红黑树(C++实现)

已于 2023-06-06 16:47:05 修改
阅读量895 收藏 14
点赞数 14
分类专栏： 数据结构与算法 文章标签： 数据结构 c++
于 2023-04-17 15:21:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63300413/article/details/130166407
版权

文章目录

红黑树的概念

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

在这里插入图片描述

红黑树的性质

1: 每个结点不是红色就是黑色.

2: 根节点是黑色的

3: 如果一个结点是红色的,则它的两个孩子结点是黑色的.

4: 对于每个结点,从该结点到其所有后代叶结点的简单路径上,均包含相同数目的黑色结点.

5: 每个叶子结点都是黑色的(此处的叶子结点指的是NIL结点,也就是空结点).

依据以上5个性质,怎么保证红黑树的最长路径不会超过最短路径的两倍呢?

我们可以假设,在红黑树中,如果每个路径的黑色结点都是N个,那么在棵红黑树中最短路径长度就为N.(假设N为2)
在这里插入图片描述
根据性质3,性质4,那么最长路径也是N个黑色结点,并且由多对一黑一红结点组成,此时,最长路径的长度即为2N.(假设N为2)
在这里插入图片描述
所以,在红黑树中,最长路径长度等于最短路径长度的两倍,不可能超过最短路径的两倍.

红黑树结点的定义

我们实现的是KV模型结构的红黑树,由于红黑树需要旋转,我们将红黑树的结点定义为三叉链结构,并且添加一个新成员_col,代表结点的颜色,方便后续的变色平衡.

enum Colour
{
	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;         //存储的键值对
	Colour _col;           //标志着红黑树的颜色.
    
	RBTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_kv(kv)
		,_col(RED)       //将结点默认定义为红色.
	{
	}
};

思考: 在结点的定义中,为什么要将结点的默认颜色给成红色的?

1:如果我们在红黑树的一条路径中插入一个黑色结点,由于性质4,那么便会影响红黑树的其它路径,为了保持平衡,其他路径都可能需要变色+旋转.
2: 如果我们在红黑树的一条路径中插入一个红色结点,由于性质三,最多只会影响插入的那一条路径,我们只需要对该条路径变色+旋转来保持平衡就行.

所以,为了将红黑树的插入影响降到最低,我们选择将红黑树的结点默认定义为红色.

红黑树的插入

红黑树的插入主要分为三个步骤:
1: 找到红黑树的插入位置.
2: 将插入结点插入到寻找的插入位置.
3: 检测新结点插入后,红黑树的性质是否发生改变,并对其进行相应调整.
其中步骤1和步骤2和AVL树的插入相同,但是步骤三相较AVL树的插入有了较大改变.

那么查看红黑树性质的依据是什么?

在红黑树的插入中:
1: 如果插入结点的父亲结点是黑色的,那么该次插入并没有破坏红黑树的性质,则该次插入并不需要调整平衡.
2: 如果插入结点的父亲结点是红色的,那么根据红黑树的性质2,父亲结点一定有grandfater结点且为黑色结点.
3: 如果插入结点为父亲结点是红色的,那么根据插入结点的叔叔结点(即parent的兄弟结点)的情况,进行调整平衡.

此时有三种情况:

情况一: 插入结点的叔叔存在,并且叔叔结点的颜色为红色.

为了防止出现连续的红结点,我们需要将父亲结点变黑,又为了保持每条路径的黑色结点的个数相同,我们将祖父结点变红,将叔叔结点变黑.因此,我们既可以解决连续出现红色结点的问题,又可以保持每条路径的黑色结点相同.
变色调整抽象图如下:
在这里插入图片描述
注意:
1:如果此时的祖父结点即为整棵树的根结点,:那么为了保持根节点为黑结点的性质,我们需要将祖父变为黑色结点后,退出循环.

2: 如果此时的祖父结点为整棵树的子树,那么我们需要将cur指向祖父节点,parent指向cur的父亲结点后,根据叔叔的情况继续平衡.
在这里插入图片描述
3: 当叔叔存在且为红色结点时,cur是parent的左孩子还是右孩不影响变色平衡.

情况二: 插入结点的叔叔存在,并且叔叔结点的颜色为黑色.

插入前:
1: d,e 可以是空树或者是一个红色结点.

