红黑树实现

最新推荐文章于 2024-11-02 17:29:37 发布

爱马拉松的东宫高兴

最新推荐文章于 2024-11-02 17:29:37 发布

阅读量261

点赞数 1

分类专栏：高级数据结构 C++

本文链接：https://blog.youkuaiyun.com/qq_43780350/article/details/100020612

版权

C++ 同时被 2 个专栏收录

18 篇文章

订阅专栏

高级数据结构

4 篇文章

订阅专栏

本文深入探讨红黑树的概念、性质及其实现细节，包括节点定义、插入调整策略、旋转操作等，对比红黑树与AVL树的性能，提供代码示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

文章目录

红黑树

红黑树

红黑树的概念

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

红黑树的性质

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

总结

为什么满足上面的性质红黑树就能保证：其最长路径中节点个数不会超过最短路径节点个数的两倍？

最短的路径上节点的颜色全部都为黑色；最长的路径则为黑红交叉的路径，其上有与最短路径的黑节点数目相同的黑节点数和红节点数目。所以我们按照红黑树性质所建立的红黑树的最长路径必然不会超过最短路径的两倍！

红黑树节点的定义

enum Color
{
	RED,
	BLACK	
};
template<class T>
struct RBTreeNode
{
	RBTreeNode(const T& data = T(), Color color = RED)
		: _pLeft(nullptr)
		, _pRight(nullptr)
		, _pParent(nullptr)
		, _data(data)
		, _color(color)
	{}
	RBTreeNode<T>* _pLeft;
	RBTreeNode<T>* _pRight;
	RBTreeNode<T>* _pParent;
	T _data;
	Color _color;
};

思考题

在节点的定义中，为什么要将节点的默认颜色给成红色的？

保证每次插入操作不会导致性质4不满足

红黑树的结构

为了后续实现关联式容器简单，红黑树的实现中增加一个头结点，因为跟节点必须为黑色，为了与根节点进行区分，将头结点给成黑色，并且让头结点的pParent域指向红黑树的根节点，pLeft域指向红黑树中小的节点，_pRight域指向红黑树中大的节点，如下：
在这里插入图片描述
header的作用：放置end迭代器的位置：

end：区间中最后一个元素的下一个位置
–end：取到最后一个元素
end->left：begin(),树中最小的节点
end->right：树中最大的节点

红黑树的插入

红黑树是在二叉搜索树的基础上加上其平衡限制条件，因此红黑树的插入可分为两步：

按照二叉搜索的树规则插入新节点
检测新节点插入后，红黑树的性质是否造到破坏因为新节点的默认颜色是红色，因此：如果其双亲节点的颜色是黑色，没有违反红黑树任何性质，则不需要调整；但当新插入节点的双亲节点颜色为红色时，就违反了性质三不能有连在一起的红色节点，此时需要对红黑树分情况来讨论：
约定:cur为当前节点，p为父节点，g为祖父节点，u为叔叔节点

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

cur和p均为红，违反了性质三，此处能否将p直接改为黑？解决方式：将p,u改为黑，g改为红，然后把g当成cur，继续向上调整。

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

p为g的左孩子，cur为p的左孩子，则进行右单旋转；
相反， p为g的右孩子，cur为p的右孩子，则进行左单旋转
p、g变色–p变黑，g变红

情况三: cur为红，p为红，g为黑，u不存在/u为黑

p为g的左孩子，cur为p的右孩子，则针对p做左单旋转；相反， p为g的右孩子，cur为p的左孩子，则针对p做右单旋转则转换成了情况2

红黑树的验证

红黑树的检测分为两步：

检测其是否满足二叉搜索树(中序遍历是否为有序序列)
检测其是否满足红黑树的性质

红黑树与AVL树的比较

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

红黑树代码实现

RBTree.hpp

