封装红黑树实现map和set

news2025/4/13 3:34:19

前言：

        之前我们学习了set与map容器的如何使用，红黑树的实现。接下来我们来看看如何通过封装红黑树，实现我们自己的set与map
相关文章：oi！让我来给你唠唠咋实现红黑树☝️-CSDN博客
                超详细介绍map（multimap）的使用_mapster的map用法-CSDN博客
                超详细介绍set（multiset）的使用（C++）-CSDN博客

源码及框架分析 

        SGI-STL30版本源代码，map和set的源代码在map/set/stl_map.h/stl_set.h/stl_tree.h等几个头文件中。 map和set的实现结构框架核⼼部分截取出来如下： 

// set
#ifndef __SGI_STL_INTERNAL_TREE_H
#include <stl_tree.h>
#endif
#include <stl_set.h>
#include <stl_multiset.h>
// map
#ifndef __SGI_STL_INTERNAL_TREE_H
#include <stl_tree.h>
#endif
#include <stl_map.h>
#include <stl_multimap.h>
// stl_set.h
template <class Key, class Compare = less<Key>, class Alloc = alloc>
class set {
public:
 // typedefs:
 typedef Key key_type;
 typedef Key value_type;
private:
 typedef rb_tree<key_type, value_type, 
 identity<value_type>, key_compare, Alloc> rep_type;
 rep_type t; // red-black tree representing set
};
// stl_map.h
template <class Key, class T, class Compare = less<Key>, class Alloc = alloc>
class map {
public:
// typedefs:
 typedef Key key_type;
 typedef T mapped_type;
typedef pair<const Key, T> value_type;
private:
 typedef rb_tree<key_type, value_type, 
 select1st<value_type>, key_compare, Alloc> rep_type;
 rep_type t; // red-black tree representing map
};
// stl_tree.h
struct __rb_tree_node_base
{
 typedef __rb_tree_color_type color_type;
 typedef __rb_tree_node_base* base_ptr;
 color_type color; 
 base_ptr parent;
 base_ptr left;
 base_ptr right;
};
// stl_tree.h
template <class Key, class Value, class KeyOfValue, class Compare, class Alloc 
= alloc>
class rb_tree {
protected:
 typedef void* void_pointer;
 typedef __rb_tree_node_base* base_ptr;
 typedef __rb_tree_node<Value> rb_tree_node;
 typedef rb_tree_node* link_type;
 typedef Key key_type;
 typedef Value value_type;
public:
 // insert⽤的是第⼆个模板参数左形参 
 pair<iterator,bool> insert_unique(const value_type& x);
 
 // erase和find⽤第⼀个模板参数做形参 
 size_type erase(const key_type& x);
 iterator find(const key_type& x);
protected:
 size_type node_count; // keeps track of size of tree
 link_type header;
};
template <class Value>
struct __rb_tree_node : public __rb_tree_node_base
{
 typedef __rb_tree_nod
 Value value_field;
};

       通过下图对框架的分析，我们可以看到源码中rb_tree用了⼀个巧妙的泛型思想实现，rb_tree是实 现key的搜索场景，还是key/value的搜索场景不是直接写死的，而是由第二个模板参数Value决定 _rb_tree_node中存储的数据类型。
        set实例化rb_tree时第⼆个模板参数给的是key，map实例化rb_tree时第⼆个模板参数给的是 pair，这样⼀颗红黑树既可以实现key搜索场景的set，也可以实现key/value搜索场景的map
        要注意⼀下，源码里面模板参数是用T代表value，而内部写的value_type不是我们我们日常 key/value场景中说的value，源码中的value_type反而是红黑树结点中存储的真实的数据的类型。
        rb_tree第二个模板参数Value已经控制了红黑树结点中存储的数据类型，为什么还要传第⼀个模板参数Key呢？尤其是set，两个模板参数是一样的，这是很多同学这时的⼀个疑问。要注意的是对于map和set，find/erase时的函数参数都是Key，所以第⼀个模板参数是传给find/erase等函数做形参的类型的。对于set而言两个参数是一样的，但是对于map而言就完全不⼀样了，map、insert的是pair对象，但是find和ease的是Key对象。

