C++进阶—红黑树详解及map、set封装（3）

news2024/11/18 19:48:16

 

目录

1. 红黑树的概念

2. 红黑树的性质

3. 红黑树节点的定义

4. 红黑树性质分析

5. 红黑树插入节点简要分析（新插入节点的parent为红色）

5.1 简要分析1-变色：

5.2 简要分析2-变色+旋转

5.3 简要分析总结

6. 红黑树插入节点详细分析

6.1 情况一: cur为红，p为红，g为黑，u存在且为红

6.2 情况二: cur为红，p为红，g为黑，u不存在/u存在且为黑

6.2.1 a/b/c/d/e是空树，uncle不存在，cur就是新增

6.2.2 a/b/c/d/e不是空树，uncle存在且为黑，cur原黑

6.3 红黑树插入代码实现

6.4 红黑树的验证

7. 红黑树的其他

7.1 红黑树的删除

7.2 红黑树与AVL树的比较

7.3 红黑树的应用

8. 红黑树的封装实现STL中的map与set

8.1 红黑树的迭代器

8.2 改造红黑树

8.3 map封装红黑树的实现

8.4 set的模拟实现

8.5 其他功能的实现

1. 红黑树的概念

红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或 Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路 径会比其他路径长出俩倍，因而是接近平衡的。

 

2. 红黑树的性质

  1. 每个结点不是红色就是黑色
  2. 根节点是黑色的 
  3. 如果一个节点是红色的，则它的两个孩子结点是黑色的 
  4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点 
  5. 每个叶子结点都是黑色的(此处的叶子结点指的是空结点)（也叫做NIL节点）

3. 红黑树节点的定义

enum color {
	BLACK,
	RED
};

template<class K, class V>
class RBTreeNode {
public:
	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;

	color _col;//节点的值域
	pair<K, V> _kv;//结点的颜色

	RBTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		,_kv(kv)
	{}
};

4. 红黑树性质分析

问题一：红黑树是如何控制最长路径节点个数不会超过最短路径的二倍？

答：路径最长状态：一黑一红

       路径极限最短状态·：全是黑（不会出现）

       因为每条路径黑色节点数相同，因此极限状态下，最长路径节点数不会超过最短路径的二倍！！！

问题二：新插入节点的颜色应该选用黑色还是红色

 

答：如上图，如果新插入节点节点为黑色，则违反性质4，即每条路径节点颜色为黑色的数量相同！

  • 插入黑色，明显是抗衡性质4，需要对每条路径，每个节点遍历，找出最短路径，且调整困难
  • 插入红色，明显是抗衡性质3，仅需通过判断父节点是否为红色，为红色则需要调整，为黑色，则直接插入成功

【总结】：

        红黑树主要是通过颜色使其保持平衡，且最长路径不超过最短路径的二倍

5. 红黑树插入节点简要分析（新插入节点的parent为红色）

红黑树插入调整主要是变色+旋转，红黑树没有AVL树那么直观，AVL树通过平衡因子即可判断其控制方向而红黑树是通过观察颜色的规则，只要控制颜色规则，其就间接控制了最长路径就不会超过最短路径的二倍！

5.1 简要分析1-变色：

         如上图，因为新插入节点为红色，而其parent也为红色，将parent变黑，导致了增加黑节点，性质4被破坏，而parent节点为红色，其grandfather必定为黑，将grandfather变红，也 需要控制parent的uncle为黑色，才能保持性质4被调整正确！！！

【注】在满足条件时，层层上调，保证了其性质4不会被破坏，针对其他情况，提出其他解决方案

调整完毕后，进而在加cur = grandfather，层层转换，最终，将cur变为黑色便可调增完成。

5.2 简要分析2-变色+旋转

在分析1中，可能会面临uncle为黑色节点，此时变色便被终止，解决方法就是通过旋转方式+变色得到正确的二叉平衡搜索树

 

5.3 简要分析总结

但是上述调节过程层层转换可能会面临：

  • 情况一：uncle为空，或者uncle的颜色为黑色
  • 情况二：不断处理过程中，cur的parent为黑色，此树便处理完成，如下图

  • 情况三：cur走到根节点，此时cur为所有路径的根，且cur为红色，只需要将cur颜色变为黑色，此树便处理完成

6. 红黑树插入节点详细分析

通过上述分析得出以下判决条件：

1. 新插入节点为根，跟为黑色；

2. 新插入节点的parent为红色，则又分为以下判决条件：

    条件一：parent为红色，其uncle也为红色，层层上调（变色）

    条件二：上调过程中遇到uncle为空，或则uncle颜色为黑色（变色+旋转）

    条件三：上调过程中cur的parent为黑色，处理完成

    条件四：上调cur到根节点，即parent为空，此树处理完成

