c++红黑树的模拟实现

目录

1. 红黑树的概念

​编辑

 2. 红黑树的性质

3. 红黑树的模拟实现 

 3.1 红黑树节点的定义

3.2 红黑树的插入

旋转代码 

插入主逻辑代码 

验证是否平衡 

4. 红黑树与AVL树的比较 

---

1. 红黑树的概念

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

那么红黑树是凭什么满足没有最长路径不超过最短路径的两倍呢？我们去看看他的性质！ 

 2. 红黑树的性质

1. 每个结点不是红色就是黑色
2. 根节点是黑色的（根节点必须为黑）
3. 如果一个节点是红色的，则它的两个孩子结点是黑色的（没有连续的红色节点）
4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点

（每条路径上的黑色节点都相同）
5. 每个叶子结点都是黑色的(此处的叶子结点指的是空结点)（注意这里的叶子是空结点，我们学习的时候不会对他有过多的理睬）

难道凭借这几个性质就能得出最长路径不超过最短路径的两倍吗？

是的没错！这些性质足以！

红色节点的孩子必然是黑色，每条路径的黑色节点个数都相同。这不就固定了最短路径必然是全黑的，最长路径必然是一黑一红，同时每条路径的黑色节点个数相同，那么最长路径就是两倍的最短路径。

3. 红黑树的模拟实现 

 3.1 红黑树节点的定义

enum Color
{
	RED,
	BLACK
};

template<class K,class V>
class RBTreeNode
{
public:
	RBTreeNode(const pair<K, V>& kv,const Color& color=RED)//颜色的缺省参数给定为红色
		:_kv(kv)
		, _color(color)
		,_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
private:
	pair<K, V> _kv;
	Color _color;
	RBTreeNode<K, V> _left;
	RBTreeNode<K, V> _right;
	RBTreeNode<K, V> _parent;
};

其他的我们都能理解，但是颜色的缺省参数为什么给定红色呢？

我们想一想，根据红黑树的几条性质，我们插入的时候要怎么检测呢？难道每插入一个都检查一下树的每条路径黑色节点个数是否相同吗？

当然不是，插入时我们只需要检测是否有连续的红色节点。

当我们插入的是红色节点，其父亲为黑就正常，其父亲为红就进行处理。

但如果我们插入的是黑色，那么永远满足没有连续的红色节点，也触发不了处理过程。 

3.2 红黑树的插入

红黑树的插入规则仍是延续二叉搜索树的规则，在插入后依据红黑树的规则对树进行调整。 

我们来看看吧。

当插入节点后需要检测是否满足红黑树的特性。

新插入的节点为红色，如果他的父亲是黑色，满足红黑树特性，over；

如果他的父亲是红色，违反了红黑树的特性，这时就需要进行处理。

这个时候需要分情况讨论。我们约定c为插入节点，p为其父亲，u为其叔叔，g为其爷爷。这几个节点都是今天的主角。第一主角则是叔叔节点u，这是为什么呢？

叔叔节点的状态决定了我们的操作。

可以看到，关键就在于叔叔节点的状态。

我们来画图看看

u存在且为红

u不存在且为黑

当p为g左且c为p左 

当p为g右且c为p右

当p为g右且c为p左时

 当p为g左且c为g右时

以上就是红黑树的插入思路了。我们来写一写代码吧。

旋转代码 

旋转思路与AVL树没有差别，只是需要将对平衡因子的调节改为对颜色的调节。

void RotateL(Node* parent)//左单旋
{
	//记录会进行迁移的节点
	Node* cur = parent->_right;//cur节点
	Node* CL = cur->_left;//cur的左孩子

	parent->_right = CL;//cur->_left变成parent->_right
	if (CL)//如果CL存在，更新其父亲，以免触发空指针的解引用
		CL->_parent = parent;

	cur->_left = parent;//parent给cur->_left
	Node* grandfather = parent->_parent;//先记录parent的父亲
	parent->_parent = cur;//更新parent的父亲

	if (parent == _root)//parent为根，将cur置为_root，其父亲为空
	{
		_root = cur;
	}
	else//不为根，更新其父亲
	{
		if (parent == grandfather->_left)
			grandfather->_left = cur;
		else
			grandfather->_right = cur;
	}
	cur->_parent = grandfather;
	
}
void RotateR(Node* parent)//右单旋
{
	//记录会进行迁移的节点
	Node* cur = parent->_left;
	Node* CR = cur->_right;

	parent->_left = CR;
	if (CR)
		CR->_parent = parent;

	cur->_right = parent;
	Node* grandfather = parent->_parent;//记录parent的父亲
	parent->_parent = cur;

	if (parent == _root)//parent为根
	{
		_root = cur;
		cur->_parent = nullptr;
	}
	else//不为根
	{
		if (parent == grandfather->_left)//判断parent的位置
			grandfather->_left = cur;
		else
			grandfather->_right = cur;
	}
	cur->_parent = grandfather;
	

}