2: c可以是根是黑节点的子树,为例图右侧四种子树的任意一种.
在这里插入图片描述
插入后
在这里插入图片描述
由插入前后例图可见,情况二的出现主要由情况一插入时变色调整导致的.
当叔叔存在且为黑色结点时,此时需要旋转+变色调整平衡,但是旋转时打又有两种情况:
(1):如果祖先,父亲,儿子三个结点的路径为一条直线,首先,于祖父所在的红黑树来说,左子树的路径的长度已经大于最短路径的两倍了,此时需要以祖先为旋转点右单旋(降左子树的高度),为了保持红黑树的每条路径的黑色结点个数相等,我们需要将父亲结点调整为黑色结点,再将祖父结点调整为红色结点.
旋转+变色抽象图如下:
在这里插入图片描述
(2)如果祖先,父亲,儿子三个结点的路径为一条折线,我们需要先以父亲为旋转点左单旋,然后再以祖父为旋转点右单旋,将祖父调整为红色结点,将孩子结点调整为黑色结点,进而保持了每条路径的的的黑色结点个数相同.
在这里插入图片描述

注意:
颜色调整后,无论这棵树是整棵树还是子树,根节点是黑色的,且已经保持平衡,所以无需继续往上处理.

情况三: 插入结点的叔叔不存在,且a/b/c/d/e为空树

情况三又分为两种情况:
1:如果祖父,父亲,孩子结点组成的路径为一条直线:

首先祖父结点左子树的路径长度大于最短路径的两倍,此时需要以祖父右单旋降左子树高度,然后将父亲结点调整为黑色结点,将祖父结点调整为红色结点.
在这里插入图片描述

2:如果祖父,父亲,孩子结点组成的路径为一条折线.
同理,首先,我们先以父亲结点为旋转点左单旋,然后再以祖父为旋转点右单旋,最后,再将孩子结点调整为黑色结点,祖父结点调整为红色结点.
在这里插入图片描述

红黑树的插入函数代码如下:


bool Insert(const pair<K, V>& kv)            //插入函数
	{
		if (_root == nullptr) //如果为空树,直接插入结点就可以了.
		{
			_root = new Node(kv);
			return 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 false;
			}
		}
		cur = new Node(kv);               //找到插入位置并插入.
		cur->_col = RED;     //新插入结点的颜色为红色.
		if (parent->_kv.first < kv.first)  //与父亲结点建立联系
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		cur->_parent = parent;
		while ( parent && parent->_col == RED ) //达到平衡条件,需要调整平衡.
		{
			Node* grandfater = parent->_parent;
			assert(grandfater);
			assert(grandfater->_col == BLACK);
			if ( parent == grandfater->_left ) //判断父亲在祖父的位置,如果父亲在祖父的左边
			{
				Node* uncle = grandfater->_right;
				if ( uncle && uncle->_col == RED ) //将父亲和叔叔的颜色变黑,祖父的颜色变红.
				{       
					parent->_col = uncle->_col = BLACK;
					grandfater->_col = RED;
				
					cur = grandfater;             //继续向上寻找
					parent = grandfater->_parent;
				}
				else           //uncle不存在或者存在且为黑
				{      
				//     g 
			    //  p
               //cur

					if (cur == parent->_left)   //如果祖父,父亲,孩子路径为一条直线
					{
						RotateR(grandfater);
						parent->_col = BLACK;
						grandfater->_col = RED;
					}
					//    g
					// p
					//    cur
					else                       //如果祖父,父亲,孩子路径为一条折线.
					{ 
						RotateL(parent);
						RotateR(grandfater);
						cur->_col = BLACK;                  
						grandfater->_col = RED;  
					}
					//走到这里大该子树的根已经变成黑色结点了,不用再往上循环了.
					break;
				}
			}
			else                    //如果父亲在祖父的右边.
			{
				//   g
				// u   p 
				//       c
 				//
				Node* uncle = grandfater->_left;
				if (uncle && uncle->_col == RED)    //如果叔叔存在且为红色结点.
				{
					parent->_col = uncle->_col = BLACK;
					grandfater->_col = RED;
					
					cur = grandfater;      //继续向上变色循环.
					parent = grandfater->_parent;
					
				}
				else                    //如果父亲不存在,或者存在且为黑色结点.
				{
					//    g 
					//      p
	                //        c 		
					if (parent->_right == cur)      //如果父亲,祖父,孩子路径为一条直线
					{
						RotateL(grandfater);
						parent->_col = BLACK;
						grandfater->_col = RED;
					}
					//    g
					//      p
					//    c
					else                          //如果父亲,祖父,孩子路径为一条折线
					{
						RotateR(parent);
						RotateL(grandfater);
						grandfater->_col = RED;
						cur->_col = BLACK;
					}
					break;
				}

			}
		}
		_root->_col = BLACK; //走到这说明这棵树没有的祖先没有parent,或者有parent但是父亲是黑色的,不需要处理.
		return true;
	}
	void RotateL(Node* parent)         //左单旋
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;

		Node* ppNode = parent->_parent;

		subR->_left = parent;
		parent->_parent = subR;

		if (_root == parent)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subR;
			}
			else
			{
				ppNode->_right = subR;
			}

			subR->_parent = ppNode;
		}

	}
	void RotateR(Node* parent)             //右单旋
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		if (subLR)
		{
			subLR->_parent = parent;
		}

		Node* ppNode = parent->_parent;

		subL->_right = parent;
		parent->_parent = subL;

		if (_root == parent)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subL;
			}
			else
			{
				ppNode->_right = subL;
			}

			subL->_parent = ppNode;
		}

	}