3. 层层调整走完，最后将根节点的颜色变为黑色（对于其他情况根节点的统一处理没有任何影响）

4. 新插入节点的parent为黑色，则不做处理

因为新节点的默认颜色是红色，因此：如果其双亲节点的颜色是黑色，没有违反红黑树任何 性质，则不需要调整；但当新插入节点的双亲节点颜色为红色时，就违反了性质三不能有连 在一起的红色节点，此时需要对红黑树分情况来讨论：

约定:cur为当前节点，p为parent父节点，g为grandfather祖父节点，u为uncle叔叔节点

6.1 情况一: cur为红，p为红，g为黑，u存在且为红

【注意】此处所看到的树，可能是一颗完整的树，也可能是一颗子树

上图为层层处理的具象图，及分析 

解决方式：将p,u改为黑，g改为红，然后把g当成cur，继续向上调整。

6.2 情况二: cur为红，p为红，g为黑，u不存在/u存在且为黑

说明： u的情况有两种

  1. 如果u节点不存在，则cur一定是新插入节点，因为如果cur不是新插入节点，则cur和p一定有一个节点的颜色是黑色，就不满足性质4：每条路径黑色节点个数相同。
  2. 如果u节点存在，则其一定是黑色的，那么cur节点原来的颜色一定是黑色的。现在看到其是红色的原因是因为cur的子树在调整的过程中将cur节点的颜色由黑色改成红色。

 根据上述两种情况分别分析：

6.2.1 a/b/c/d/e是空树，uncle不存在，cur就是新增

主要有以下四种情况

1.parent == grandfather->_left && cur = parent->_left，以grandfather为轴点，进行右单旋

 2.parent == grandfather->_right && cur = parent->_right，以grandfather为轴点，进行左单旋

 

3.parent == grandfather->_left && cur = parent->_right，双旋 + 变色，以parent为轴点，进行左单旋，以grandfather为轴点，进行右单旋

4. parent == grandfather->_right && cur = parent->_left，双旋 + 变色，以parent为轴点，进行右单旋，以grandfather为轴点，进行左单旋

上述是uncle不存在的情况下，abcde必是空树 ，分别的处理措施

6.2.2 a/b/c/d/e不是空树，uncle存在且为黑，cur原黑

下图皆为具象图，包含多种情况，统一处理得来，cur原本是黑的，但是由于a或者b得新增，层层上调，导致其cur变红，且遇到uncle存在且为黑。

主要有以下四种情况：

1.parent == grandfather->_left && cur = parent->_left，以grandfather为轴点，进行右单旋

 

2.parent == grandfather->_right && cur = parent->_right，以grandfather为轴点，进行左单旋

 

3.parent == grandfather->_left && cur = parent->_right，双旋 + 变色，以parent为轴点，进行左单旋，以grandfather为轴点，进行右单旋

 

4. parent == grandfather->_right && cur = parent->_left，双旋 + 变色，以parent为轴点，进行右单旋，以grandfather为轴点，进行左单旋

 上述是uncle存在的情况下，abcde可能不是空树 ，分别的处理措施

6.3 红黑树插入代码实现

插入具体代码实现：

bool Insert(const pair < K, V>& kv) {
		if (_root == nullptr) {
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur) {
			if (kv.first > cur->_kv.first) {
				parent = cur;
				cur = cur->_right;
			}
			else if (kv.first < cur->_kv.first) {
				parent = cur;
				cur = cur->_left;
			}
			else {
				return false;
			}
		}
		cur = new Node(kv);
		cur->_col = RED;
		if (parent->_kv.first < kv.first) {
			parent->_right = cur;
		}
		else {
			parent->_left = cur;
		}
		cur->_parent = parent;

		//cur为红色，且parent也为红色，违反性质3
		//if (parent->_col == RED) {
		//	Node* grandfather;
		//	Node* uncle;

		//	while (cur != _root) {
		//		if (cur->_parent->_col == BLACK) {
		//			return true;
		//		}
		//		parent = cur->_parent;
		//		grandfather = parent->_parent;
		//		uncle = grandfather->_left;
		//		if (parent == grandfather->_left) {
		//			uncle = grandfather->_right;
		//		}
		//		if (uncle == nullptr || uncle->_col == BLACK) {
		//			if (grandfather->_left == parent && parent->_left == cur) {
		//				//右旋
		//				RotateR(grandfather);
		//			}
		//			else if (grandfather->_right == parent && parent->_right == cur) {
		//				RotateL(grandfather);
		//			}
		//			else if (grandfather->_left == parent && parent->_right == cur) {
		//				RotateLR(cur);
		//			}
		//			else if (grandfather->_right == parent && parent->_left == cur) {
		//				RotateRL(cur);
		//			}
		//			else {
		//				assert(false);
		//			}
		//			return true;
		//		}
		//		parent->_col = BLACK;
		//		uncle->_col = BLACK;
		//		grandfather->_col = RED;
		//		cur = grandfather;
		//	}
		//	if(cur == _root){
		//		cur->_col = BLACK;
		//	}
		//}
		///cur为红色，且parent也为黑色，返回true
		while (parent && parent->_col == RED) {
			Node* grandfather = parent->_parent;
			assert(grandfather && grandfather->_col == BLACK);
			Node* uncle = grandfather->_left;
			if (parent == grandfather->_left) {
				uncle = grandfather->_right;
			}
			if (uncle && uncle->_col == RED) {
				parent->_col = uncle->_col = BLACK;
				grandfather->_col = RED;
				//继续往上处理
				cur = grandfather;
				parent = cur->_parent;
			}
			//情况二：uncle不存在 || 存在且为黑
			else {
				if (grandfather->_left == parent && parent->_left == cur) {
					RotateR(grandfather);
				}
				else if (grandfather->_right == parent && parent->_right == cur) {
					RotateL(grandfather);
				}
				else if (grandfather->_left == parent && parent->_right == cur) {
					RotateLR(cur);
				}
				else if (grandfather->_right == parent && parent->_left == cur) {
					RotateRL(cur);
				}
				else {
					assert(false);
				}
				return true;
			}
		}
		_root->_col = BLACK;
		return true;
	}