#pragma once
enum Color
{
	RED,
	BLACK
};
template<class T>
struct RBTreeNode
{
	RBTreeNode(const T& data = T(), Color color = RED)
		: _pLeft(nullptr)
		, _pRight(nullptr)
		, _pParent(nullptr)
		, _data(data)
		, _color(color)
	{}
	RBTreeNode<T>* _pLeft;
	RBTreeNode<T>* _pRight;
	RBTreeNode<T>* _pParent;
	T _data;
	Color _color;
};
template<class T>
struct RBTreeIterator
{
	typedef RBTreeNode<T> Node;
	typedef RBTreeIterator<T> Self;
public:
	RBTreeIterator(Node* pNode = nullptr)
		:_pNode(pNode)
	{}
	//具有指针操作
	T& operator*()
	{
		return _pNode->_data;
	}
	T* operator->()
	{
		return &(operator*());
	}
	//可以移动
	Self& operator++()//前置++
	{
		Increament();
		return *this;
	}
	Self operator++(int)//后置++
	{
		Self temp(*this);
		Increament();
		return temp;
	}
	Self&  operator--()//前置--
	{
		DeIncreament();
		return *this;
	}
	Self operator--(int)//后置-- 
	{
		Self temp(*this);
		DeIncreament();
		return temp;
	}
	bool operator==(const Self& s)const
	{
		return _pNode == s._pNode;
	}
	bool operator!=(const Self& s)const
	{
		return _pNode != s._pNode;
	}
private:
	void Increament()
	{
		if (_pNode->_pParent->_pParent == _pNode && RED == _pNode->_color)
		{
			_pNode = _pNode->_pRight;
		}
		else if (_pNode->_pRight)//右子树存在
		{
			_pNode = _pNode->_pRight;
			while (_pNode->_pLeft)
				_pNode = _pNode->_pLeft;
		}
		else
		{
			//比_pNode大的元素可能在其双亲
			Node* pParent = _pNode->_pParent;
			while (_pNode == pParent->_pRight)
			{
				_pNode = pParent;
				pParent = _pNode->_pParent;
			}
			//根节点没有右子树，并且迭代器刚好在根节点的位置
			if (_pNode->_pRight != pParent)
				_pNode = pParent;
		}
	}
	void DeIncreament()
	{
		if (_pNode->_pLeft)
		{
			//如果左子树存在，应该在左子树中找最大的节点
			_pNode = _pNode->_pLeft;
			while (_pNode->_pRight)
				_pNode = _pNode->_pRight;
		}
		else
		{
			//向上找
			Node* pParent = _pNode->_pParent;
			while (_pNode = pParent->_pLeft)
			{
				_pNode = pParent;
				pParent = _pNode->_pParent;
			}
			_pNode = pParent;
		}
	}
private:
	Node* _pNode;
};
template<class T, class KOFV>//KOFV类型
class RBTree
{
	typedef RBTreeNode<T> Node;
public:
	typedef RBTreeIterator<T> Iterator;
public:
	RBTree()
		:_size(0)
	{
		_pHead = new Node;
		_pHead->_pLeft = _pHead;
		_pHead->_pRight = _pHead;
	}
	Iterator begin()
	{
		return Iterator(_pHead->_pLeft);
	}
	Iterator end()
	{
		return Iterator(_pHead);
	}
	pair<Iterator, bool> Insert(const T& data)
	{
		Node*& pRoot = GetRoot();
		Node* pNewNode = nullptr;
		if (nullptr == pRoot)
		{
			pNewNode = pRoot = new Node(data, BLACK);
			pRoot->_pParent = _pHead;
		}
		else
		{
			//1.按照二叉搜索树的性质找到待插入节点在红黑树中的位置
			Node* pCur = pRoot;
			Node* pParent = nullptr;
			while (pCur)
			{
				pParent = pCur;
				if (KOFV()(data) < KOFV()(pCur->_data))
					pCur = pCur->_pLeft;
				else if (KOFV()(data) > KOFV()(pCur->_data))
					pCur = pCur->_pRight;
				else
					return make_pair(Iterator(pCur), false);
			}
			//插入新节点
			pNewNode = pCur = new Node(data);
			if (KOFV()(data) < KOFV()(pParent->_data))
				pParent->_pLeft = pCur;
			else
				pParent->_pRight = pCur;
			pCur->_pParent = pParent;

			//检测：是否新节点插入后，是否有连在一起的红色节点
			while (pParent != _pHead && RED == pParent->_color)
			{
				Node* grandFather = pParent->_pParent;
				if (pParent == grandFather->_pLeft)
				{
					Node* uncle = grandFather->_pRight;
					//情况一：叔叔节点存在，且为红
					if (uncle&&RED == uncle->_color)
					{
						pParent->_color = BLACK;
						uncle->_color = BLACK;
						grandFather->_color = RED;
						pCur = grandFather;
						pParent = pCur->_pParent;
					}
					else
					{
						//情况三
						if (pCur == pParent->_pRight)
						{
							_RotateLeft(pParent);
							swap(pParent, pCur);
						}
						//情况二
						pParent->_color = BLACK;
						grandFather->_color = RED;
						_RotateRight(grandFather);
					}
				}
				else
				{
					Node* uncle = grandFather->_pLeft;
					if (uncle&&RED == uncle->_color)
					{
						pParent->_color = BLACK;
						uncle->_color = BLACK;
						grandFather->_color = RED;
						pCur = grandFather;
						pParent = pCur->_pParent;
					}
					else
					{
						if (pCur == pParent->_pLeft)
						{
							_RotateRight(pParent);
							swap(pParent, pCur);
						}

						pParent->_color = BLACK;
						grandFather->_color = RED;
						_RotateLeft(grandFather);
					}
				}
			}
		}
		++_size;
		pRoot->_color = BLACK;
		_pHead->_pLeft = LeftMost();
		_pHead->_pRight = RightMost();
		return make_pair(Iterator(pNewNode), true);
	}