红黑树的查找

查找步骤:
1: 如果所给值大于cur所指结点first,那么从左边遍历查找.
2: 如果所给值大于cur所指结点first,那么从右边遍历查找.
3: 找到了就返回.
4: 但退出循环还没找到,就说明找不到了,返回nullptr.

Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < key ) //如果key大于当前结点的first
			{
				cur = cur->_right;
			}
			else if (cur->_kv.first > key) //如果key小于当前结点的first
			{
				cur = cur->_left;
			}
			else           //寻找到了
			{
				return cur;
			}
		}
		return nullptr;
	}

红黑树的验证

检测是否满足二叉搜索树

红黑树也是一棵接近平衡的二叉搜索树,因此,我们可以通过中序遍历,进而查看是否满足二叉搜索树的性质.

void InOrder()       //中序遍历
	{
		_InOrder(_root);
	}
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_InOrder(root->_left);
		cout << root->_kv.first << ":"<< root->_kv.second << endl;
		_InOrder(root->_right);
	}

检测是否满足红黑树的性质

我们可以检测红黑树的四个性质进而推出红黑树的最长路径长度不超过最短路径的两倍.最后可以判断是否平衡.
1: 性质一可以通过代码的颜色枚举中证明.
2: 性质二和性质三可以在递归中进行判断.
3: 性质四,我们可以设计一个基准值,先求出第一条路径的黑色结点个数为基准值,然后当其他的路径走完时,将其他路径黑色结点个数与该基准值分别比较.

bool PreCheck(Node* root,int& benchMark, int blackNum) //判断性质四
	{
		if (root == nullptr)
		{
			if (benchMark == 0)
			{
				benchMark = blackNum;;
				return true;
			}
			if (blackNum != benchMark)
			{
				cout << "某条黑色结点数量不相等." << endl;
				return false;
			}
			else 
			{
				return true;
			}
		}
		if ( root->_col == RED && root->_parent->_col == RED )//判断性质三
		{
			return false;
		}
		if (root->_col == BLACK)
		{
			++blackNum;
		}
		return PreCheck(root->_left,benchMark ,blackNum) && 
		PreCheck(root->_right,benchMark, blackNum);
	}
	bool _IsBalance( Node* root ) //要从红黑树的四个性质分别判断
	{
		if (root == nullptr )
		{
			return true;
		}
		if (root->_col == RED)       //判断性质一
		{
			cout << "根节点不是黑色结点" << endl;
			return false;
		}
		int benchMark = 0;         //黑色结点数量基准值.
		 return PreCheck(root,benchMark,0);
	}

红黑树与AVL树的比较

1:红黑树和AVL树都是高效的平衡二叉树,增删查改的时间复杂度都为O(log2N),红黑树不追求绝对平衡,只需要保证最长路径的长度不超过最短路径的两倍.
2:在插入或者删除中,红黑树降低了旋转的次数,所以需要多次增删操作中,红黑树的性能比AVL树的性能更加高效,而且红黑树的实现相对AVL树来说比较简单,在实践中使用红黑树更多.

包含上述功能的红黑树代码

#include <iostream>
#include <assert.h>
#include <map>
using namespace std;
enum Colour
{
	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;         //存储的键值对
	Colour _col;           //标志着红黑树的颜色.
    
	RBTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_kv(kv)
	{
	}
};
template <class K, class V>
struct RBTree
{
	typedef RBTreeNode<K, V> Node;
public:
	Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < key ) //如果key大于当前结点的first
			{
				cur = cur->_right;
			}
			else if (cur->_kv.first > key) //如果key小于当前结点的first
			{
				cur = cur->_left;
			}
			else           //寻找到了
			{
				return cur;
			}
		}
		return nullptr;
	}
	void InOrder()
	{
		_InOrder(_root);
	}
	bool Insert(const pair<K, V>& kv)            //插入函数
	{
		if (_root == nullptr) //如果为空树,直接插入结点就可以了.
		{
			_root = new Node(kv);
			return 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 false;
			}
		}
		cur = new Node(kv);               //找到插入位置并插入.
		cur->_col = RED;     //新插入结点的颜色为红色.
		if (parent->_kv.first < kv.first)  //与父亲结点建立联系
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		cur->_parent = parent;
		while ( parent && parent->_col == RED ) //达到平衡条件,需要调整平衡.
		{
			Node* grandfater = parent->_parent;
			assert(grandfater);
			assert(grandfater->_col == BLACK);
			if ( parent == grandfater->_left ) //判断父亲在祖父的位置,如果父亲在祖父的左边
			{
				Node* uncle = grandfater->_right;
				if ( uncle && uncle->_col == RED ) //将父亲和叔叔的颜色变黑,祖父的颜色变红.
				{       
					parent->_col = uncle->_col = BLACK;
					grandfater->_col = RED;
				
					cur = grandfater;             //继续向上寻找
					parent = grandfater->_parent;
				}
				else           //uncle不存在或者存在且为黑
				{      
				//     g 
			    //  p
               //cur

					if (cur == parent->_left)   //如果祖父,父亲,孩子路径为一条直线
					{
						RotateR(grandfater);
						parent->_col = BLACK;
						grandfater->_col = RED;
					}
					//    g
					// p
					//    cur
					else                       //如果祖父,父亲,孩子路径为一条折线.
					{ 
						RotateL(parent);
						RotateR(grandfater);
						cur->_col = BLACK;                  
						grandfater->_col = RED;  
					}
					//走到这里大该子树的根已经变成黑色结点了,不用再往上循环了.
					break;
				}
			}
			else                    //如果父亲在祖父的右边.
			{
				//   g
				// u   p 
				//       c
 				//
				Node* uncle = grandfater->_left;
				if (uncle && uncle->_col == RED)    //如果叔叔存在且为红色结点.
				{
					parent->_col = uncle->_col = BLACK;
					grandfater->_col = RED;
					
					cur = grandfater;      //继续向上变色循环.
					parent = grandfater->_parent;
					
				}
				else                    //如果父亲不存在,或者存在且为黑色结点.
				{
					//    g 
					//      p
	                //        c 		
					if (parent->_right == cur)      //如果父亲,祖父,孩子路径为一条直线
					{
						RotateL(grandfater);
						parent->_col = BLACK;
						grandfater->_col = RED;
					}
					//    g
					//      p
					//    c
					else                          //如果父亲,祖父,孩子路径为一条折线
					{
						RotateR(parent);
						RotateL(grandfater);
						grandfater->_col = RED;
						cur->_col = BLACK;
					}
					break;
				}

			}
		}
		_root->_col = BLACK; //走到这说明这棵树没有的祖先没有parent,或者有parent但是父亲是黑色的,不需要处理.
		return true;
	}
	bool IsBalance()
	{
		return _IsBalance(_root);
	}