模拟实现map和set 

        实现出复用红黑树的框架，并支持insert

           参考源码框架，map和set复用之前我们实现的红黑树。

           我们这里相比源码调整⼀下，key参数就用K，value参数就用V，红黑树中的数据类型，我们使用 T。

           其次因为RBTree实现了泛型不知道T参数导致是K，还是pair，那么insert内部进行插入逻辑 比较时，就没办法进行比较，因为pair的默认支持的是key和value一起参与比较，我们需要时的任 何时候只比较key，所以我们在map和set层分别实现⼀个MapKeyOfT和SetKeyOfT的仿函数传给 RBTree的KeyOfT，然后RBTree中通过KeyOfT仿函数取出T类型对象中的key，再进行比较，具体 细节参考如下代码实现。

// 源码中pair⽀持的<重载实现 
template <class T1, class T2>
bool operator< (const pair<T1, T2>& lhs, const pair<T1, T2>& rhs)
{
	return lhs.first < rhs.first || (!(rhs.first < lhs.first) &&
		lhs.second < rhs.second);
}
// Mymap.h
namespace hyc
{
	template<class K, class V>
	class map
	{
		struct MapKeyOfT
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};
	public:
		bool insert(const pair<K, V>& kv)
		{
			return _t.Insert(kv);
		}
	private:
		RBTree<K, pair<K, V>, MapKeyOfT> _t;
	};
}
// Myset.h
namespace hyc
{
	template<class K>
	class set
	{
		struct SetKeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	public:
		bool insert(const K& key)
		{
			return _t.Insert(key);
		}
	private:
		RBTree<K, K, SetKeyOfT> _t;
	};
}
// RBTree.h
enum Colour
{
	RED,
	BLACK
};
template<class T>
struct RBTreeNode
{
	T _data;
	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;
	Colour _col;
	RBTreeNode(const T& data)
		: _data(data)
		, _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
	{
	}
};
// 实现步骤： 
// 1、实现红⿊树 
// 2、封装map和set框架，解决KeyOfT 
// 3、iterator 
// 4、const_iterator 
// 5、key不⽀持修改的问题 
// 6、operator[] 
template<class K, class T, class KeyOfT>
class RBTree
{
private:
	typedef RBTreeNode<T> Node;
	Node* _root = nullptr;

public:
	bool Insert(const T& data)
	{
		if (_root == nullptr)
		{
			_root = new Node(data);
			_root->_col = BLACK;
			return true;
		}
		KeyOfT kot;
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (kot(cur->_data) < kot(data))
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (kot(cur->_data) > kot(data))
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}
		cur = new Node(data);
		Node* newnode = cur;
		// 新增结点。颜⾊给红⾊ 
		cur->_col = RED;
		if (kot(parent->_data) < kot(data))
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		cur->_parent = parent;
		//...
		return true;
	}
}

支持iterator的实现

        iterator核心源代码

struct __rb_tree_base_iterator
{
	typedef __rb_tree_node_base::base_ptr base_ptr;
	base_ptr node;
	void increment()
	{
		if (node->right != 0) {
			node = node->right;
			while (node->left != 0)
				node = node->left;
		}
		else {
			base_ptr y = node->parent;
			while (node == y->right) {
				node = y;
				y = y->parent;
			}
			if (node->right != y)
				node = y;
		}
	}
	void decrement()
	{
		if (node->color == __rb_tree_red &&
			node->parent->parent == node)
			node = node->right;
		else if (node->left != 0) {
			base_ptr y = node->left;
			while (y->right != 0)
				y = y->right;
			node = y;
		}
		else {
			base_ptr y = node->parent;
			while (node == y->left) {
				node = y;
				y = y->parent;
			}
			node = y;
		}
	}
};
template <class Value, class Ref, class Ptr>
struct __rb_tree_iterator : public __rb_tree_base_iterator
{
	typedef Value value_type;
	typedef Ref reference;
	typedef Ptr pointer;
	typedef __rb_tree_iterator<Value, Value&, Value*> iterator;
	__rb_tree_iterator() {}
	__rb_tree_iterator(link_type x) { node = x; }
	__rb_tree_iterator(const iterator& it) { node = it.node; }
	reference operator*() const { return link_type(node)->value_field; }
#ifndef __SGI_STL_NO_ARROW_OPERATOR
	pointer operator->() const { return &(operator*()); }
#endif /* __SGI_STL_NO_ARROW_OPERATOR */
	self& operator++() { increment(); return *this; }
	self& operator--() { decrement(); return *this; }

