C++程序员修炼手册--红黑树的实现及map和set的封装

已于 2022-06-09 13:42:08 修改
阅读量327 收藏 3
点赞数 2
分类专栏： C++ 文章标签： 红黑树 AVL树 插入操作 迭代器 树平衡
于 2022-06-09 10:19:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63111921/article/details/125183238
版权

目录

一，概述

1，有了二叉搜索树，为什么还需要AVL树

2，有了AVL树，为什么还需要红黑树

二，红黑树的性质

三，红黑树模拟实现

1，树节点的构造

2，树的插入操作

        1，首先构造根节点，再去插入数据

        2，插入数据

        3，调节树的平衡

四，迭代器的实现

4.1，红黑树的迭代器怎么走

4.2 迭代器的封装

1，构造出一个迭代器的类，通过对类的操作，实现对树的节点的访问

2，反向迭代器的封装

五，set和map的封装

5.1，set的封装

5.2，map的封装

六，总代码如下所示：

1.RBtree

2.map.h

3,set.h

4,Iterator.h

期待关注，一键三连

一，概述

1，有了二叉搜索树，为什么还需要AVL树

        二叉搜索树在极端条件下，会退化成一条单链表，增删查改效率会退化到Olog(n),严重影响性能,而AVl树通过对结点的旋转，会形成一个左右子树高度差不超过1的搜索树，形成一个高度平衡的二叉树。

2，有了AVL树，为什么还需要红黑树

        AVL树在增删数据时，会通过不停的旋转来实现树的平衡，在频繁的增删数据时，几乎都需要旋转，效率退化，而使用红黑树，通过牺牲不是特别平衡的树，可以减少树的旋转，通过节点颜色的改变和树的旋转共同维持树的平衡，虽然没有AVL树高度平衡，但效率会变高。

二，红黑树的性质

1，是一个二叉搜索树，左树值比根节点值小，右树值比根节点大。

2，根节点是黑色

3，没有连续的红色节点

4，每条路径上的黑色节点数相等

5，最长路径不超过最短路径的2倍

三，红黑树模拟实现

1，树节点的构造

通过使用三叉链来实现，节点颜色通过枚举实现（RED，BLACK）

enum Color
{
	RED,
	BLACK,
};
template<class K,class V>
struct RBtreenode
{
	RBtreenode<K,V>*_left;  //左节点 
	RBtreenode<K,V>*_right; //右节点 
	RBtreenode<K,V>*_parent;//父节点 
	pair<K,V>_kv;			//数据 
	Color _col;				//颜色 
	RBtreenode(const pair<K,V>&kv)
	:_left(nullptr)
	,_right(nullptr)
	,_parent(nullptr)
	,_kv(kv)
	,_col(RED)//默认给红色 
	{}
};

2，树的插入操作

        1，首先构造根节点，再去插入数据

template<class K,class V>
class RBtree
{
	typedef RBtreenode<K,V>node;//对节点进行重定义 
public:
	pair<node*,bool>insert(const pair<K,V>& kv)
	{	
	} 
private:
	node*_root;	//定义根节点 
};

        2，插入数据

        按照搜索二叉树的规则，先找到插入的位置，把数据插入进去，再对节点进行判断，看是否满足红黑树的性质，满足，直接返回，不满足，再对树进行处理

template<class K,class V>
class RBtree
{
	typedef RBtreenode<K,V>node;//对根节点进行重定义 
public:
	pair<node*,bool>insert(const pair<K,V>& kv)
	{	
		if(_root==nullptr)//根节点为空 
		{
			_root=new node(kv);
			_root->_col=BLACK;
			return make_pair(_root,true);
		} 
		node*parent=nullptr;
		node*cur=_root;
		//找到节点插入的位置 
		while(cur)
		{
			if(cur->_kv.first<kv.first)
			{
				parent=cur;
				cur=cur->_right;	
			}
			else if(cur->_kv.first>kv.first)
			{
				parent=cur;
				cur=cur->_left;
			}
			else
			{
				return make_pair(cur,false);
			}
		} 
		//插入数据
		node *newnode=new node(kv);
		newnode->_col=RED;
		//此时cur走到空，父亲走到将要插入的位置,插入数据 
		if(parent->_kv.first>kv.first)
		{
			parent->_left=newnode;
			newnode->_parent=parent;
		} 
		else
		{
			parent->_right=newnode;
			newnode->_parent=parent;
		}
		cur=newnode; 
		//调节树的平衡
        //重点，难点
		while(parent&&parent->_col==RED)
		{
			
		}
		 
	} 
private:
	node*_root;	//定义根节点 
};

        3，调节树的平衡

        3.1，父亲在祖父的左边

        情况1，叔叔存在且为红

        具象图如下所示：