旋转代码实现：

	void RotateL(Node* parent) {
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		subR->_left = parent;
		Node* pParent = parent->_parent;
		if (parent == _root) {
			_root = subR;
		}
		else {
			if (parent == pParent->_left) {
				pParent->_left = subR;
			}
			else {
				pParent->_right = subR;
			}
		}
		subR->_parent = pParent;
		parent->_parent = subR;
		parent->_right = subRL;
		if (subRL) {
			subRL->_parent = parent;
		}
		parent->_col = RED;
		subR->_col = BLACK;
	}
	void RotateR(Node* parent) {
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		subL->_right = parent;
		Node* pParent = parent->_parent;
		if (parent == _root) {
			_root = subL;
		}
		else {
			if (parent == pParent->_left) {
				pParent->_left = subL;
			}
			else {
				pParent->_right = subL;
			}
		}
		subL->_parent = pParent;
		parent->_parent = subL;
		parent->_left = subLR;
		if (subLR) {
			subLR->_parent = parent;
		}
		parent->_col = RED;
		subL->_col = BLACK;
	}
	void RotateLR(Node* cur) {
		Node* parent = cur->_parent;
		Node* grandfather = parent->_parent;
		RotateL(parent);
		RotateR(grandfather);
		cur->_col = BLACK;
		grandfather->_col = RED;
	}
	void RotateRL(Node* cur) {
		Node* parent = cur->_parent;
		Node* grandfather = parent->_parent;
		RotateR(parent);
		RotateL(grandfather);
		cur->_col = BLACK;
		grandfather->_col = RED;
	}

6.4 红黑树的验证

红黑树的检测分为两步：

  1. 检测其是否满足二叉搜索树(中序遍历是否为有序序列)
  2. 检测其是否满足红黑树的性质（性质2、性质3、性质4）

检测性质4以某条路径黑色节点数量作为基准值，或者传引用，记录第一条路径黑色节点数量，进而，遍历每条路径

public:
	bool IsBalance() {
		if (_root == nullptr) {
			return true;
		}
		if (_root->_col == RED) {
			cout << "性质2：根节点不是黑色" << endl;
			return false;
		}
		//黑色节点基准值
		int benchmark = 0;
		Node* cur = _root;
		while (cur) {
			if (cur->_col == BLACK) {
				++benchmark;
			}
			cur = cur->_left;
		}
		return _PrevCheck(_root, 0, benchmark);
	}
private:
	bool _PrevCheck(Node* root, int blackNum, int benchmark) {
		if (root == nullptr) {
			if (blackNum != benchmark) {
				cout << "性质4：某条路径黑色节点数量不相等" << endl;
				return false;
			}
			else {
				return true;
			}
		}
		if (root->_col == BLACK) {
			++blackNum;
		}
		if (root->_col == RED && root->_parent->_col == RED) {
			cout << "性质3：存在连续红色节点" << endl;
			return false;
		}
		return _PrevCheck(root->_left, blackNum, benchmark)
			&& _PrevCheck(root->_right, blackNum, benchmark);
	}

7. 红黑树的其他

7.1 红黑树的删除

可参考：《算法导论》或者《STL源码剖析》

红黑树 - _Never_ - 博客园 (cnblogs.com)