	inline bool operator==(const __rb_tree_base_iterator& x,
		const __rb_tree_base_iterator& y) {
		return x.node == y.node;
	}
	inline bool operator!=(const __rb_tree_base_iterator& x,
		const __rb_tree_base_iterator& y) {
		return x.node != y.node;
	}

iterator实现思路分析

         1. 迭代器实现框架：与list迭代器思路一致，用类型封装结点指针，通过重载运算符实现类似指针的访问行为。

        2. operator++实现难点：map和set迭代器按中序遍历（左子树->根结点->右子树），begin()返回中序第一个结点迭代器，其核心逻辑是考虑当前中序局部要访问的下一个结点：
         若当前结点右子树不为空，下一个结点是右子树的最左结点。 
         若当前结点右子树为空，需沿祖先路径向上找：当前结点是父结点左孩子时，下一个结点是父结点；当前结点是父结点右孩子时，继续往上找，直到找到孩子是父结点左孩子的祖先。

        3. end()表示：可用nullptr充当end，STL红黑树用哨兵位头结点作为end()，二者差别不大，--end()时若结点为空，特殊处理让迭代器结点指向最右结点。

        4. operator--实现：与++思路类似，逻辑相反，访问顺序为右子树->根结点->左子树。

        5. set和map迭代器修改权限：set迭代器不支持修改，将第二个模板参数改成const K；map迭代器不支持修改key但可修改value，将第二个模板参数pair的第一个参数改成const K。

map支持[] 

        map要支持[]主要需要修改insert返回值支持，修改RBtree中的insert返回值为 pair<Iterator,bool> Insert (const T& data)

map和set实现

//myMap.h
#include"RBTree.h"

namespace hyc
{
	template<class K,class V>
	class map
	{
		struct MapKeyOfT
		{
			//operator
			const K& operator()(const pair<K,V>& a)
			{
				return a.first;
			}
		};

	public:
		typedef typename RBTree<K, pair<const K, V>, MapKeyOfT>::Iterator iterator;
		typedef typename RBTree<K, pair<const K, V>, MapKeyOfT>::ConstIterator const_iterator;

		iterator begin()
		{
			return _t.Begin();
		}

		iterator end()
		{
			return _t.End();
		}

		const_iterator begin() const
		{
			return _t.Begin();
		}

		const_iterator end() const
		{
			return _t.End();
		}

		pair<iterator, bool> insert(const pair<K,V>& key)
		{
			return _t.Insert(key);
		}

		V& operator[](const K& key)
		{ 
			pair<iterator, bool> ret = insert({ key,V() });
			return ret.first->second;
		}

		RBTree<K, pair<const K,V>, MapKeyOfT> _t;
	};
}


//mySet.h
#include"RBTree.h"

namespace hyc
{
	template<class K>
	class set
	{
		struct SetKeyOfT
		{
			const K& operator()(const K& a)
			{
				return a;
			}
		};

	public:
		typedef typename RBTree<K, const K, SetKeyOfT>::Iterator iterator;
		typedef typename RBTree<K, const K, SetKeyOfT>::ConstIterator const_iterator;

		iterator begin()
		{
			return _t.Begin();
		}

		iterator end()
		{
			return _t.End();
		}

		const_iterator begin() const
		{
			return _t.Begin();
		}

		const_iterator end() const
		{
			return _t.End();
		}

		pair<iterator,bool> insert(const K& key)
		{
			return _t.Insert(key);
		}


