【C++】红黑树

文章目录

  • 红黑树的概念
  • 红黑树的性质
  • 红黑树的节点定义
  • 红黑树的结构
  • 红黑树的插入操作
  • 红黑树的验证
  • 红黑树删除
  • 红黑树模拟实现STL中的map与set
  • 改造红黑树
  • map的模拟实现
  • set的模拟实现

红黑树的概念

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

【C++】红黑树_第1张图片

红黑树的性质

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

红黑树的节点定义

    enum class Colour : unsigned int//class是用来限制类型的
	{
		RED,
		BLACK
	};

	template<class T>
	struct RBTreeNode
	{
		RBTreeNode<T>* _left;
		RBTreeNode<T>* _right;
		RBTreeNode<T>* _parent;
		T _data;
		Colour _col;

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

这里是将眼色默认设定成为红色,原因是在上述写的红黑树的性质中有两条的内容是这样写的,不能连续出现红节点,和每条路径下的黑节点数量必须相同。在两者必须要违反一种的情况下选择了前者。前者的代价要比后者的代价小得多。

红黑树的结构

为了后续实现关联式容器简单,红黑树的实现中增加一个头结点,因为跟节点必须为黑色,为了
与根节点进行区分,将头结点给成黑色,并且让头结点的 pParent 域指向红黑树的根节点,pLeft
域指向红黑树中最小的节点,_pRight域指向红黑树中最大的节点,如下:
【C++】红黑树_第2张图片
上述的结构式STL源码当中的结构,而我接下来要写的不是上述的结构。

红黑树的插入操作

红黑树是在二叉搜索树的基础上加上其平衡限制条件,因此红黑树的插入可分为两步:
1. 按照二叉搜索的树规则插入新节点

if (_root == nullptr)
{
	_root = new Node(data);
	_root->_col = Colour::BLACK;
	return make_pair(itertor(_root), true);
}

Node* parent = nullptr;
Node* cur = _root;
KeyofValue kov;
while (cur)
{
	if (kov(cur->_data) < kov(data))
	{
		parent = cur;
		cur = cur->_right;
	}
	else if (kov(cur->_data) > kov(data))
	{
		parent = cur;
		cur = cur->_left;
	}
	else
	{
		return make_pair(itertor(cur), false);
	}
}

cur = new Node(data);
Node* newnode = cur;
if (kov(parent->_data) > kov(data))
{
	parent->_left = cur;
}
else
{
	parent->_right = cur;
}
cur->_parent = parent;

上面的代码是第一步,为了找到插入节点属于他的位置。就是二叉搜索树的结构。

2、检测新节点插入后,红黑树的性质是否造到破坏

while (parent && parent->_col == Colour::RED)
{
	Node* grandfather = parent->_parent;
	if (parent == grandfather->_left)
	{
		Node* uncle = grandfather->_right;
		if (uncle && uncle->_col == Colour::RED)
		{
			// 情况1:u存在且为红,变色处理,并继续往上处理
			parent->_col = Colour::BLACK;
			uncle->_col = Colour::BLACK;
			grandfather->_col = Colour::RED;

			cur = grandfather;
			parent = cur->_parent;
		}
		else
		{
			// 情况2+3:u不存在/u存在且为黑,旋转+变色
			//    g
			//  p   u
			// c
			if (cur == parent->_left)
			{
				RotateR(grandfather);
				parent->_col = Colour::BLACK;
				grandfather->_col = Colour::RED;
			}
			else
			{
				//    g
				//  p   u
				//    c
				RotateL(parent);
				RotateR(grandfather);

				cur->_col = Colour::BLACK;
				grandfather->_col = Colour::RED;
			}
			break;//旋转了就可以退出了
		}

	}
	else // (grandfather->_right == parent)
	{
		//    g
		//  u   p
		//        c
		Node* uncle = grandfather->_left;
		// 情况1:u存在且为红,变色处理,并继续往上处理
		if (uncle && uncle->_col == Colour::RED)
		{
			parent->_col = Colour::BLACK;
			uncle->_col = Colour::BLACK;
			grandfather->_col = Colour::RED;

			// 继续往上调整
			cur = grandfather;
			parent = cur->_parent;
		}
		else // 情况2+3:u不存在/u存在且为黑,旋转+变色
		{
			//    g
			//  u   p
			//        c
			if (cur == parent->_right)
			{
				RotateL(grandfather);
				grandfather->_col = Colour::RED;
				parent->_col = Colour::BLACK;
			}
			else
			{
				//    g
				//  u   p
				//    c
				RotateR(parent);
				RotateL(grandfather);
				cur->_col = Colour::BLACK;
				grandfather->_col = Colour::RED;
			}

			break;
		}
	}
}

_root->_col = Colour::BLACK;

return make_pair(itertor(newnode), true);

因为新节点的默认颜色是红色,因此:如果其双亲节点的颜色是黑色,没有违反红黑树任何
性质,则不需要调整;但当新插入节点的双亲节点颜色为红色时,就违反了性质三不能有连
在一起的红色节点,此时需要对红黑树分情况来讨论:
约定:cur为当前节点,p为父节点,g为祖父节点,u为叔叔节点

  • 情况一: cur为红,p为红,g为黑,u存在且为红
    【C++】红黑树_第3张图片
    【C++】红黑树_第4张图片
    cur和p均为红,违反了性质三,此处能否将p直接改为黑?
    解决方式:将p,u改为黑,g改为红,然后把g当成cur,继续向上调整。
  • 情况二: cur为红,p为红,g为黑,u不存在/u存在且为黑
    【C++】红黑树_第5张图片
    【C++】红黑树_第6张图片
    p为g的左孩子,cur为p的左孩子,则进行右单旋转;相反,
    p为g的右孩子,cur为p的右孩子,则进行左单旋转
    p、g变色–p变黑,g变红
  • 情况三: cur为红,p为红,g为黑,u不存在/u存在且为黑
    【C++】红黑树_第7张图片

红黑树的验证

红黑树的检测分为两步:

    1. 检测其是否满足二叉搜索树(中序遍历是否为有序序列)
    1. 检测其是否满足红黑树的性质
bool IsBalance()
		{
			if (_root && _root->_col == Colour::RED)
			{
				cout << "根节点颜色是红色" << endl;
				return false;
			}

			int benchmark = 0;
			Node* cur = _root;
			while (cur)
			{
				if (cur->_col == Colour::BLACK)
					++benchmark;
				cur = cur->_left;
			}

			// 连续红色节点
			return _Check(_root, 0, benchmark);
		}
bool _Check(Node* root, int blackNum, int benchmark)
{
	if (root == nullptr)
	{
		if (benchmark != blackNum)
		{
			cout << "某条路径黑色节点的数量不相等" << endl;
			return false;
		}

		return true;
	}

	if (root->_col == Colour::BLACK)
	{
		++blackNum;
	}

	if (root->_col == Colour::RED
		&& root->_parent
		&& root->_parent->_col == Colour::RED)
	{
		cout << "存在连续的红色节点" << endl;
		return false;
	}

	return _Check(root->_left, blackNum, benchmark)
		&& _Check(root->_right, blackNum, benchmark);
}

红黑树删除

传送门

红黑树模拟实现STL中的map与set

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

  • operator++()与operator–()
// 找迭代器的下一个节点,下一个节点肯定比其大
void Increasement()
{
    //分两种情况讨论:_pNode的右子树存在和不存在
    // 右子树存在
 if(_pNode->_pRight)
 {
         // 右子树中最小的节点,即右子树中最左侧节点
 _pNode = _pNode->_pRight;
 while(_pNode->_pLeft)
 _pNode = _pNode->_pLeft;
 }
 else
 {
         // 右子树不存在,向上查找,直到_pNode != pParent->right
 PNode pParent = _pNode->_pParent;
 while(pParent->_pRight == _pNode)
 {
 _pNode = pParent;
 pParent = _pNode->_pParent;
 }
 // 特殊情况:根节点没有右子树
 if(_pNode->_pRight != pParent)
 _pNode = pParent;
 }
}
// 获取迭代器指向节点的前一个节点
void Decreasement()
{
     //分三种情况讨论:_pNode 在head的位置,_pNode 左子树存在,_pNode 左子树不
存在
     // 1. _pNode 在head的位置,--应该将_pNode放在红黑树中最大节点的位置
 if(_pNode->_pParent->_pParent == _pNode && _pNode->_color == RED)
 _pNode = _pNode->_pRight;
 else if(_pNode->_pLeft)
 {
        // 2. _pNode的左子树存在,在左子树中找最大的节点,即左子树中最右侧节点
 _pNode = _pNode->_pLeft;
 while(_pNode->_pRight)
 _pNode = _pNode->_pRight;
 }
 else
 {
         // _pNode的左子树不存在,只能向上找
 PNode pParent = _pNode->_pParent;
 while(_pNode == pParent->_pLeft)
 {
 _pNode = pParent;
 pParent = _pNode->_pParent;
 }
 _pNode = pParent;
 }
}

改造红黑树

// 因为关联式容器中存储的是的键值对,因此
// k为key的类型,
// ValueType: 如果是map,则为pair; 如果是set,则为k
// KeyOfValue: 通过value来获取key的一个仿函数类
template<class K, class ValueType, class KeyOfValue>
class RBTree
{
 typedef RBTreeNode<ValueType> Node;
 typedef Node* PNode;
public:
 typedef RBTreeIterator<ValueType, ValueType*, ValueType&> Iterator;
public:
  RBTree();
 ~RBTree()
 /
 // Iterator
 Iterator Begin(){ return Iterator(_pHead->_pLeft);}
 Iterator End(){ return Iterator(_pHead);}
 //
 // Modify
 pair<Iterator, bool> Insert(const ValueType& data)
 {
      // 插入节点并进行调整
      // 参考上文...
 return make_pair(Iterator(pNewNode), true);
 }
 // 将红黑树中的节点清空
 void Clear();
 Iterator Find(const K& key);
 //
 // capacity
 size_t Size()const;
 bool Empty()const;
  // ……
private:
 PNode _pHead;
 size_t _size;  // 红黑树中有效节点的个数
};

map的模拟实现

template<class K, class V>
 class map
 {
 typedef pair<K, V> ValueType;
      // 作用:将value中的key提取出来
 struct KeyOfValue
 {
 const K& operator()(const ValueType& v)
 { return v.first;}
 };
 typedef RBTree<K, ValueType, KeyOfValue> RBTree;
 public:
 typedef typename RBTree::Iterator iterator;
 public:
 map(){}
 /
 // Iterator
 iterator begin(){ return _t.Begin();}
 iterator end(){ return _t.End();}
 /
 // Capacity
 size_t size()const{ return _t.Size();}
 bool empty()const{ return _t.Empty();}
比特就业课
4.3.4 set的模拟实现
set的底层为红黑树,因此只需在set内部封装一棵红黑树,即可将该容器实现出来(具体实现可参
考map)/
 // Acess
 V& operator[](const K& key)
 { return (*(_t.Insert(ValueType(key, V()))).first).second;}
 const V& operator[](const K& key)const;
 
 // modify
 pair<iterator, bool> insert(const ValueType& data) { return
_t.Insert(data);}
 void clear(){ _t.Clear();}
 iterator find(const K& key){ return _t.Find(key);}
 private:
 RBTree _t;
 };

set的模拟实现

template<class K>
 class set
 {
 typedef K ValueType;
 // 作用是:将value中的key提取出来
 struct KeyOfValue
 {
 const K& operator()(const ValueType& key)
 { return key;}
 };
      // 红黑树类型重命名
 typedef RBTree<K, ValueType, KeyOfValue> RBTree;
 public:
 typedef typename RBTree::Iterator iterator;
 public:
 Set(){}
 /
 // Iterator
 iterator Begin();
 iterator End();
 /
 // Capacity
 size_t size()const;
 bool empty()const;
 
 // modify
 pair<iterator, bool> insert(const ValueType& data)
 {
 return _t.Insert(data);
 }
 void clear();
 iterator find(const K& key);
 private:
 RBTree _t;
 };

你可能感兴趣的:(c++,c++,开发语言)