代码如下：

	    node*grandfather=parent->_parent;
			//父亲在祖父的左边 
			if(parent==grandfather->_left)
			{
				//关键看叔叔
				//1,叔叔存在且为红
				node*uncle=grandfather->_right;
				if(uncle&&uncle->_col==RED)
				{
					//把父亲和叔叔变黑，祖父变红
					uncle->_col=parent->_col=BLACK;
					grandfather->_col=RED;
					//此时往上处理，祖父的父亲可能为红，不满足红黑树性质，继续调整
					cur=grandfather;
					parent=grandfather->_parent; 
				}

         情况二，叔叔不存在，


	//情况2，叔叔不存在
	if(cur==parent->_left)
		{
			//右单旋处理
			RoateR(grandfather);
			parent->_col=BLACK;
			grandfather->_col=RED; 
		}
    //右旋 
	void RoateR(node*parent)
	{
		node*subL=parent->_left;
		node*subLR=subL->_right;
		//链接 
		parent->_left=subLR;
		if(subLR)
		{
			subLR->_parent=parent;
		}
		subL->_right=parent;
		//判断parent是否为根
		node*parentparent=parent->_parent;
		 parent->_parent=subL;
		 if(parent==_root)
		 {
		 	_root=subL;
		 	subL->_parent=nullptr;
		 }
		 //不是根处理 
		 else
		 {
		 	if(parentparent->_left==parent)
		 	parentparent->_left=subL;
		 	else
		 	parentparent->_right=subL;
		 	
			subL->_parent=parentparent;
		 }
	}

情况三，叔叔存在且为黑

        当在此种情况下，双旋处理+变色，树平衡

	//情况3，叔叔存在且为黑 
		else
		{
			RoateL(parent);
			RoateR(grandfather);
			grandfather->_col=RED;
			cur->_col=BLACK; 
		}

         3.2，父亲在祖父的右边

        情况一，叔叔存在且为红

            node*uncle=grandfather->_left;
				//情况1，叔叔存在且为红
				if(uncle&&uncle->_col==RED)
				{
					parent->_col=uncle->_col=BLACK;
					grandfather->_col=RED;
					//继续往上处理
					cur=grandfather;
					parent=cur->_parent; 
				}

        情况二，叔叔不存在

                //叔叔不存在 
					if(cur==parent->_right)
					{
						RoateL(grandfather);
						parent->_col=BLACK;
						grandfather->_col=RED;
					}

情况三，叔叔存在且为黑


					//叔叔为黑 
					else
					{
						RoateR(parent);
						RoateL(grandfather);
						grandfather->_col=RED;
						cur->_col=BLACK;
					}

 最后整个的插入操作就完成了，实现代码如下：

//插入数据 
	pair<node*,bool>insert(const pair<K,V>&kv)
	{
		//如果树为空 
		if(_root==nullptr)
		{
			_root=new node(kv);
			_root->_col=BLACK;
			return make_pair(_root,true);
		}
		//树不为空 
		node*parent=nullptr;
		node*cur=_root;
		//找到节点插入的位置 
		while(cur)
		{
			if(cur->_kv.first<kv.first)
			{
				parent=cur;
				cur=cur->_right;
			}
			else if(cur->_kv.first>kv.first)
			{
				parent=cur;
				cur=cur->_left;
			}
			else
			{
				return make_pair(cur,false);
			}
		} 
		//插入数据
		node*newnode=new node(kv);
		newnode->_col=RED;
		if(parent->_kv.first>kv.first)
		{
			parent->_left=newnode;
			newnode->_parent=parent;	
		} 
		else
		{
			parent->_right=newnode;
			newnode->_parent=parent;			
		}
		cur=newnode;
		//处理颜色
		while(parent&&parent->_col==RED)
		{
			node*grandfather=parent->_parent;
			//关键看叔叔
			
			//父亲在祖父左边 
			if(parent==grandfather->_left)
			{
				//情况1，叔叔存在且为红 
				node*uncle=grandfather->_right;
				if(uncle&&uncle->_col==RED)
				{
					parent->_col=uncle->_col=BLACK;
					grandfather->_col=RED;
					//继续往上处理
					cur=grandfather;
					parent=cur->_parent; 
				} 
				//情况2，叔叔不存在或者存在为黑
				else
				{
					//叔叔不存在,单旋处理 
					if(cur==parent->_left)
					{
						RoateR(grandfather);
						grandfather->_col=RED;
						parent->_col=BLACK;
					} 
					//情况三 ，叔叔存在且为黑 
					else
					{
						RoateL(parent);
						RoateR(grandfather);
						cur->_col=BLACK;
						grandfather->_col=RED;
					} 
					break;
				} 
			}
			//父亲在祖父右边 
			else  
			{
				node*uncle=grandfather->_left;
				//情况1，叔叔存在且为红
				if(uncle&&uncle->_col==RED)
				{
					parent->_col=uncle->_col=BLACK;
					grandfather->_col=RED;
					//继续往上处理
					cur=grandfather;
					parent=cur->_parent; 
				}
				//情况2，叔叔不存在或者叔叔为黑	
				else
				{
					//叔叔不存在 
					if(cur==parent->_right)
					{
						RoateL(grandfather);
						parent->_col=BLACK;
						grandfather->_col=RED;
					}
					//叔叔为黑 
					else
					{
						RoateR(parent);
						RoateL(grandfather);
						grandfather->_col=RED;
						cur->_col=BLACK;
					}
					break; 	
				} 
			}		
		}
		_root->_col=BLACK; 
		return make_pair(cur,true);
	}
	//右旋 
	void RoateR(node*parent)
	{
		node*subL=parent->_left;
		node*subLR=subL->_right;
		//链接 
		parent->_left=subLR;
		if(subLR)
		{
			subLR->_parent=parent;
		}
		subL->_right=parent;
		//判断parent是否为根
		node*parentparent=parent->_parent;
		 parent->_parent=subL;
		 if(parent==_root)
		 {
		 	_root=subL;
		 	subL->_parent=nullptr;
		 }
		 //不是根处理 
		 else
		 {
		 	if(parentparent->_left==parent)
		 	parentparent->_left=subL;
		 	else
		 	parentparent->_right=subL;
		 	
			subL->_parent=parentparent;
		 }
	}
	void RoateL(node*parent)
	{
		node*subR=parent->_right;
		node*subRL=subR->_left;
		parent->_right=subRL;
		if(subRL)
		{
			subRL->_parent=parent;
		}	
		//判断parent是否为根
		subR->_left=parent;
		node*parentparent=parent->_parent;
		parent->_parent=subR;
		if(_root==parent)
		{
			_root=subR; 
			subR->_parent=nullptr; 
		} 
		else
		{
			if(parentparent->_left==parent)
			{
				parentparent->_left=subR;
			}
			else
			{
				parentparent->_right=subR;	
			}
			subR->_parent=parentparent;
		}
	}

四，迭代器的实现

4.1，红黑树的迭代器怎么走

从最左边的第一个元素，以中序遍历的方式向下走

++方式应为 {1 ，8，11，13 ，15，17，25}

--方式应为 {25，17，15，13，11，8，1} 

其实现方式如下代码所示:

operator++（）

从最左节点开始走，走父亲，右孩子，然后向上继续走，直到走到空

self operator++()
	{
		//如果右树不为空，走左子树的最左节点 
		if(_node->_right)
		{
			node*left=_node->_right;
			while(left->_left)
			{
				left=left->_left;
			}
			_node=left;
		} 
		//右子树为空，找孩子不是右的节点返回 
		else
		{
			node*cur=_node;
			node*parent=cur->_parent;
			while(parent&&cur==parent->_right)
			{
				cur=cur->_parent;
				parent=parent->_parent;
			} 
			_node=parent;
		}
		return *this;
	}

operator--（)l类似上面++，先走右子树，再走父亲，走左子树

	self operator--()
	{
		//如果左树不为空，找右子树的最右节点 
		if(_node->_left)
		{
			node*right=_node->_left;
			//访问右子树的最右节点 
			while(right->_right)
			{
				right=right->_left;
			}
			_node=right;
		}	
		else
		{
			//右树访问完，访问左树
			node*cur=_node;
			node*parent=cur->_parent;
			while(parent&&cur==parent->_left)
			{
				cur=parent;
				parent=parent->_parent;
			} 
			_node=parent;
		}
		return *this;

4.2 迭代器的封装

1，构造出一个迭代器的类，通过对类的操作，实现对树的节点的访问

//构造迭代器类型 
template<class T, class Ref, class Ptr>
struct __TreeIterator
{
	typedef Ref reference;
	typedef Ptr pointer;
	
	typedef RB_treeNode<T> node;
	typedef __TreeIterator<T,Ref,Ptr> self;
	node *_node;
	
	__TreeIterator(node*node)
	:_node(node)
	{}
	Ref operator*()
	{
		return _node->_data;
	}
	Ptr operator->()
	{
		return &_node->_data;
	}
	bool operator!=(const self &s) const
	{
		return _node!=s._node;
	}
	self operator++()
	{
		//如果右树不为空，走左子树的最左节点 
		if(_node->_right)
		{
			node*left=_node->_right;
			while(left->_left)
			{
				left=left->_left;
			}
			_node=left;
		} 
		//右子树为空，找孩子不是右的节点返回 
		else
		{
			node*cur=_node;
			node*parent=cur->_parent;
			while(parent&&cur==parent->_right)
			{
				cur=cur->_parent;
				parent=parent->_parent;
			} 
			_node=parent;
		}
		return *this;
	}
	self operator--()
	{
		//如果左树不为空，找右子树的最右节点 
		if(_node->_left)
		{
			node*right=_node->_left;
			//访问右子树的最右节点 
			while(right->_right)
			{
				right=right->_left;
			}
			_node=right;
		}	
		else
		{
			//右树访问完，访问左树
			node*cur=_node;
			node*parent=cur->_parent;
			while(parent&&cur==parent->_left)
			{
				cur=parent;
				parent=parent->_parent;
			} 
			_node=parent;
		}
		return *this;
	}
};

2，反向迭代器的封装

++和--调用已有数据结构的--和++

实现反向迭代器

template<class Iterator>
struct ReverseIterator
{
	//红黑树中实例化以后再实例化反向迭代器 
	typedef typename Iterator::reference Ref;
	typedef typename Iterator::pointer Ptr;
	typedef ReverseIterator<Iterator> Self;
	Iterator _it;
	ReverseIterator(Iterator it)
	:_it(it)
	{}
	Ref operator*()
	{
		return *_it;
	}
	Ptr operator->()
	{
		return _it.operator->();
	}
	Self& operator++()
	{
		--_it;
		return *this;
	}
	Self& operator--()
	{
		++_it;
		return *this;
	}
	bool operator!=(const Self& s) const
	{
		return _it != s._it;
	}
	
	bool operator==(const Self& s) const
	{
		return _it == s._it;
	}
};

五，set和map的封装

5.1，set的封装

1，红黑树存的是键值对，怎么传数据给pair

通过传的两个参数都为K，红黑树插入和find通过set定义的仿函数，提取到节点存取的值，再去比较，是一种高级的泛型编程。

template<class K>
		class set
		{
			//仿函数，提取节点存取的值 
			struct SetKeyOfT
			{
				const K& operator()(const K& key)
				{
					return key;
				}
			};
		public:
			typedef typename RBtree<K, K, SetKeyOfT>::iterator iterator;
			//实例化参数以后再去实例化迭代器 
			typedef typename RBtree<K, K, SetKeyOfT>::reverse_iterator reverse_iterator;

			reverse_iterator rbegin()
			{
				return _t.rbegin();
			}

			reverse_iterator rend()
			{
					return _t.rend();
			}		
			iterator begin()
			{
				return _t.begin();
			}
	
			iterator end()
			{
				return _t.end();
	
			}
			
			bool insert(const K& k)
			{
				_t.Insert(k);
	
				return true;
			}
		private:
			RBtree<K, K, SetKeyOfT> _t;
		};

5.2，map的封装

与set一样，都是通过仿函数拿到节点的值，再在插入和find中通过比较存取值

代码如下：

template<class K,class V>
	class map
	{
		//仿函数，拿出传过去参数的值
		struct mapKeyOfT
		{
			const K& operator()(const pair<const K,V>& kv)
			{
				return kv.first;
			}
		};
		public:
			//在对象实例化以后，再去构造迭代器 
			typedef typename RBtree<K,pair<const K,V>,mapKeyOfT>::iterator iterator;
			typedef typename RBtree<K,pair<const K,V>,mapKeyOfT>::reverse_iterator reverse_iterator;
			reverse_iterator rbegin()
			{
				return _t.rbegin();
			}	
			reverse_iterator rend()
			{
				return _t.rend();
			}		
			iterator begin()
			{
				return _t.begin();
			}
			iterator end()
			{
				return _t.end();
			}
			bool insert(const pair<const K,V>& kv)
			{
				_t.Insert(kv);
				return true;
			}
		private:
		    RBtree<K,pair<const K,V>,mapKeyOfT> _t;

走到这里，基本map和set就结束了，其中最重要的应当是红黑树的插入操作（主要看叔叔）和operator++（中序遍历，看节点有没有右节点）

六，总代码如下所示：

1.RBtree

#pragma once
#include<iostream>
#include<algorithm>
#include"iterator.h"
using namespace std;
enum Color
{
	RED,
	BLACK,	
};
//构造节点类型 
//使用T代表类型，传过来单参，就是set
//传过来键值对，就是map 
template<class T>
struct RB_treeNode 
{
	RB_treeNode<T>*_left;
	RB_treeNode<T>*_right;
	RB_treeNode<T>*_parent;
	T _data;
	Color _col;
	RB_treeNode(const T& x)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_data(x)
		,_col(RED)
	{}
};
//构造迭代器类型 
template<class T, class Ref, class Ptr>
struct __TreeIterator
{
	typedef Ref reference;
	typedef Ptr pointer;
	
	typedef RB_treeNode<T> node;
	typedef __TreeIterator<T,Ref,Ptr> self;
	node *_node;
	
	__TreeIterator(node*node)
	:_node(node)
	{}
	Ref operator*()
	{
		return _node->_data;
	}
	Ptr operator->()
	{
		return &_node->_data;
	}
	bool operator!=(const self &s) const
	{
		return _node!=s._node;
	}
	self operator++()
	{
		//如果右树不为空，走左子树的最左节点 
		if(_node->_right)
		{
			node*left=_node->_right;
			while(left->_left)
			{
				left=left->_left;
			}
			_node=left;
		} 
		//右子树为空，找孩子不是右的节点返回 
		else
		{
			node*cur=_node;
			node*parent=cur->_parent;
			while(parent&&cur==parent->_right)
			{
				cur=cur->_parent;
				parent=parent->_parent;
			} 
			_node=parent;
		}
		return *this;
	}
	self operator--()
	{
		//如果左树不为空，找右子树的最右节点 
		if(_node->_left)
		{
			node*right=_node->_left;
			//访问右子树的最右节点 
			while(right->_right)
			{
				right=right->_left;
			}
			_node=right;
		}	
		else
		{
			//右树访问完，访问左树
			node*cur=_node;
			node*parent=cur->_parent;
			while(parent&&cur==parent->_left)
			{
				cur=parent;
				parent=parent->_parent;
			} 
			_node=parent;
		}
		return *this;
	}
};
//构造树
//Ref代表引用，ptr代表指针 
//template<class T,class Ref,class Ptr>
template<class K, class T, class KeyOfT>
class RBtree
{
	typedef RB_treeNode<T> node;
public:
	typedef __TreeIterator < T, const T&, const T* > const_iterator; 
	typedef __TreeIterator < T, T&, T* > iterator;
	typedef ReverseIterator<iterator> reverse_iterator;
	reverse_iterator rbegin()
		{
			node* right = _root;
			while (right && right->_right)
			{
				right = right->_right;
			}
			return reverse_iterator(iterator(right));
		}
	reverse_iterator rend()
		{
			return reverse_iterator(iterator(nullptr));
		}
	//最左边的元素 
	iterator begin()
		{
			node* left = _root;
			while (left && left->_left)
			{
				left = left->_left;
			}
	
			return iterator(left);
		}
	//最右边的元素 
		iterator end()
		{
			return iterator(nullptr);
		}
	
	RBtree()
		:_root(nullptr)
		{}
	void Destory(node*root)
	{
		if(root==nullptr)
		{
			return ;
		}
		Destory(root->_left);
		Destory(root->_right);
		delete root;
	}
	~RBtree()
	{
		Destory(_root);
		_root=nullptr;
	}
	//拷贝构造 
//	RBtree(const RBtree <K,V>& RB)
//	{
//		_root=_copy(RB._root);
//	}
//	RBtree<K,V>& operator=(RBtree<K,V> t)
//	{
//		swap(_root,t._root);
//		return *this;
//	} 
	node*find(const K&key)
	{
		//使用仿函数拿出传过来参数的值
		//高级泛型编程 
		KeyOfT kot;
		node*cur=_root;
		while(cur)
		{
			if(kot(cur->_data)<key)
			{
				cur=cur->_right;
			}
			else if(kot(cur->_data)>key)
			{
				cur=cur->_left;
			}
			else
			{
				return cur;
			}
			return nullptr;
		}
	}
	//插入数据 
	pair<iterator,bool>Insert(const T& data)
	{
		//如果树为空 
		if(_root==nullptr)
		{
			_root=new node(data);
			_root->_col=BLACK;
			return make_pair(_root,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 make_pair(iterator(cur),false);
			}
		} 
		//插入数据
		node*newnode=new node(data);
		newnode->_col=RED;
		if(kot(parent->_data)>kot(data))
		{
			parent->_left=newnode;
			newnode->_parent=parent;	
		} 
		else
		{
			parent->_right=newnode;
			newnode->_parent=parent;			
		}
		cur=newnode;
		//处理颜色
		while(parent&&parent->_col==RED)
		{
			node*grandfather=parent->_parent;
			//关键看叔叔
			
			//父亲在祖父左边 
			if(parent==grandfather->_left)
			{
				//情况1，叔叔存在且为红 
				node*uncle=grandfather->_right;
				if(uncle&&uncle->_col==RED)
				{
					parent->_col=uncle->_col=BLACK;
					grandfather->_col=RED;
					//继续往上处理
					cur=grandfather;
					parent=cur->_parent; 
				} 
				//情况2，叔叔不存在或者存在为黑
				else
				{
					//叔叔不存在,单旋处理 
					if(cur==parent->_left)
					{
						RoateR(grandfather);
						grandfather->_col=RED;
						parent->_col=BLACK;
					} 
					//情况三 ，叔叔存在且为黑 
					else
					{
						RoateL(parent);
						RoateR(grandfather);
						cur->_col=BLACK;
						grandfather->_col=RED;
					} 
					break;
				} 
			}
			//父亲在祖父右边 
			else  
			{
				node*uncle=grandfather->_left;
				//情况1，叔叔存在且为红
				if(uncle&&uncle->_col==RED)
				{
					parent->_col=uncle->_col=BLACK;
					grandfather->_col=RED;
					//继续往上处理
					cur=grandfather;
					parent=cur->_parent; 
				}
				//情况2，叔叔不存在或者叔叔为黑	
				else
				{
					//叔叔不存在 
					if(cur==parent->_right)
					{
						RoateL(grandfather);
						parent->_col=BLACK;
						grandfather->_col=RED;
					}
					//叔叔为黑 
					else
					{
						RoateR(parent);
						RoateL(grandfather);
						grandfather->_col=RED;
						cur->_col=BLACK;
					}
					break; 	
				} 
			}		
		}
		_root->_col=BLACK; 
		return make_pair(iterator(newnode),true);
	}
	//右旋 
	void RoateR(node*parent)
	{
		node*subL=parent->_left;
		node*subLR=subL->_right;
		//链接 
		parent->_left=subLR;
		if(subLR)
		{
			subLR->_parent=parent;
		}
		subL->_right=parent;
		//判断parent是否为根
		node*parentparent=parent->_parent;
		 parent->_parent=subL;
		 if(parent==_root)
		 {
		 	_root=subL;
		 	subL->_parent=nullptr;
		 }
		 //不是根处理 
		 else
		 {
		 	if(parentparent->_left==parent)
		 	parentparent->_left=subL;
		 	else
		 	parentparent->_right=subL;
		 	
			subL->_parent=parentparent;
		 }
	}
	void RoateL(node*parent)
	{
		node*subR=parent->_right;
		node*subRL=subR->_left;
		parent->_right=subRL;
		if(subRL)
		{
			subRL->_parent=parent;
		}	
		//判断parent是否为根
		subR->_left=parent;
		node*parentparent=parent->_parent;
		parent->_parent=subR;
		if(_root==parent)
		{
			_root=subR; 
			subR->_parent=nullptr; 
		} 
		else
		{
			if(parentparent->_left==parent)
			{
				parentparent->_left=subR;
			}
			else
			{
				parentparent->_right=subR;	
			}
			subR->_parent=parentparent;
		}
	}
	bool _isBlanceTree(node*root,int blacknum,int count)
	{
		if(root==nullptr)
		{
			if(blacknum!=count)
			{
				cout<<"黑色节点数量不相等"<<endl; 
				return false;
			}
			return true;
		}
		if(root->_col==RED&&root->_parent->_col==RED)
		{
			cout<<"存在连续的红色节点"<<endl;
			return false;
		}
		if(root->_col==BLACK)
		{
			count++;
		}
		return _isBlanceTree(root->_left,blacknum,count)&&_isBlanceTree(root->_right,blacknum,count);
	}
	bool isBlanceTree()
	{
		if(_root==nullptr)
		{
			return true;
		}
		if(_root->_col==RED)
		{
			cout<<"根节点是红色的"<<endl; 
			return false;	
		}	
		node*left=_root;
		int blacknum=0;//黑色节点个数 
		while(left)
		{
			if(left->_col==BLACK)
			{
				blacknum++;
			}
			left=left->_left;
		}	
		int count=0;
		return _isBlanceTree(_root,blacknum,count); 
	}
//	void _inorder(node*root)
//	{
//		if(root==nullptr)
//		{
//			return ;
//		}
//		_inorder(root->_left);
//		cout<<root->_kv.first<<":"<<root->_kv.second<<endl;
//		_inorder(root->_right);
//		
//	}
//	void inorder()
//	{
//		_inorder(_root);
//	}
private:
	node*_root;
//	node*_copy(node*root)
//	{
//		if(root==nullptr)
//		{
//			return nullptr;
//		}
//		node* copynode=new node(root->_kv);
//		copynode->_left=_copy(root->_left);
//		copynode->_right=_copy(root->_right);
//		return copynode;
//	}
};

2，map.h

#include"RB_tree.h"
namespace Etta
{
	template<class K,class V>
	class map
	{
		//仿函数，拿出传过去参数的值
		struct mapKeyOfT
		{
			const K& operator()(const pair<const K,V>& kv)
			{
				return kv.first;
			}
		};
		public:
			//在对象实例化以后，再去构造迭代器 
			typedef typename RBtree<K,pair<const K,V>,mapKeyOfT>::iterator iterator;
			typedef typename RBtree<K,pair<const K,V>,mapKeyOfT>::reverse_iterator reverse_iterator;
			reverse_iterator rbegin()
			{
				return _t.rbegin();
			}	
			reverse_iterator rend()
			{
				return _t.rend();
			}		
			iterator begin()
			{
				return _t.begin();
			}
			iterator end()
			{
				return _t.end();
			}
			bool insert(const pair<const K,V>& kv)
			{
				_t.Insert(kv);
				return true;
			}
		private:
		    RBtree<K,pair<const K,V>,mapKeyOfT> _t;
	};
}

3,set.h

#include"RB_tree.h"
namespace Etta
{
	template<class K>
		class set
		{
			//仿函数，提取节点存取的值 
			struct SetKeyOfT
			{
				const K& operator()(const K& key)
				{
					return key;
				}
			};
		public:
			typedef typename RBtree<K, K, SetKeyOfT>::iterator iterator;
			//实例化参数以后再去实例化迭代器 
			typedef typename RBtree<K, K, SetKeyOfT>::reverse_iterator reverse_iterator;

			reverse_iterator rbegin()
			{
				return _t.rbegin();
			}

			reverse_iterator rend()
			{
					return _t.rend();
			}		
			iterator begin()
			{
				return _t.begin();
			}
	
			iterator end()
			{
				return _t.end();
	
			}
			
			bool insert(const K& k)
			{
				_t.Insert(k);
	
				return true;
			}
		private:
			RBtree<K, K, SetKeyOfT> _t;
		};
}

4,Iterator.h

template<class Iterator>
struct ReverseIterator
{
	//红黑树中实例化以后再实例化反向迭代器 
	typedef typename Iterator::reference Ref;
	typedef typename Iterator::pointer Ptr;
	typedef ReverseIterator<Iterator> Self;
	Iterator _it;
	ReverseIterator(Iterator it)
	:_it(it)
	{}
	Ref operator*()
	{
		return *_it;
	}
	Ptr operator->()
	{
		return _it.operator->();
	}
	Self& operator++()
	{
		--_it;
		return *this;
	}
	Self& operator--()
	{
		++_it;
		return *this;
	}
	bool operator!=(const Self& s) const
	{
		return _it != s._it;
	}
	
	bool operator==(const Self& s) const
	{
		return _it == s._it;
	}
};

期待关注，一键三连

想找后端开发的小杜
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
hdu 4857 逃生 （拓扑排序+保证最小在前面）
To be what you what to be!
07-20 3621
逃生 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 74    Accepted Submission(s): 13 Problem Description 糟糕的事情发生啦，现在大家都忙着逃命。但是逃命的通道很
【C++】红黑树（Red Black Tree）
knous
08-04 447
红黑树的一些操作
＜map与set的模拟实现＞——《C++高阶》
m0_57859086的博客
08-14 718
——《》C++高阶
【C++】红黑树 --- map/set 底层
YoungMLet的博客
11-13 1211
了解 map/set 底层红黑树的插入！使用红黑树封装 map/set ！
C++数据结构 —— 红黑树
weixin_59913110的博客
03-03 4575
enum Corlor //枚举颜色RED,BLACKtemplate //为了方便，使用K模型K _key;{}
【C++】map与set容器——红黑树底层封装
Pursue quality, not quantity.
04-04 994
map和set的介绍，以及如何用红黑树封装map和set，细节拉满！
map和set的模拟实现
最新发布
06-06
这将帮助我们更好地理解和实现红黑树，从而有效地模拟出Map和Set。 总之，通过封装红黑树并结合C++的面向对象特性，我们可以构建出高性能的Map和Set模拟实现。这不仅可以加深对数据结构和算法的理解，也有助于在...
c++容器list、vector、map、set区别与用法详解
12-17
c++容器list、vector、map、set区别 list 封装链表，以链表形式实现，不支持[]运算符。 对随机访问的速度很慢(需要遍历整个链表)，插入数据很快(不需要拷贝和移动数据，只需改变指针的指向)。 新添加的元素，...
STL中map、set的数据结构及底层实现.docx
10-28
总的来说，STL中的map和set通过封装红黑树这一高效的数据结构，为C++程序员提供了便捷且强大的键值存储和集合管理工具。理解它们的底层实现有助于优化代码，避免因不恰当使用而导致的性能问题。对于希望深入学习STL...
STL中map、set的数据结构及底层实现.pdf
10-05
STL中的map和set是两种关联容器，它们都基于一种高效的数据结构——红黑树（Red-Black Tree）进行实现。这种数据结构是一种自平衡的二叉查找树，能够保证在最坏情况下的搜索、插入和删除操作的时间复杂度为O(log n)...
c++MAP使用类
12-17
c++MAP使用例子程序，在本人的VS2005使用上通过，对学习使用C++MAP很有用
【C++】红黑树详解（附迭代器以及插入实现），适合初学者
jhao的博客
07-13 2387
红黑树的简单实现附有迭代器实现，代码都有详细解释，适合于初学者和想要理解STL map/set原理的朋友观看。
【C++】AVL树的插入实现
QiHai的博客
11-09 782
介绍提高查找二叉树的效率的方法-平衡搜索二叉树中的实现方法之一AVL树
我的jdk源码（十九）：TreeMap类 红黑树实现的map结构
Java觉浅的博客
06-09 545
一、概述 TreeMap类是一个有序的key-value的集合，与HashMap不同，TreeMap底层只有一个红黑树的结构（对红黑树不了解或者不熟悉的和觉得文字太枯燥的，推荐一个在线演示地址： https://rbtree.phpisfuture.com/ ），结点TreeMap类的内部类Entry，维护树结构；并且由于红黑树的特性，使得元素保存在TreeMap中默认是根据key值的自然顺序排序，也可以传入特定的比较器实例使TreeMap维持指定的顺序。所以，当你既想利用Map的高效查找特性，又...
红黑树实现——STL中的map
zhongjie的专栏
11-04 7773
红黑树实现——STL中的map [ 2009-07-24 13:55:31 | 作者: dklkt ] 字号: 大 | 中 | 小 [转载]STL中map实现技术 来源：http://blog.csdn.net/Fandywang_jlu/archive/2008/03/23/2208363.aspx 红黑树是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，
（C++进阶）二叉搜索树 （K KV）
qq_57594025的博客
07-22 347
个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树。③如果根节点key>查找key，在其左子树查找。如果根节点key...
Class RedisTemplate<K,V> ------ API
u014704496的专栏
11-06 1120
http://docs.spring.io/spring-data/redis/docs/1.0.x/api/org/springframework/data/redis/core/RedisTemplate.html redistemplate 的 API 英文版 Class RedisTemplate
【 C++ 】用一颗红黑树封装map和set
bit_zyx的博客
09-04 360
目录 1、前言 2、红黑树模板参数的控制 3、模板参数中仿函数的增加 4、红黑树迭代器的实现 5、红黑树的begin()和end() 6、红黑树的Find查找函数 7、红黑树源码链接 8、set的代码 9、map的代码
c++stl中红黑树的实现
09-14
在C++ STL中，红黑树的实现被封装在`std::map`和`std::set`这两个容器类中。这两个容器类都是基于红黑树实现的，它们提供了高效的查找、插入和删除操作，保证了元素的有序性。 STL中的红黑树实现与你提供的C++代码...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

想找后端开发的小杜

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值