		RBTree<K,const K, SetKeyOfT> _t;
	};
}


//RBTree.h
#include<iostream>
using namespace std;
//红黑树：二叉搜索树+4条红黑树规则
// 1.红黑树所有节点有且只有两种颜色：红、黑
// 2.红黑树的根必须为黑色
// 3.红色节点的孩子必须为黑色
// 4.对于任意一个节点，从这个节点开始到NULL节点的黑色节点数量都是一样的


// 枚举值表⽰颜⾊ 
enum Colour
{
	RED,
	BLACK,
};

// 这里我们默认按key/value结构实现 
template<class T>
struct RBTreeNode
{
	// 这⾥更新控制平衡也要加⼊parent指针 
	T _kv;
	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;
	Colour _col;

	RBTreeNode(const T& kv)//const?
		:_kv(kv)
		, _left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		,_col(RED)
	{}
};

template<class T, class Ref, class Ptr>
struct RBTreeIterator
{
	typedef RBTreeNode<T> Node;
	typedef RBTreeIterator<T, Ref, Ptr> Self;

	Node* _node;
	Node* _root;

	RBTreeIterator(Node* node,Node* root)
		:_node(node)
		,_root(root)
	{
	}


	// 完善迭代器的++操作，让迭代器可以移动
	Self& operator++()
	{
		//如果右不为null，找右树的最左节点
		if(_node->_right)
		{
			Node* cur = _node->_right;
			while (cur->_left)
			{
				cur = cur->_left;
			}
			_node = cur;
		}
		else//右为空，则去找孩子是父亲左边的祖先
		{
			Node* cur = _node;
			Node* parent = cur->_parent;
			while (parent && parent->_right== cur)
			{
				cur = parent;
				parent = parent->_parent;
			}
			_node = parent;
		}

		return *this;
	}

	//与++的逻辑相反
	Self& operator--()
	{
		//当为end()时，返回最右节点
		if (_node == nullptr)
		{
			Node* cur = _root;
			while (cur &&cur->_right)
			{
				cur = cur->_right;
			}
			_node = cur;
		}
		//如果左子树不为空,则去找左子树的最右节点
		else if (_node->_left)
		{
			Node* cur = _node->_left;
			while (cur->_right)
			{
				cur = cur->_right;
			}
			_node = cur;
		}
		else//如果左子树为空, 则去找孩子是父亲右的祖先
		{
			Node* cur = _node;
			Node* parent = cur->_parent;
			while(parent&&parent->_left==cur)
			{
				cur = parent;
				parent = parent->_parent;
			}
			_node = parent;
		}

		return *this;
	}


	// 完善下面两个操作，让迭代器可以像指针一样操作
	T& operator*()
	{
		return _node->_kv;
	}

	T* operator->()//返回指针
	{
		return &_node->_kv;
	}

	// 完善下面两个操作，让迭代器能够支持比较
	bool operator!=(const Self& s)const
	{
		return _node != s._node;
	}

	bool operator==(const Self& s)const
	{
		return _node == s._node;
	}
};

template<class K, class V,class KetOfT>
class RBTree
{
	//typedef RBTreeNode<V> Node;
	using Node = RBTreeNode<V>;
public:
	typedef RBTreeIterator<V, V&, V*> Iterator;
	typedef RBTreeIterator<V, const V&, const V*> ConstIterator;

	Iterator Begin()
	{
		Node* cur = _root;
		while (cur && cur->_left)
		{
			cur = cur->_left;
		}
		return Iterator(cur,_root);//调用构造函数
	}

	Iterator End()
	{
		return Iterator(nullptr, _root);
	}

	ConstIterator Begin() const
	{
		Node* cur = _root;
		while (cur && cur->_left)
		{
			cur = cur->_left;
		}
		return ConstIterator(cur, _root);//调用构造函数
	}

	ConstIterator End() const
	{
		return ConstIterator(nullptr, _root);
	}