	Iterator Find(const T& data)const
	{
		Node* pCur = _pHead->_pParent;
		while (pCur)
		{
			if (KOFV()(data) == KOFV()(pCur->_data))
				return Iterator(pCur);
			else if (KOFV()(data) < KOFV()(pCur->_data))
				pCur = pCur->_pLeft;
			else
				pCur = pCur->_pRight;
		}
		return end();
	}
	void InOrder()
	{
		_InOrder(GetRoot());
		cout << endl;
	}

	bool IsVaildRBTree()
	{
		Node* pRoot = GetRoot();
		if (nullptr == pRoot)
			return true;

		if (pRoot->_color != BLACK)
		{
			cout << "违反性质1：根节点颜色必须为黑色" << endl;
			return false;
		}

		size_t blackCount = 0;
		Node* pCur = pRoot;
		while (pCur)
		{
			if (pCur->_color == BLACK)
				blackCount++;
			pCur = pCur->_pLeft;
		}

		size_t pathBlack = 0;
		return _IsValidRBTree(pRoot, blackCount, pathBlack);
	}
	bool Empty()const
	{
		return nullptr == _pHead->_pParent;
	}
	size_t Size()const
	{
		return _size;
	}
protected:
	bool _IsValidRBTree(Node* pRoot, size_t blackCount, size_t pathBlack)
	{
		if (nullptr == pRoot)
			return true;
		if (pRoot->_color == BLACK)
			pathBlack++;
		//检测性质三
		Node* pParent = pRoot->_pParent;
		if (pParent != _pHead && pParent->_color == RED && pRoot->_color == RED)
		{
			cout << "违反性质三：不能有连在一起的红色节点" << endl;
			return false;
		}

		//一条路径到叶子
		if (pRoot->_pLeft == nullptr&&pRoot->_pRight == nullptr)
		{
			if (blackCount != pathBlack)
			{
				cout << "违反性质4：每条路径中黑色节点个数必须相同" << endl;
				return false;
			}
		}
		return _IsValidRBTree(pRoot->_pLeft, blackCount, pathBlack) &&
			_IsValidRBTree(pRoot->_pRight, blackCount, pathBlack);
	}
	Node*& GetRoot()
	{
		return _pHead->_pParent;
	}
	void _InOrder(Node* pRoot)
	{
		if (pRoot)
		{
			_InOrder(pRoot->_pLeft);
			cout << pRoot->_data << " ";
			_InOrder(pRoot->_pRight);
		}
	}
	void _RotateRight(Node* pParent)//右单旋
	{
		Node *pSubL = pParent->_pLeft;
		Node* pSubLR = pSubL->_pRight;

		//更新孩子指针域
		pParent->_pLeft = pSubLR;
		if (pSubLR)
			pSubLR->_pParent = pParent;
		pSubL->_pRight = pParent;

		//更新双亲指针域
		Node* pPParent = pParent->_pParent;
		pParent->_pParent = pSubL;
		pSubL->_pParent = pPParent;

		//判断pParent：根节点||非根节点(pParent可能为其双亲的左或右孩子)
		if (pPParent == _pHead)
			GetRoot() = pSubL;
		else
		{
			if (pParent == pPParent->_pLeft)
				pPParent->_pLeft = pSubL;
			else
				pPParent->_pRight = pSubL;
		}
	}

	void _RotateLeft(Node* pParent)//左单旋
	{
		Node *pSubR = pParent->_pRight;
		Node* pSubRL = pSubR->_pLeft;

		//更新孩子指针域
		pParent->_pRight = pSubRL;
		if (pSubRL)
			pSubRL->_pParent = pParent;
		pSubR->_pLeft = pParent;

		//更新双亲指针域
		Node* pPParent = pParent->_pParent;

		pSubR->_pParent = pPParent;
		pParent->_pParent = pSubR;
		//判断pParent：根节点||非根节点(pParent可能为其双亲的左或右孩子)
		if (pPParent == _pHead)
			GetRoot() = pSubR;
		else
		{
			if (pParent == pPParent->_pLeft)
				pPParent->_pLeft = pSubR;
			else
				pPParent->_pRight = pSubR;
		}
	}
	Node* LeftMost()
	{
		Node* pRoot = GetRoot();
		if (nullptr == pRoot)
			return _pHead;

		Node* pCur = pRoot;
		while (pCur->_pLeft)
			pCur = pCur->_pLeft;

		return pCur;
	}
	Node* RightMost()
	{
		Node* pRoot = GetRoot();
		if (nullptr == pRoot)
			return _pHead;

		Node* pCur = pRoot;
		while (pCur->_pRight)
			pCur = pCur->_pRight;
		return pCur;
	}
private:
	Node* _pHead;
	size_t _size;//记录红黑树中有效节点个数
};
struct KeyOfValue
{
	int operator()(int data)
	{
		return data;
	}
};
void TestRBTree()
{
	int array[] = { 16,3,7,11,9,26,18,14,15 };
	RBTree<int, KeyOfValue> t;
	for (auto e : array)
		t.Insert(e);

	t.InOrder();
	RBTree<int, KeyOfValue>::Iterator it = t.begin();
	while (it != t.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
}