7.2 红黑树与AVL树的比较

        红黑树和AVL树都是高效的平衡二叉树，增删改查的时间复杂度都是O($log_2 N$)，红黑树不追求绝对平衡，其只需保证最长路径不超过最短路径的2倍，相对而言，降低了插入和旋转的次数， 所以在经常进行增删的结构中性能比AVL树更优，而且红黑树实现比较简单，所以实际运用中红黑树更多。

7.3 红黑树的应用

C++ STL库 -- map/set、mutil_map/mutil_set

Java 库

linux内核

其他一些库

8. 红黑树的封装实现STL中的map与set

STL源码分析，对map、set及tree进行分析（只分析其结构及封装形式）：

 

 由上述分析可以观察的出map、set底层对红黑树的封装，迭代器也采用了红黑树迭代器的实现

8.1 红黑树的迭代器

在STL中为了后续实现关联式容器简单，更好的实现迭代器，红黑树的实现中增加一个头结点，因为跟节点必须为黑色，为了与根节点进行区分，将头结点给成黑色，并且让头结点的 pParent 域指向红黑树的根节点，pLeft 域指向红黑树中最小的节点，_pRight域指向红黑树中最大的节点，如下：

迭代器的好处是可以方便遍历，是数据结构的底层实现与用户透明。如果想要给红黑树增加迭代器，需要考虑以前问题：

        begin()与end()STL中的实现：

STL明确规定，begin()与end()代表的是一段前闭后开的区间，而对红黑树进行中序遍历后， 可以得到一个有序的序列，因此：begin()可以放在红黑树中最小节点(即最左侧节点)的位 置，end()放在最大节点(最右侧节点)的下一个位置，关键是最大节点的下一个位置在哪块？ 能否给成nullptr呢？答案是行不通的，因为对end()位置的迭代器进行--操作，必须要能找最 后一个元素，此处就不行，因此最好的方式是将end()放在头结点的位置。

        begin()与end()不采用新增头节点实现：

如果不采用STL中的新增头节点的实现方式，其也可以通过遍历的方式线，end()指向nullptr，在迭代器操++、--作中，通过条件判断，便可依次遍历每个节点。

8.2 改造红黑树

// 因为关联式容器中存储的是<key, value>的键值对，因此
// k为key的类型，
// ValueType: 如果是map，则为pair<K, V>; 如果是set，则为k
// KeyOfValue: 通过value来获取key的一个仿函数类
enum color {
	BLACK,
	RED
};

template<class T>
class RBTreeNode {
public:
	RBTreeNode<T>* _left;
	RBTreeNode<T>* _right;
	RBTreeNode<T>* _parent;
	T _data;
	color _col;

	RBTreeNode(const T& data)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _col(RED)
		, _data(data)
	{}
};

template<class T, class Ref, class Ptr>
struct __RBTree_Iterator {
	typedef RBTreeNode<T> Node;
	typedef __RBTree_Iterator<T, Ref, Ptr> Self;
	Node* _node;

	__RBTree_Iterator(Node* node)
		:_node(node)
	{}

	Ref operator*() {
		return _node->_data;
	}
	Ptr operator->() {
		return &(_node->_data);
	}
	Self& operator++() {
		if (_node->_right) {
			//找右树最左节点
			_node = _node->_right;
			while (_node && _node->_left) {
				_node = _node->_left;
			}
		}
		else {
			Node* parent = _node->_parent;
			//找孩子不是父亲右的祖先
			while (parent && parent->_right == _node) {
				_node = _node->_parent;
				parent = _node->_parent;
			}
			_node = parent;
		}
		return *this;
	}
	Self operator++(int) {
		Self prevIterator = Self(_node);
		if (_node->_right) {
			//找右树最左节点
			_node = _node->_right;
			while (_node && _node->_left) {
				_node = _node->_left;
			}
		}
		else {
			Node* parent = _node->_parent;
			//找孩子不是父亲右的祖先
			while (parent && parent->_right == _node) {
				_node = _node->_parent;
				parent = _node->_parent;
			}
			_node = parent;
		}
		return prevIterator;
	}
	Self& operator--() {
		if (_node->_left) {
			_node = _node->_left;
			while (_node && _node->_right) {
				_node = _node->_right;
			}
		}
		else {
			Node* parent = _node->_parent;
			while (parent && parent->_left == _node) {
				_node = parent;
				parent = _node->_parent;
			}
			_node = parent;
		}
		return *this;
	}
	Self operator--(int) {
		Self prevIterator = Self(_node);
		if (_node->_left) {
			_node = _node->_left;
			while (_node && _node->_right) {
				_node = _node->_right;
			}
		}
		else {
			Node* parent = _node->_parent;
			while (parent && parent->_left == _node) {
				_node = parent;
				parent = _node->_parent;
			}
			_node = parent;
		}
		return prevIterator;
	}
	bool operator!=(const Self& s) const {
		return _node != s._node;
	}
	bool operator==(const Self& s) const {
		return _node == s._node;
	}
};