	KetOfT kot;
	Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv < key)
			{
				cur = cur->_right;
			}
			else if (cur->_kv > key)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}
		return nullptr;
	}


	pair<Iterator,bool> Insert(const V& kv)
	{
		Node* cur = _root;
		Node* parent = cur;

		if (!cur)//如果是空树
		{
			_root = new Node(kv);
			_root->_col = BLACK;
			//return pair<Iterator, bool>(Iterator(_root, _root), true);
			return  { Iterator(_root, _root), true };
			
		}

		while(cur)
		{
			if (kot(cur->_kv) > kot(kv))
			{
				parent = cur;
				cur = parent->_left;
			}
			else if (kot(cur->_kv) < kot(kv))
			{
				parent = cur;
				cur = parent->_right;
			}
			else
			{
				return  { Iterator(cur, _root), false };
			}
		}
		cur = new Node(kv);
		if (kot(parent->_kv) > kot(kv))
			parent->_left = cur;
		else
			parent->_right = cur;

		//连接至上一层
		cur->_parent = parent;

		Node* newNode = cur;
		//判断是否满足条件
		while (parent&&parent->_col == RED)
		{
			Node* pparent = parent->_parent;

			//先讨论parent在左边的情况
			if (pparent->_left == parent)
			{
				Node* uncle = pparent->_right;
				//uncle存在且为红 -> 变色
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					pparent->_col = RED;

					cur = pparent;
					parent = cur->_parent;
				}
				else
				{
					//单旋+变色
					if (parent->_left == cur)
					{
						RotateR(pparent);
						pparent->_col = RED;
						parent->_col = BLACK;
						break;
					}
					//双旋+变色
					else
					{
						RotateL(parent);
						RotateR(pparent);
						pparent->_col = RED;
						cur->_col = BLACK;
						break;
					}
				}
			}
			else//再讨论parent在右边的情况
			{
				Node* uncle = pparent->_left;
				//uncle存在且为红 -> 变色
				if (uncle && uncle->_col == RED)
				{
					parent->_col = uncle->_col = BLACK;
					pparent->_col = RED;

					cur = pparent;
					parent = cur->_parent;
				}
				else
				{
					//单旋+变色
					if (parent->_right == cur)
					{
						RotateL(pparent);
						parent->_col = BLACK;
						pparent->_col = RED;
						break;
					}
					else//双旋+变色
					{
						RotateR(parent);
						RotateL(pparent);
						cur->_col = BLACK;
						pparent->_col = RED;
						break;
					}
				}
			}
			_root->_col = BLACK;
		}
		return  { Iterator(newNode, _root), true};
	}

	//右单旋
	void RotateR(Node* parent)
	{
		Node* pparent = parent->_parent;
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		if(subLR)
			subLR->_parent = parent;
		parent->_left = subLR;
		
		subL->_right = parent;
		parent->_parent = subL;

		if (!pparent)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (pparent->_left == parent)
			{
				subL->_parent = pparent;
				pparent->_left = subL;
			}
			else
			{
				subL->_parent = pparent;
				pparent->_right = subL;
			}
		}
	}

	//左单旋
	void RotateL(Node* parent)
	{
		Node* pparent = parent->_parent;
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;

		subR->_left = parent;
		parent->_parent = subR;

		if(!pparent)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			if (pparent->_left == parent)
			{
				pparent->_left = subR;
				subR->_parent = pparent;
			}
			else
			{
				pparent->_right = subR;
				subR->_parent = pparent;
			}
		}
	}

private:
	
	Node* _root = nullptr;
};

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2331824.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

解码AI大脑：Claude的思维显微镜与语言炼金术

解码AI大脑：Claude的思维显微镜与语言炼金术

&#xff08;前些天发现了一个巨牛的人工智能学习网站&#xff0c;通俗易懂&#xff0c;风趣幽默&#xff0c;忍不住分享一下给大家。点击跳转到网站&#xff09;。 一、多语言思维实验&#xff1a;Claude的“概念空间”如何运转&#xff1f; 跨语言谜题&#xff1a;反义词的…
阅读更多...
中科岩创基坑自动化监测解决方案

中科岩创基坑自动化监测解决方案

1.行业现状 城市基坑开挖具有施工风险高、施工难度大等特点。由于地下土体性质、荷载条件、施工环境的复杂性&#xff0c;单根据地质勘察资料和室内土工试验参数来确定设计和施工方案&#xff0c;往往含有许多不确定因素&#xff0c;对在施工过程中引发的土体性状、环境、邻近建…
阅读更多...
机器学习01-支持向量机（SVM）（未完）

机器学习01-支持向量机（SVM）（未完）