private:
	bool PreCheck(Node* root,int& benchMark, int blackNum) //判断性质四
	{
		if (root == nullptr)
		{
			if (benchMark == 0)
			{
				benchMark = blackNum;;
				return true;
			}
			if (blackNum != benchMark)
			{
				cout << "某条黑色结点数量不相等." << endl;
				return false;
			}
			else 
			{
				return true;
			}
		}
		if ( root->_col == RED && root->_parent->_col == RED )//判断性质三
		{
			return false;
		}
		if (root->_col == BLACK)
		{
			++blackNum;
		}
		return PreCheck(root->_left,benchMark ,blackNum) && 
		PreCheck(root->_right,benchMark, blackNum);
	}
	bool _IsBalance( Node* root ) //要从红黑树的四个性质分别判断
	{
		if (root == nullptr )
		{
			return true;
		}
		if (root->_col == RED)       //判断性质一
		{
			cout << "根节点不是黑色结点" << endl;
			return false;
		}
		int benchMark = 0;         //黑色结点数量基准值.
		 return PreCheck(root,benchMark,0);
	}
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_InOrder(root->_left);
		cout << root->_kv.first << ":"<< root->_kv.second << endl;
		_InOrder(root->_right);
	}
	void RotateL(Node* parent)         //左单旋
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;

		Node* ppNode = parent->_parent;

		subR->_left = parent;
		parent->_parent = subR;

		if (_root == parent)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subR;
			}
			else
			{
				ppNode->_right = subR;
			}

			subR->_parent = ppNode;
		}

	}
	void RotateR(Node* parent)             //右单旋
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		if (subLR)
		{
			subLR->_parent = parent;
		}

		Node* ppNode = parent->_parent;

		subL->_right = parent;
		parent->_parent = subL;

		if (_root == parent)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subL;
			}
			else
			{
				ppNode->_right = subL;
			}

			subL->_parent = ppNode;
		}

	}
	Node* _root = nullptr;

};
//测试1
void TestRBTree1()
{
	int a[] = { 16,3,7,11,9,26,18,14,15,0,1 };
	RBTree<int, int> t1;
	for (auto e : a)
	{
t1.Insert(make_pair(e, e));
	}
	t1.InOrder();
	cout << "IsBalance:" << t1.IsBalance() << endl;
}