template<class K, class T, class KeyOfT, class Compare>
class RBTree {
	typedef RBTreeNode<T> Node;
public:
	typedef __RBTree_Iterator<T, T&, T*> iterator;
	typedef __RBTree_Iterator<T, const T&, const T*> const_iterator;
	typedef __RBTree_Iterator<T, T&, T*> reverse_iterator;
	typedef __RBTree_Iterator<T, const T&, const T*> const_reverse_iterator;

	iterator begin() {
		Node* left = _root;
		while (left && left->_left) {
			left = left->_left;
		}
		return iterator(left);
	}
	iterator end() {
		return iterator(nullptr);
	}
	const_iterator begin() const {
		Node* left = _root;
		while (left && left->_left) {
			left = left->_left;
		}
		return const_iterator(left);
	}
	const_iterator end() const {
		return const_iterator(nullptr);
	}
	reverse_iterator rbegin() {
		Node* right = _root;
		while (right && right->_right) {
			right = right->_right;
		}
		return reverse_iterator(right);
	}
	reverse_iterator rend() {
		return reverse_iterator(nullptr);
	}
	pair<iterator, bool> Insert(const T& data) {
		if (_root == nullptr) {
			_root = new Node(data);
			_root->_col = BLACK;
			return std::make_pair(iterator(_root), true);
		}
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur) {
			if (_compare(_kot(cur->_data), _kot(data))) {
				parent = cur;
				cur = cur->_right;
			}
			else if (_compare(_kot(data), _kot(cur->_data))) {
				parent = cur;
				cur = cur->_left;
			}
			else {
				return std::make_pair(iterator(cur), true);
			}
		}
		Node* newnode = new Node(data);
		cur = newnode;
		cur->_col = RED;
		if (_compare(_kot(parent->_data), _kot(data))) {
			parent->_right = cur;
		}
		else {
			parent->_left = cur;
		}
		cur->_parent = parent;

		
		///cur为红色，且parent也为黑色，返回true
		while (parent && parent->_col == RED) {
			Node* grandfather = parent->_parent;
			assert(grandfather && grandfather->_col == BLACK);
			Node* uncle = grandfather->_left;
			if (parent == grandfather->_left) {
				uncle = grandfather->_right;
			}
			if (uncle && uncle->_col == RED) {
				parent->_col = uncle->_col = BLACK;
				grandfather->_col = RED;
				//继续往上处理
				cur = grandfather;
				parent = cur->_parent;
			}
			//情况二：uncle不存在 || 存在且为黑
			else {
				if (grandfather->_left == parent && parent->_left == cur) {
					RotateR(grandfather);
				}
				else if (grandfather->_right == parent && parent->_right == cur) {
					RotateL(grandfather);
				}
				else if (grandfather->_left == parent && parent->_right == cur) {
					RotateLR(cur);
				}
				else if (grandfather->_right == parent && parent->_left == cur) {
					RotateRL(cur);
				}
				else {
					assert(false);
				}
				return std::make_pair(iterator(newnode), true);
			}
		}
		_root->_col = BLACK;
		return std::make_pair(iterator(newnode), true);
	}
	void Inorder() {
		_Inorder(_root);
	}
	bool IsBalance() {
		if (_root == nullptr) {
			return true;
		}
		if (_root->_col == RED) {
			cout << "性质2：根节点不是黑色" << endl;
			return false;
		}
		//黑色节点基准值
		int benchmark = 0;
		Node* cur = _root;
		while (cur) {
			if (cur->_col == BLACK) {
				++benchmark;
			}
			cur = cur->_left;
		}
		return _PrevCheck(_root, 0, benchmark);
	}