参考浙大 胡浩基老师 的课以及以下链接&#xff1a; https://blog.csdn.net/m0_74100344/article/details/139560508 https://blog.csdn.net/2301_78630677/article/details/132657023 https://blog.csdn.net/lsb2002/article/details/131338700 一、一些定义 T是倒置&…
阅读更多...
[ctfshow web入门] web32

[ctfshow web入门] web32

前置知识 协议相关博客&#xff1a;https://blog.csdn.net/m0_73353130/article/details/136212770 include&#xff1a;include "filename"这是最常用的方法&#xff0c;除此之外还可以 include url&#xff0c;被包含的文件会被当做代码执行。 data://&#xff1a…
阅读更多...
鸿蒙开发中的并发与多线程

鸿蒙开发中的并发与多线程

文章目录 前言异步并发 (Promise和async/await)多线程并发并发能力选择耗时任务并发执行场景常见业务场景 常驻任务并发执行场景常见业务场景 传统共享内存并发业务长时任务并发执行场景常见业务场景 并发任务管理线程间通信同语言线程间通信&#xff08;ArkTS内&#xff09;线…
阅读更多...
TCP和UDP的区别是什么？

TCP和UDP的区别是什么？

1. 基本特性: TCP&#xff1a; 面向连接&#xff1a;在数据传输开始前&#xff0c;TCP需要在通信双方建立连接&#xff08;三次握手&#xff09;。可靠性&#xff1a;TCP保证数据的可靠传输&#xff0c;通过确认应答、重传机制、数据包顺序等确保数据无误到达。流量控制和拥塞…
阅读更多...
MySQL 函数（入门版）

MySQL 函数（入门版）

目录 一、字符串函数 1、常用的字符串函数 2、函数演示 3、具体案例 二、数值函数 1、常用的数值函数 2、函数演示 3、具体案例 三、日期函数 1、常用的日期函数 2、函数演示 3、具体案例 四、流程函数 1、常用的流程函数 2、函数演示 3、具体案例 在MySQL中&a…
阅读更多...
Simulink中Signal Builder在新版中找不到怎么办

Simulink中Signal Builder在新版中找不到怎么办

在较新的MATLAB版本中&#xff0c;新版Simulink中的Signal Builder用Signal Editor作为替代工具。 signal builder not shown in matlab - MATLAB Answers - MATLAB Central signalBuilderToSignalEditor 1.打开上面第二个链接 2.点击拷贝 3.然后在命令行中粘贴 4.然后就会…
阅读更多...
SvelteKit 最新中文文档教程（19）—— 最佳实践之身份认证

SvelteKit 最新中文文档教程（19）—— 最佳实践之身份认证

前言 Svelte&#xff0c;一个语法简洁、入门容易&#xff0c;面向未来的前端框架。 从 Svelte 诞生之初&#xff0c;就备受开发者的喜爱&#xff0c;根据统计&#xff0c;从 2019 年到 2024 年&#xff0c;连续 6 年一直是开发者最感兴趣的前端框架 No.1&#xff1a; Svelte …
阅读更多...
Cursor编程-从入门到精通__0409

Cursor编程-从入门到精通__0409

早期的Github Copilot 最近更新了&#xff0c;支持Agent编程&#xff0c;字节跳动Trae使用&#xff08;免费&#xff09;&#xff0c;但成熟程度不如Cursor&#xff0c;Cursor前50次免费 Copilot VS Cursor*** 1&#xff0c;Cursor VSCode 二次开发&#xff0c;IDE级别 2&…
阅读更多...
VSCode、clangd、mingw 配置与使用

VSCode、clangd、mingw 配置与使用

1.安装 安装如下软件&#xff1a; VSCodeclangd 扩展mingw-w64 2.配置 配置好 mingw-w64 到用户环境中。 在项目中设置 .clangd 扩展&#xff0c;设置 argument //setting.json"clangd.arguments": ["--query-driverD:\\Development\\Tools\\mingw64\\bin…
阅读更多...
深度学习处理文本（14）

深度学习处理文本（14）