//测试2
//随机数测试,使用10000个随机数测试
void TestRBTree2()
{
	size_t N = 10000;
	srand(time(0));
	RBTree<int, int> t1;
	for (size_t i = 0; i < N; ++i)
	{
		int x = rand();               //x接收产生的随机数.
		t1.Insert(make_pair(x, i));   //在树中插入随机数.
	}
	t1.InOrder();
	cout << t1.Find(1)->_kv.first << endl;
	cout << "IsBanlance:" << t1.IsBalance() << endl;
}
暂停更新
关注
专栏目录
红黑树C++代码实现
01-21
描述： 实现红黑树、二叉搜索树相关算法：插入（红黑树涉及树的调整：左旋右旋等），删除，搜索（指定Key值节点）。 另外，红黑树实现计算树黑高的算法。 1).插入测试，输入 8，11，17，15，6，1，22，25，27，建立红黑树，按照 红黑树信息输出方式 输出整棵红黑树以及黑高。 2).删除测试，删除1）中红黑树中Key=15的节点，按照 红黑树信息输出方式 输出调整后的整棵红黑树以及黑高。 3).随机产生300,000个不同自然数Key值（1－300,000），建立红黑树，查找Key=15000的节点，输出查找花费时间。 随机产生300,000个不同自然数Key值（1－300,000），建立二叉搜索树，查找Key=15000的节点，输出查找花费时间。 4). 重复3－5次3）中操作，求各自平均时间。 5). 在1)－4)的红黑树算法基础上修改完成P307 14.1-4算法 OS_Key_Rank(T,k). 输入 1,2,3,4,5,6,7,8 建树， k=6, 输出OS_Key_Rank的返回值。 详细信息看readme!
红黑树C++实现
01-27
了解红黑树的C++实现，不仅可以帮助我们掌握数据结构与算法，还能在实际项目中有效提升数据存储和检索的效率。通过学习和实践，我们可以熟练地运用红黑树解决各种复杂的问题，例如在数据库索引、编译器符号表管理等...
C++:红黑树
zhang_si_hang的博客
08-21 1809
1.红黑树的概念红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。（最长的路径不超过最短路径的2倍，近似平衡）2.红黑树的性质1.每个结点不是红色就是黑色2.根节点是黑色的3. 如果一个节点是红色的，则它的两个孩子结点是黑色的(没有连续的红色节点)
C++——红黑树（图片+动图详解）
最新发布
2301_80687320的博客
08-11 848
在了解完平衡搜索二叉树的优势和应用后，我们学习了AVL树这种方案来实现它，但在前人们的不断使用和开辟，另一种更优的方案横空出世——红黑树。一、红黑树是什么？红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路 径会比其他路径长出俩倍，因而是接近平衡的。通过图片的观察，我们发红黑树有一下几个性质1、每个结点不是红色就是黑色；2、根节点是黑色；3、红色节点不能是连续两个；
红黑树的C++完整实现源码
热门推荐
结构之法 算法之道
03-29 5万+
红黑树的C++完整实现源码作者：July、saturnman。时间：二零一一年三月二十九日。出处：http://blog.csdn.net/v_JULY_v。声明：版权所有，侵权必究。-------------------------------------------前言：    本人的原创作品红黑树系列文章，至此，已经写到第5篇了。虽然第三篇文章：红黑树的c源码实现与剖析，用c语言完整实现过红
C++ 红黑树
weixin_53946312的博客
01-28 1546
红黑树
c++——红黑树
Britney_dark的博客
11-13 4750
愿你终将与重要的人重逢！
（模板类）红黑树c++实现
10-02
红黑树的c++实现，代码注释详尽，另外在POJ上找了一个关于红黑树的题，A了，可以保证是正确的实现。 分多的小伙伴们送点分给我吧····哥另外的资源下载了500+次，但是CSDN设置每个资源分封底为100，导致现在我...
红黑树C++实现大学生课程设计
12-11
在实际编程中，C++实现红黑树时，通常会定义一个结构体或类来表示树节点，包含键值、颜色、子节点指针等属性。同时，还需要提供插入、删除、查找等方法，这些方法内部实现上述的调整逻辑。此外，为了简化操作，可以...
红黑树的c++实现，提供完整代码
03-21
以下是关于红黑树C++实现的一些补充说明: 1. 红黑树性质 - 每个节点都是红色或黑色 - 根节点是黑色 - 所有叶节点(NIL节点)都是黑色 - 如果一个节点是红色,那么它的两个子节点都是黑色(不存在两个连续的红节点) ...
C++【红黑树】
芊樱烛渊的博客
11-05 1063
AVLTree：要求左右高度差不超过1红黑树：AVLTree过分严格，可能会导致过分的旋转，那能不能不要那么严格呢？需要达到的目的，最长路径不超过最短路径的二倍。也就是说，我们的AVLTree是严格平衡，我们的红黑树是不严格平衡，而是近似平衡结果：相对而言，插入同样的数据，AVL树的旋转更多，红黑树的旋转次数更少假设N是100w，AVL树为logN的高度，也就是大概20左右但是我们的红黑树的话，最短的高度大概是logN也就是20左右，最深的应该为2*logN，为40次左右。
红黑树精短C++代码
04-13
红黑树实现前去后继排名的查询，代码经过精心简短，题目测试参考洛谷
C++实现红黑树
hdsHDS6的博客
06-28 1682
C++实现红黑树，插入和删除思路
红黑树的介绍以及代码实现(C++)
dawning
03-19 2608
红黑树简单介绍红黑树是一种满足： 根是黑色的 红色边必须为左子树，且不能有两条连续红边 不存在一个节点有2条红边 根节点到空节点的黑边相等 红黑树是一种大致平衡的二叉树，所以在插入、删除和查找操作时能保证在最坏的情况下时间复杂度为O(lgn)。 二叉搜索树在最坏情形下(当插入的元素是递增的时候)，时间复杂度为O(n)。 所以红黑树在linux内核、构造关联数组等被大量使用。查找这个没什么好说，和
C++实现红黑树（含完整代码+图）
weixin_44628585的博客
08-09 2460
此文主要记录红黑树的操作，即节点的添加删除操作，并且有完整代码可供学习。欢迎大家阅读，如有问题，麻烦大家指出。
红黑树的C++代码实现
yantingtao_sunny的博客
04-24 1068
#include #include using namespace std; #define BLACK 0 #define RED 1 template class my_rbtree;//前置声明 /* 类名:my_rbnode(红黑树节点) */ template class my_rbnode { friend class my_rbtree;//友元 public:
C++之红黑树
cls的博客
05-23 2165
红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。 4.2.2 红黑树的性质 1. 每个结点不是红色就是黑色 2. 根节点是黑色的 3. 如果一个节点是红色的，则它的两个孩子结点是黑色的，但是没有连续的红节点 4. 对于每个结点，从该结点到其所有后代叶结点的简单路径...
算法导论 红黑树的C++代码实现
sinat_24520925的专栏
12-16 628
红黑树为满足下列五个条件的特殊二叉树 每个结点要么是红的要么是黑的。  根结点是黑的。  每个叶结点（叶结点即指树尾端NIL指针或NULL结点）都是黑的。  如果一个结点是红的，那么它的两个儿子都是黑的。   对于任意结点而言，其到叶结点树尾端NIL指针的每条路径都包含相同数目的黑结点。 本文代码根据算法导论上的伪代码编写，按照先序、中序、后序输出。可直接运行，如有错误，欢迎大家指正~~~
评论 12
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

暂停更新

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

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

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

打赏作者

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

抵扣说明：

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

余额充值