private:
	bool _PrevCheck(Node* root, int blackNum, int benchmark) {
		if (root == nullptr) {
			if (blackNum != benchmark) {
				cout << "性质4：某条路径黑色节点数量不相等" << endl;
				return false;
			}
			else {
				return true;
			}
		}
		if (root->_col == BLACK) {
			++blackNum;
		}
		if (root->_col == RED && root->_parent->_col == RED) {
			cout << "性质3：存在连续红色节点" << endl;
			return false;
		}
		return _PrevCheck(root->_left, blackNum, benchmark)
			&& _PrevCheck(root->_right, blackNum, benchmark);
	}
	void _Inorder(Node* cur) {
		std::stack<Node*> st;
		while (cur || !st.empty()) {
			while (cur) {
				st.push(cur);
				cur = cur->_left;
			}
			cur = st.top();
			std::cout << _kot(cur->_data) << " ";
			st.pop();
			cur = cur->_right;
		}
		std::cout << std::endl;
	}
	void RotateL(Node* parent) {
		Node* subR = parent->_right;
		Node* subRL = subR->_left;
		subR->_left = parent;
		Node* pParent = parent->_parent;
		if (parent == _root) {
			_root = subR;
		}
		else {
			if (parent == pParent->_left) {
				pParent->_left = subR;
			}
			else {
				pParent->_right = subR;
			}
		}
		subR->_parent = pParent;
		parent->_parent = subR;
		parent->_right = subRL;
		if (subRL) {
			subRL->_parent = parent;
		}
		parent->_col = RED;
		subR->_col = BLACK;
	}
	void RotateR(Node* parent) {
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		subL->_right = parent;
		Node* pParent = parent->_parent;
		if (parent == _root) {
			_root = subL;
		}
		else {
			if (parent == pParent->_left) {
				pParent->_left = subL;
			}
			else {
				pParent->_right = subL;
			}
		}
		subL->_parent = pParent;
		parent->_parent = subL;
		parent->_left = subLR;
		if (subLR) {
			subLR->_parent = parent;
		}
		parent->_col = RED;
		subL->_col = BLACK;
	}
	void RotateLR(Node* cur) {
		Node* parent = cur->_parent;
		Node* grandfather = parent->_parent;
		RotateL(parent);
		RotateR(grandfather);
		cur->_col = BLACK;
		grandfather->_col = RED;
	}
	void RotateRL(Node* cur) {
		Node* parent = cur->_parent;
		Node* grandfather = parent->_parent;
		RotateR(parent);
		RotateL(grandfather);
		cur->_col = BLACK;
		grandfather->_col = RED;
	}
protected:
	Compare _compare;
	Node* _root = nullptr;
	KeyOfT _kot;
};

8.3 map封装红黑树的实现

map的底层结构就是红黑树，因此在map中直接封装一棵红黑树，然后将其接口包装下即可

#pragma once
#include"RBTree.h"
namespace Thb {
	template<class Key, class T, class Compare = less<Key>>
	class map {
		typedef Key key_type;
		typedef pair<const Key, T> value_type;
		struct MapKeyOfT {
			const Key& operator()(const value_type& kval) {
				return kval.first;
			}
		};
	public:
		typedef typename RBTree<key_type, value_type, MapKeyOfT, Compare>::iterator iterator;
		typedef typename RBTree<key_type, value_type, MapKeyOfT, Compare>::reverse_iterator reverse_iterator;
		iterator begin() {
			return _t.begin();
		}
		iterator end() {
			return _t.end();
		}
		reverse_iterator rbegin() {
			return _t.rbegin();
		}
		reverse_iterator rend() {
			return _t.rend();
		}
		pair<iterator,bool> insert(const value_type& val) {
			return _t.Insert(val);
		}
		void inorder() {
			_t.Inorder();
		}
		bool is_balance() {
			return _t.IsBalance();
		}
		T& operator[](const Key& key) {
			pair<iterator, bool> ret = insert(std::make_pair(key, T()));
			return (ret.first)->second; 
		}
	private:
		typedef RBTree<key_type, value_type, MapKeyOfT, Compare> rep_type;
		rep_type _t;
	};
	
}

8.4 set的模拟实现

set的底层为红黑树，因此只需在set内部封装一棵红黑树，即可将该容器实现出来(具体实现可参考map)。

#pragma once
#include"RBTree.h"
namespace Thb {
	template<class Key, class Compare = less<Key>>
	class set {
		typedef Key key_type;
		typedef Key value_type;
		struct SetKeyOfT {
			const Key& operator()(const Key& key) {
				return key;
			}
		};
	public:
		typedef typename RBTree<key_type, value_type, SetKeyOfT, Compare>::iterator iterator;
		typedef typename RBTree<key_type, value_type, SetKeyOfT, Compare>::reverse_iterator reverse_iterator;
		
		iterator begin() {
			return _t.begin();
		}
		iterator end() {
			return _t.end();
		}
		reverse_iterator rbegin() {
			return _t.rbegin();
		}
		reverse_iterator rend() {
			return _t.rend();
		}
		pair<iterator, bool> insert(const value_type& val) {
			return _t.Insert(val);
		}
		void inorder() {
			_t.Inorder();
		}
		bool is_balance() {
			return _t.IsBalance();
		}
	private:
		typedef RBTree<key_type, value_type, SetKeyOfT, Compare> rep_type;
		rep_type _t;
	};
}

8.5 其他功能的实现

其他功能的实现可参考二叉搜索树文章，增加需要的功能(1条消息) C++进阶—二叉搜索树_IfYouHave的博客-CSDN博客

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

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

相关文章

Linux下载安装Redis（Ubuntu系统）

Linux下载安装Redis（Ubuntu系统）