插入主逻辑代码 

bool insert(const pair<K, V>& kv)
{
	if (_root == nullptr)
		_root = new Node(kv,BLACK);
	else//插入
	{
		Node* cur = _root, * parent = nullptr;//虽然是三叉链结构，但这里的parent仍需要，因为我们找到的位置是nullptr
		while (cur)//找到需要插入位置的父亲
		{
			if (compare(kv, cur->_kv))
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (compare(cur->_kv, kv))
			{
				parent = cur;
				cur = cur->_right;
			}
			else
				return false;
		}
		cur = new Node(kv);
		if (compare(kv,parent->_kv))//判断插入的位置是父亲的左还是右
		{
			parent->_left = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		//检测是否满足红黑树特性，不满足则处理
		while (parent && parent->_color != BLACK)
		{
			Node* grandfather = parent->_parent;
			Node* uncle = nullptr;
			if (parent == grandfather->_left)
				uncle = grandfather->_right;
			else
				uncle = grandfather->_left;
			if (!uncle || uncle->_color == BLACK)//叔叔存在且为黑
			{
				if (parent == grandfather->_left && cur == parent->_left)//p为g左且c为p左，右单旋
				{
					RotateR(grandfather);
					parent->_color = BLACK;
					grandfather->_color = RED;
				}
				else if (parent == grandfather->_right && cur == parent->_right)//p为g右且c为p右，左单旋
				{
					RotateL(grandfather);
					parent->_color = BLACK;
					grandfather->_color = RED;
				}
				else if (parent == grandfather->_left && cur == parent->_right)//p为g左且c为p右，左右双旋
				{
					RotateL(parent);
					RotateR(grandfather);
					cur->_color = BLACK;
					grandfather->_color = RED;
				}
				else if (parent == grandfather->_right && cur == parent->_left)//p为g右且c为p左，右左双旋
				{
					RotateR(parent);
					RotateL(grandfather);
					cur->_color = BLACK;
					grandfather->_color = RED;
				}
				_root->_color = BLACK;
				break;
			}
			else//叔叔存在且为红
			{
				parent->_color = BLACK;
				uncle->_color = BLACK;
				grandfather->_color = RED;
				cur = cur->_parent;
				parent = cur->_parent;
			}	
			_root->_color = BLACK;
		}
	}
	return true;
}

验证是否平衡 

先计算一条路径的黑色节点个数，将其他路径与其进行比较，同时检测是否有连续的红色节点。

	bool IsBanlanceTree()
	{
		Node* cur = _root;
		int BlackNum = 0;
		while (cur)//计算一条路径的黑色节点
		{
			if (cur->_color == BLACK)
				BlackNum++;
			cur = cur->_left;
		}
		return _IsBanlance(_root,BlackNum,0);
	}
bool _IsBanlance(Node* root,int BlackNum,int Bnum)//每一个根节点的左右路径黑色节点Bnum是否都等于BlackNum
{
	if (root == nullptr)
	{
		if (BlackNum != Bnum)
		{
			cout << "每条路径上的黑色节点个数不相等" << endl;
			return false;
		}
			return true;
	}
	if (root->_parent&&root->_color==RED && root->_color == RED)
	{
		cout << "有连续的红色节点" << endl;
		return false;
	}
	if (root->_color == BLACK)
		Bnum++;
	return _IsBanlance(root->_left, BlackNum, Bnum) && _IsBanlance(root->_right, BlackNum, Bnum);
}

4. 红黑树与AVL树的比较 

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

下文我们来看看红黑树封装map与set。