使用Transformer进行序列到序列学习 正是序列到序列学习让Transformer真正大放异彩。与RNN相比，神经注意力使Transformer模型能够处理更长、更复杂的序列。要将英语翻译成西班牙语，你不会一个单词一个单词地阅读英语句子，将其含义保存在记忆中，然后再一个单词一个单词地生…
阅读更多...
核心案例 | 湖南汽车工程职业大学无人机操控与编队技术实验室

核心案例 | 湖南汽车工程职业大学无人机操控与编队技术实验室

核心案例 | 湖南汽车工程职业大学无人机操控与编队技术实验室 为满足当今无人机行业应用需求&#xff0c;推动无人机技术的教育与实践深度融合&#xff0c;北京卓翼智能科技有限公司旗下品牌飞思实验室与湖南汽车工程职业大学强强联手&#xff0c;共同建设无人机操控与编队技术…
阅读更多...
Oracle 查看后台正在执行的 SQL 语句

Oracle 查看后台正在执行的 SQL 语句

在 Oracle 数据库中&#xff0c;要查看后台正在执行的 SQL 语句&#xff0c;可以通过查询动态性能视图&#xff08;Dynamic Performance Views&#xff09;或使用监控工具来实现。 1. 查询动态性能视图 (1) 查看当前活跃会话及其执行的 SQL 使用 v$session 和 v$sql 视图关联…
阅读更多...
SpringBoot整合MinIO快速入门：实现分布式文件存储与管理

SpringBoot整合MinIO快速入门：实现分布式文件存储与管理

文章目录 一、MinIO是什么&#xff1f;为什么选择它&#xff1f;1.1 什么是MinIO&#xff1f;1.2 核心优势 二、本地快速搭建MinIO服务2.1 Docker一键部署2.2 访问管理界面2.3 创建存储桶&#xff08;Bucket&#xff09; 三、SpringBoot集成MinIO客户端3.1 添加Maven依赖3.2 配…
阅读更多...
我的NISP二级之路-03

我的NISP二级之路-03

目录 一.ISMS 二.IP 三.http 四.防火墙 五.文件 解析 解析 六.攻击 解析 解析 七.风险管理工程 八.信息系统安全保护等级 九.我国信息安全保障 一.ISMS 1.文档体系建设是信息安全管理体系(ISMS)建设的直接体现&#xff0c;下列说法不正确的是&#xff1a; A&#…
阅读更多...
Oracle 表空间高水位收缩全攻略

Oracle 表空间高水位收缩全攻略

1. 概述 本文档是针对某个特定用户表空间收缩的文档&#xff0c;实际操作要结合生产库具体情况。主要包括以下几个流程&#xff1a; 收集当前数据库相关信息降低数据库表高水位线Resize 收缩数据文件 具体细节详见以下章节。 2. 时间规划 操作类型预估时间实际时间数据库信…
阅读更多...
ESModule和CommonJS在Node中的区别

ESModule和CommonJS在Node中的区别

ESModule console.log(require);//>errorconsole.log(module);//>errorconsole.log(exports);//>errorconsole.log(__filename);//>errorconsole.log(__dirname);//>error全部报错commonjs console.log(require);console.log(module);console.log(exports);co…
阅读更多...
力扣刷题-热题100题-第34题（c++、python）

力扣刷题-热题100题-第34题（c++、python）

23. 合并 K 个升序链表 - 力扣&#xff08;LeetCode&#xff09;https://leetcode.cn/problems/merge-k-sorted-lists/?envTypestudy-plan-v2&envIdtop-100-liked 顺序合并 合并两个有序链表作为子函数&#xff0c;创建一个空链表&#xff0c;然后对含有多个链表的数组进…
阅读更多...
原生SSE实现AI智能问答+Vue3前端打字机流效果

原生SSE实现AI智能问答+Vue3前端打字机流效果

实现流程&#xff1a; 1.用户点击按钮从右侧展开抽屉&#xff08;drawer&#xff09;&#xff0c;打开模拟对话框 2.用户输入问题&#xff0c;点击提问按钮&#xff0c;创建一个SSE实例请求后端数据&#xff0c;由于SSE是单向流&#xff0c;所以每提一个问题都需要先把之前的实…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023