相比于 Windows 系统而言&#xff0c;Redis 更适合于在 Linux 系统上使用&#xff0c;这是由 Redis 的底层机制决定的。下面介绍一下如何在 Linux 发行版 Ubuntu 系统上安装 Redis 数据库。 了解Redis版本 Redis 版本号采用国际标准惯例&#xff0c;即“主版本号.副版本号.补…
阅读更多...
Linux分布式应用 Zabbix监控软件 安装

Linux分布式应用 Zabbix监控软件 安装

zabbix 是什么&#xff1f; ●zabbix 是一个基于 Web 界面的提供分布式系统监视以及网络监视功能的企业级的开源解决方案。 ●zabbix 能监视各种网络参数&#xff0c;保证服务器系统的安全运营&#xff1b;并提供灵活的通知机制以让系统管理员快速定位/解决存在的各种问题。 ●…
阅读更多...
第七届御网杯re的wp_Ba0

第七届御网杯re的wp_Ba0

re拿了一血和二血&#xff0c;感觉挺简单的&#xff08; 1、easycpp 使用IDA进行linux动调 主要异或加密&#xff0c;还原即可 1 2 3 4 flag1[0x23,0x21,0x27,0x22,0x27,0x27,0x25,0x2B,0x2D,0x26,0x23,0x23,0x22,0x26,0x27,0x2E] flag[18,19,20,22,18,17,18,19,20,22,18,17…
阅读更多...
visual stodio 编译

visual stodio 编译

一、生成文件复制一份到其他路径 选到这里&#xff0c;添加命令&#xff1a; PlatformName 平台版本 x86/x64 Configuration 配置生成目录 Debug/Release OutputPath 生成路径 Debug/Release copy /y "$(OutputPath)$(ProjectName).dll" "E:\Project\UseDll…
阅读更多...
LED点阵动画

LED点阵动画

23-7-6 #include<regx52.h> #include "Delay.h" #include "Matrix.h" /*点阵屏显示动画*/ unsigned char code Animation[]{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x08,0x08,0x08,0xff,0x00,0x0e,0x15,0x15,0x15,0x08,0x00,0x7e,0x01,0x02,…
阅读更多...
用户数据报协议 UDP

用户数据报协议 UDP

文章目录 一、UDP数据报格式二、UDP校验和计算1.伪报头2.伪报头结构3.检验和计算 三、UDP特点 UDP 的特点&#xff1a; 无连接、不可靠&#xff0c;运行快捷&#xff1a; 在传输报文之前不需要建立连接&#xff0c;因此减少了协议开销与传输延时。此外&#xff0c;除了对报文提…
阅读更多...
2023年湖北成人高考学习全流，今天启程别详细给大家介绍！

2023年湖北成人高考学习全流，今天启程别详细给大家介绍！

2023年湖北成人高考学习全流&#xff0c;今天启程别详细给大家介绍&#xff01; 成人高考可以准备起来了&#xff0c;那么你了解成人高考的学习流程吗&#xff1f; 一、考前准备 确认好报考条件&#xff0c;准备报名资料&#xff0c;拿到书本教材开始复习备考。 湖北成人高考报…
阅读更多...
canvas 绘制包含10个换行(‘\n’)文字例子,要求可以设置行高,文字最后整体在canvas的高度垂直居中

canvas 绘制包含10个换行(‘\n’)文字例子,要求可以设置行高,文字最后整体在canvas的高度垂直居中

canvas 绘制包含10个换行(‘\n’)文字例子,要求可以设置行高,文字最后整体在canvas的高度垂直居中。 <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><title>Canvas Text Example</title><style>…
阅读更多...
Redis锁防止重复提交

Redis锁防止重复提交

1.自定义注解方式 /*** author &#xff1a;网寻星公众号* date &#xff1a;Created in 2023/5/30 10:58* description&#xff1a;Redis锁防止重复提交* modified By&#xff1a;* version: 1.0$*/ Target({ElementType.METHOD}) Retention(RetentionPolicy.RUNTIME) Docume…
阅读更多...
好用的记事本app怎么切换字体颜色呢？

好用的记事本app怎么切换字体颜色呢？

很多人在使用记事本app的时候&#xff0c;会记录多条不同的内容&#xff0c;为了突出某条内容的重要性&#xff0c;将它的字体切换成更醒目的颜色是很多人都在使用的办法。对于比较好用的记事本软件来说&#xff0c;怎样操作才能切换字体颜色呢&#xff1f;以iPhone手机端敬业签…
阅读更多...
【C语言】进阶指针（一）

【C语言】进阶指针（一）

目录 前言&#xff1a; 一、字符指针 二、指针数组与数组指针 &#xff08;一&#xff09;指针数组 &#xff08;二&#xff09;数组指针 三、数组传参与指针传参 &#xff08;一&#xff09;数组传参 &#xff08;二&#xff09;指针传参 前言&#xff1a; 进阶指针…
阅读更多...
【Python】面向对象 ③ ( 构造函数 | 成员变量赋值问题 | 构造方法引入 | 构造函数可以同时定义成员变量 )

【Python】面向对象 ③ ( 构造函数 | 成员变量赋值问题 | 构造方法引入 | 构造函数可以同时定义成员变量 )

文章目录 一、构造函数1、成员变量赋值问题2、构造方法引入3、代码示例 - 构造方法3、构造函数可以同时定义成员变量 一、构造函数 1、成员变量赋值问题 在之前的博客中 , 定义的 Python 类 Student : class Student:name None # 姓名age None # 年龄def info(self):print…
阅读更多...
AIGC：文生图模型Stable Diffusion

AIGC：文生图模型Stable Diffusion

1 Stable Diffusion介绍 Stable Diffusion 是由CompVis、Stability AI和LAION共同开发的一个文本转图像模型&#xff0c;它通过LAION-5B子集大量的 512x512 图文模型进行训练&#xff0c;我们只要简单的输入一段文本&#xff0c;Stable Diffusion 就可以迅速将其转换为图像&am…
阅读更多...
飞行动力学 - 第5节-part2-喷气式飞机的爬升性能 之 基础点摘要

飞行动力学 - 第5节-part2-喷气式飞机的爬升性能 之 基础点摘要

飞行动力学 - 第5节-part2-喷气式飞机的爬升性能 之 基础点摘要 1. 最大爬升角2. 最大爬升率3. 一些历史记录4. 参考资料 1. 最大爬升角 喷气式飞机由于推力稳定输出&#xff0c;其最大爬升角相对容易计算&#xff1a; 2. 最大爬升率 爬升率相对复杂&#xff0c;使用无量纲数据…
阅读更多...
【原生HTML】表格

【原生HTML】表格

1、一个表格合并后多选 我这里的表格是在elementUI的tabs页里的&#xff0c;所以数据格式多了一层 数据格式 html原生代码&#xff1a; <tableclass"multi-table"style"width: 100%; border-color: #ebeef5"border"1px"cellspacing"0&qu…
阅读更多...
使用IDEA时关于Tomcat处理HTML请求乱码的问题（通过访问服务器的静态页面F12后响应头里的编码格式都是utf-8了，还是乱码）

使用IDEA时关于Tomcat处理HTML请求乱码的问题（通过访问服务器的静态页面F12后响应头里的编码格式都是utf-8了，还是乱码）

解决方法在文末&#xff0c;大家可以下滑到底部直接浏览 今天在使用Tomcat访问静态页面时&#xff0c;页面出现乱码问题&#xff0c;各种办法的试了&#xff0c;内心一度处于奔溃的边缘&#xff0c;在外出跑步冷静了一下之后&#xff0c;思路渐渐清晰。 出现乱码后的第一步&a…
阅读更多...
C数据结构与算法——顺序表 应用

C数据结构与算法——顺序表 应用

实验任务 (1) 掌握顺序表结构及其 C 语言实现&#xff1b; (2) 掌握插入、删除等基本算法&#xff1b; (3) 掌握顺序表的基本应用&#xff08;将两个有序线性表合并为一个有序表&#xff09;。 实验内容 使用 C 语言实现顺序表的类型定义与算法函数&#xff1b;编写 main()函…
阅读更多...
Verilog parameter的用法

Verilog parameter的用法

parameter简介 parameter”是Verilog HDL中的一个关键字&#xff0c;代表着参数型常量&#xff0c;即用parameter来定义一个标识符代表一个常量&#xff0c;这样可以提高程序的可读性与可维护性。 parameter应用场景 #&#xff08;parameter number500&#xff09; 表示定义一…
阅读更多...
零代码开发平台免费，未来企业数字化转型常用工具

零代码开发平台免费，未来企业数字化转型常用工具

什么是零代码开发平台 零代码开发平台指的是一种软件开发工具&#xff0c;能够使开发人员在不编写代码的情况下构建应用程序或快速应用程序。它们一般是通过拖放的方式创建用户界面&#xff0c;配置业务逻辑&#xff0c;集成数据库等操作&#xff0c;节省开发周期和人力成本。…
阅读更多...
安森美-深力科NC7SV08P5X能成为极高速、高驱动和低功耗应用的理想选择吗？

安森美-深力科NC7SV08P5X能成为极高速、高驱动和低功耗应用的理想选择吗？

描述&#xff1a; 关于安森美-深力科NC7SV08P5X是飞兆超低功率 (ULP-A) TinyLogic 系列的一个 2 输入“与”门。 ULP-A 是要求极高速、高驱动和低功耗应用的理想选择。 用于宽低电压工作范围&#xff08;0.9 V 到 3.6 V VCC&#xff09;&#xff0c;适合驱动和速度要求高于 Ti…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023