红黑树(《算法导论3rd》P174)

最新推荐文章于 2023-05-21 23:49:59 发布
最新推荐文章于 2023-05-21 23:49:59 发布
阅读量88 收藏
点赞数
分类专栏： 算法学习 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hclbeloved/article/details/122267970
版权

1 红黑树的性质

2 红黑树的旋转

红黑树的旋转与AVL树的旋转相同。

3 红黑树的插入

 

4 红黑树的删除

 

 4.1 红黑树删除的一个例子

5 红黑树的实现

5.1 RBTree.hpp

红黑树的声明和定义均在这个头文件中。

//file RBTree.h  
#ifndef _RB_TREE_H_  
#define _RB_TREE_H_  
#include<iostream>  
#include<string>  
#include<sstream>  
#include<fstream>  
using namespace std;

//原来的july的C++代码里面有一些问题，已经进行了修改，建议参考
//C语言版本： https://blog.csdn.net/v_JULY_v/article/details/6114226

template<class KEY, class U>
class RB_Tree
{
private:
	RB_Tree(const RB_Tree& input) {}
	const RB_Tree& operator=(const RB_Tree& input) {}
private:
	enum COLOR { RED, BLACK };
	class RB_Node
	{
	public:
		RB_Node()
		{
			//RB_COLOR = BLACK;  
			right = NULL;
			left = NULL;
			parent = NULL;
		}
		COLOR RB_COLOR;
		RB_Node* right;
		RB_Node* left;
		RB_Node* parent;
		KEY key;
		U data;
	};
public:
	RB_Tree()
	{
		this->m_nullNode = new RB_Node();
		this->m_root = m_nullNode;
		this->m_nullNode->right = NULL;
		this->m_nullNode->left = NULL;
		this->m_nullNode->parent = NULL;
		this->m_nullNode->RB_COLOR = BLACK;
	}

	bool Empty()
	{
		if (this->m_root == this->m_nullNode)
		{
			return true;
		}
		else
		{
			return false;
		}
	}

	//查找key  
	RB_Node* find(KEY key)
	{
		RB_Node* index = m_root;
		while (index != m_nullNode)
		{
			if (key < index->key)
			{
				index = index->left;  //比当前的小，往左  
			}
			else if (key > index->key)
			{
				index = index->right;  //比当前的大，往右  
			}
			else
			{
				break;
			}
		}
		return index;
	}

	//--------------------------插入结点总操作----------------------------------  
	//全部的工作，都在下述伪代码中：  
	/*RB-INSERT(T, z)
	1  y ← nil[T]                 // y 始终指向 x 的父结点。
	2  x ← root[T]              // x 指向当前树的根结点，
	3  while x ≠ nil[T]
	4      do y ← x
	5         if key[z] < key[x]           //向左，向右..
	6            then x ← left[x]
	7            else x ← right[x]   //为了找到合适的插入点，x探路跟踪路径，直到x成为NIL 为止。
	8  p[z] ← y         //y置为 插入结点z 的父结点。
	9  if y = nil[T]
	10     then root[T] ← z
	11     else if key[z] < key[y]
	12             then left[y] ← z
	13             else right[y] ← z     //此 8-13行，置z 相关的指针。
	14  left[z] ← nil[T]
	15  right[z] ← nil[T]            //设为空，
	16  color[z] ← RED             //将新插入的结点z作为红色
	17  RB-INSERT-FIXUP(T, z)
	*/
	//因为将z着为红色，可能会违反某一红黑性质，  
	//所以需要调用下面的RB-INSERT-FIXUP(T, z)来保持红黑性质。  
	bool Insert(KEY key, U data)
	{
		RB_Node* insert_point = m_nullNode;
		RB_Node* index = m_root;
		while (index != m_nullNode)
		{
			insert_point = index;
			if (key < index->key)
			{
				index = index->left;
			}
			else if (key > index->key)
			{
				index = index->right;
			}
			else
			{
				return false;
			}
		}
		RB_Node* insert_node = new RB_Node();
		insert_node->key = key;
		insert_node->data = data;
		insert_node->RB_COLOR = RED;
		insert_node->right = m_nullNode;
		insert_node->left = m_nullNode;
		insert_node->parent = insert_point;

		if (insert_point == m_nullNode) //如果插入的是一颗空树  
		{
			m_root = insert_node;
		}
		else
		{
			if (key < insert_point->key)
			{
				insert_point->left = insert_node;
			}
			else
			{
				insert_point->right = insert_node;
			}
		}
		InsertFixUp(insert_node);    //调用InsertFixUp修复红黑树性质。  
	}

	//---------------------插入结点性质修复--------------------------------  
	//3种插入情况，都在下面的伪代码中(未涉及到所有全部的插入情况)。  
	/*
	RB-INSERT-FIXUP(T, z)
	1 while color[p[z]] = RED
	2     if p[z] = left[p[p[z]]]
	3        then y ← right[p[p[z]]]
	4               if color[y] = RED
	5                  then color[p[z]] ← BLACK          Case 1
	6                         color[y] ← BLACK              Case 1
	7                         color[p[p[z]]] ← RED          Case 1
	8                         z ← p[p[z]]                      Case 1
	9               else 
	10						if z = right[p[z]]
	11                        then z ← p[z]                       Case 2
	12                               LEFT-ROTATE(T, z)         Case 2
	13                     color[p[z]] ← BLACK                 Case 3
	14                     color[p[p[z]]] ← RED                Case 3
	15                     RIGHT-ROTATE(T, p[p[z]])        Case 3
	16   else (same as then clause with "right" and "left" exchanged)
	17 color[root[T]] ← BLACK
	*/
	//然后的工作，就非常简单了，即把上述伪代码改写为下述的c++代码：  
	void InsertFixUp(RB_Node* node)
	{
		while (node->parent->RB_COLOR == RED)
		{
			if (node->parent == node->parent->parent->left)   //  
			{
				RB_Node* uncle = node->parent->parent->right;
				if (uncle->RB_COLOR == RED)   //插入情况1，z的叔叔y是红色的。  
				{
					node->parent->RB_COLOR = BLACK;
					uncle->RB_COLOR = BLACK;
					node->parent->parent->RB_COLOR = RED;
					node = node->parent->parent;
				}
				else //if (uncle->RB_COLOR == BLACK)  //此时叔叔肯定是黑色,不用再判断。插入情况2：z的叔叔y是黑色的，。  
				{
					if (node == node->parent->right) //且z是右孩子  
					{
						node = node->parent;
						RotateLeft(node);
					}
					//插入情况3：z的叔叔y是黑色的，但z是左孩子。  
					node->parent->RB_COLOR = BLACK;
					node->parent->parent->RB_COLOR = RED;
					RotateRight(node->parent->parent);
				}
			}
			else //这部分是针对为插入情况1中，z的父亲现在作为祖父的右孩子了的情况，而写的。  
				//15 else (same as then clause with "right" and "left" exchanged)  
			{
				RB_Node* uncle = node->parent->parent->left;
				if (uncle->RB_COLOR == RED)
				{
					node->parent->RB_COLOR = BLACK;
					uncle->RB_COLOR = BLACK;
					uncle->parent->RB_COLOR = RED;
					node = node->parent->parent;
				}
				else //if (uncle->RB_COLOR == BLACK)//此时叔叔肯定是黑色,不用再判断。
				{
					if (node == node->parent->left)
					{
						node = node->parent;
						RotateRight(node);     //与上述代码相比，左旋改为右旋  
					}
					node->parent->RB_COLOR = BLACK;
					node->parent->parent->RB_COLOR = RED;
					RotateLeft(node->parent->parent);   //右旋改为左旋，即可。    
				}
			}
		}
		m_root->RB_COLOR = BLACK;
	}

	//左旋代码实现  
	bool RotateLeft(RB_Node* node)
	{
		if (node == m_nullNode || node->right == m_nullNode)
		{
			return false;//can't rotate  
		}
		RB_Node* lower_right = node->right;
		lower_right->parent = node->parent;
		node->right = lower_right->left;
		if (lower_right->left != m_nullNode)
		{
			lower_right->left->parent = node;
		}
		if (node->parent == m_nullNode) //rotate node is root  
		{
			m_root = lower_right;
		}
		else
		{
			if (node == node->parent->left)
			{
				node->parent->left = lower_right;
			}
			else
			{
				node->parent->right = lower_right;
			}
		}
		node->parent = lower_right;
		lower_right->left = node;
	}

	//右旋代码实现  
	bool RotateRight(RB_Node* node)
	{
		if (node == m_nullNode || node->left == m_nullNode)
		{
			return false;//can't rotate  
		}
		RB_Node* lower_left = node->left;
		node->left = lower_left->right;
		lower_left->parent = node->parent;
		if (lower_left->right != m_nullNode)
		{
			lower_left->right->parent = node;
		}
		if (node->parent == m_nullNode) //node is root  
		{
			m_root = lower_left;
		}
		else
		{
			if (node == node->parent->right)
			{
				node->parent->right = lower_left;
			}
			else
			{
				node->parent->left = lower_left;
			}
		}
		node->parent = lower_left;
		lower_left->right = node;
	}

	//--------------------------删除结点总操作----------------------------------
	//全部的工作，都在下述伪代码中：  
	/*RB-DELETE(T, z)
	1 if left[z] = nil[T] or right[z] = nil[T]  
	2    then y ← z  
	3    else y ← TREE-SUCCESSOR(z)  
	4 if left[y] ≠ nil[T]  
	5    then x ← left[y]  
	6    else x ← right[y]  
	7 p[x] ← p[y]  
	8 if p[y] = nil[T]  
	9    then root[T] ← x  
	10    else if y = left[p[y]]  
	11            then left[p[y]] ← x  
	12            else right[p[y]] ← x  
	13 if y ≠ z  
	14    then key[z] ← key[y]  
	15         copy y's satellite data into z  
	16 if color[y] = BLACK  
	17    then RB-DELETE-FIXUP(T, x)  
	18 return y  
	*/
	bool Delete(KEY key)
	{
		RB_Node* delete_point = find(key);
		if (delete_point == m_nullNode)
		{
			return false;
		}
		if (delete_point->left != m_nullNode && delete_point->right != m_nullNode)
		{
			RB_Node* successor = InOrderSuccessor(delete_point);
			delete_point->data = successor->data;
			delete_point->key = successor->key;
			delete_point = successor;
		}
		RB_Node* delete_point_child;
		if (delete_point->right != m_nullNode)
		{
			delete_point_child = delete_point->right;
		}
		else if (delete_point->left != m_nullNode)
		{
			delete_point_child = delete_point->left;
		}
		else
		{
			delete_point_child = m_nullNode;
		}
		delete_point_child->parent = delete_point->parent;
		if (delete_point->parent == m_nullNode)//delete root node  
		{
			m_root = delete_point_child;
		}
		else if (delete_point == delete_point->parent->right)
		{
			delete_point->parent->right = delete_point_child;
		}
		else
		{
			delete_point->parent->left = delete_point_child;
		}
		
		//if (delete_point->RB_COLOR == BLACK && !(delete_point_child == m_nullNode && delete_point_child->parent == m_nullNode))
		if (delete_point->RB_COLOR == BLACK)
		{
			DeleteFixUp(delete_point_child);
		}
		delete delete_point;
		return true;
	}

	//---------------------删除结点性质修复-----------------------------------  
	//所有的工作，都在下述23行伪代码中：  
	/*
	RB-DELETE-FIXUP(T, x)
	1 while x ≠ root[T] and color[x] = BLACK
	2     if x = left[p[x]]
	3           then w ← right[p[x]]
	4                  if color[w] = RED
	5                     then color[w] ← BLACK                        Case 1
	6                            color[p[x]] ← RED                        Case 1
	7                            LEFT-ROTATE(T, p[x])                  Case 1
	8                            w ← right[p[x]]                           Case 1
	9                  if color[left[w]] = BLACK and color[right[w]] = BLACK
	10                    then color[w] ← RED                          Case 2
	11                           x ← p[x]                                   Case 2
	12                else 
	13							if color[right[w]] = BLACK
	14                            then color[left[w]] ← BLACK          Case 3
	15                                   color[w] ← RED                    Case 3
	16                                   RIGHT-ROTATE(T, w)            Case 3
	17                                   w ← right[p[x]]                    Case 3
	18                         color[w] ← color[p[x]]                     Case 4
	19                         color[p[x]] ← BLACK                        Case 4
	20                         color[right[w]] ← BLACK                   Case 4
	21                         LEFT-ROTATE(T, p[x])                     Case 4
	22                         x ← root[T]                                   Case 4
	23    else (same as then clause with "right" and "left" exchanged)
	24 color[x] ← BLACK
	*/
	//接下来的工作，很简单，即把上述伪代码改写成c++代码即可。  
	void DeleteFixUp(RB_Node* node)
	{
		while (node != m_root && node->RB_COLOR == BLACK)
		{
			if (node == node->parent->left)
			{
				RB_Node* brother = node->parent->right;
				if (brother->RB_COLOR == RED)   //情况1：x的兄弟w是红色的。  
				{
					brother->RB_COLOR = BLACK;
					node->parent->RB_COLOR = RED;
					RotateLeft(node->parent);

					/************************************************************************/
					/* 原来的代码中少了下面这一行,虽然上面的伪代码中有这一行
					*  不要认为在上面执行了 RB_Node* brother = node->parent->right;
					*  这里就不需要再次赋值了，因为经过了RotateLeft(node->parent)这就会导致node->parent->right
					*  进行了修改，所以这里要再次赋值
					*/
					/************************************************************************/
					brother = node->parent->right;
				}
   
				if (brother->left->RB_COLOR == BLACK && brother->right->RB_COLOR == BLACK)//情况2：x的兄弟w是黑色的,且w的俩个孩子都是黑色的。  					
				{
					brother->RB_COLOR = RED;
					node = node->parent;
				}
				else 
				{
					if (brother->right->RB_COLOR == BLACK)//情况3：x的兄弟w是黑色的，w的左孩子是红色且w的右孩子是黑色
					{
						brother->RB_COLOR = RED;
						brother->left->RB_COLOR = BLACK;
						RotateRight(brother);
						/************************************************************************/
						/* 原来的代码中少了下面这一行,虽然上面的伪代码中有这一行
						*  不要认为在上面执行了 RB_Node* brother = node->parent->right;
						*  这里就不需要再次赋值了，因为经过了RotateRight(brother)这就会导致node->parent->right
						*  进行了修改，所以这里要再次赋值
						*/
						/************************************************************************/
						brother = node->parent->right;
					}

					//情况4：x的兄弟w是黑色的，且w的右孩子是红色的(不关心w的左孩子的颜色)  
					brother->RB_COLOR = node->parent->RB_COLOR;
					node->parent->RB_COLOR = BLACK;
					brother->right->RB_COLOR = BLACK;
					RotateLeft(node->parent);
					node = m_root; 					
				}
			}
			else  //下述情况针对上面的情况1中，node作为右孩子而阐述的。  
				//22        else (same as then clause with "right" and "left" exchanged)  
				//同样，原理一致，只是遇到左旋改为右旋，遇到右旋改为左旋，即可。其它代码不变。  
			{
				RB_Node* brother = node->parent->left;
				if (brother->RB_COLOR == RED)
				{
					brother->RB_COLOR = BLACK;
					node->parent->RB_COLOR = RED;
					RotateRight(node->parent);
					/************************************************************************/
					/* 原来的代码中少了下面这一行,虽然上面的伪代码中有这一行
					*  不要认为在上面执行了 RB_Node* brother = node->parent->left;
					*  这里就不需要再次赋值了，因为经过了RotateRight(node->parent)这就会导致node->parent->left
					*  进行了修改，所以这里要再次赋值
					*/
					/************************************************************************/
					brother = node->parent->left;
				}

				if (brother->left->RB_COLOR == BLACK && brother->right->RB_COLOR == BLACK)
				{
					brother->RB_COLOR = RED;
					node = node->parent;
				}
				else
				{
					if (brother->left->RB_COLOR == BLACK)
					{
						brother->RB_COLOR = RED;
						brother->right->RB_COLOR = BLACK;
						RotateLeft(brother);
						/************************************************************************/
						/* 原来的代码中少了下面这一行,虽然上面的伪代码中有这一行
						*  不要认为在上面执行了 RB_Node* brother = node->parent->left;
						*  这里就不需要再次赋值了，因为经过了RotateLeft(brother)这就会导致node->parent->left
						*  进行了修改，所以这里要再次赋值
						*/
						/************************************************************************/
						brother = node->parent->left;
					}

					brother->RB_COLOR = node->parent->RB_COLOR;
					node->parent->RB_COLOR = BLACK;
					brother->left->RB_COLOR = BLACK;
					RotateRight(node->parent);
					node = m_root; 
				}
			}
		}

		node->RB_COLOR = BLACK;    //并改为黑色。  
	}

	//  
	inline RB_Node* InOrderPredecessor(RB_Node* node)
	{
		if (node == m_nullNode)       //null node has no predecessor  
		{
			return m_nullNode;
		}
		RB_Node* result = node->left;     //get node's left child  
		while (result != m_nullNode)         //try to find node's left subtree's right most node  
		{
			if (result->right != m_nullNode)
			{
				result = result->right;
			}
			else
			{
				break;
			}
		}            //after while loop result==null or result's right child is null  
		if (result == m_nullNode)
		{
			RB_Node* index = node->parent;
			result = node;
			while (index != m_nullNode && result == index->left)
			{
				result = index;
				index = index->parent;
			}
			result = index;         // first right parent or null  
		}
		return result;
	}

	//  
	inline RB_Node* InOrderSuccessor(RB_Node* node)
	{
		if (node == m_nullNode)       //null node has no successor  
		{
			return m_nullNode;
		}
		RB_Node* result = node->right;   //get node's right node  
		while (result != m_nullNode)        //try to find node's right subtree's left most node  
		{
			if (result->left != m_nullNode)
			{
				result = result->left;
			}
			else
			{
				break;
			}
		}                              //after while loop result==null or result's left child is null  
		if (result == m_nullNode)
		{
			RB_Node* index = node->parent;
			result = node;
			while (index != m_nullNode && result == index->right)
			{
				result = index;
				index = index->parent;
			}
			result = index;         //first parent's left or null  
		}
		return result;
	}

	~RB_Tree()
	{
		clear(m_root);
		delete m_nullNode;
	}

	void showRBTree()
	{
		RB_Node *now = m_root;
		showRBTree(now, 0);
	}
private:
	// utility function for destructor to destruct object;  
	void clear(RB_Node* node)
	{
		if (node == m_nullNode)
		{
			return;
		}
		else
		{
			clear(node->left);
			clear(node->right);
			delete node;
		}
	}

	void showRBTree(RB_Node* now, int d, std::string flag = "")
	{
		if (now == m_nullNode)
			return;
		for (int i = 0; i < d; i++)
			cout << "    ";
		
		cout << now->key << "(";
		cout << (flag.empty() ? "root" : flag) << ": ";
		cout << (now->RB_COLOR == BLACK ? "BLACK" : "RED") << ")";
		cout << endl;
		showRBTree(now->left, d + 1, "left");
		showRBTree(now->right, d + 1, "right");
	}
private:
	RB_Node *m_nullNode;
	RB_Node *m_root;
};
#endif /*_RB_TREE_H_*/

5.2 测试

//file test.cpp
#include<iostream>
#include<algorithm>
#include<iterator>
#include<vector>
#include<sstream>
#include"RBTree.hpp" 
using namespace std;

int main()
{
	RB_Tree<int, int> tree;
	vector<int> v;

	int i;
	for (i = 0; i < 5; ++i)
	{
		v.push_back(i);
	}
	random_shuffle(v.begin(), v.end());
	copy(v.begin(), v.end(), ostream_iterator<int>(cout, " "));
	cout << endl;
	stringstream sstr;

	cout << "========================== test insert ==========================" << endl;
	for (i = 0; i < v.size(); ++i)
	{
		tree.Insert(v[i], i);
		cout << "insert:" << v[i] << endl;   //添加结点
		tree.showRBTree();
		cout << "====================================================" << endl;
	}

	//tree.showRBTree();
	cout << "========================== test delete ==========================" << endl;
	for (i = 0; i < v.size(); ++i)
	{
		cout << "Delete:" << v[i] << endl;
		tree.Delete(v[i]);             //删除结点
		tree.showRBTree();
		cout << "====================================================" << endl;
	}

	cout << endl;
	return 0;
}

hclbeloved
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
红黑树与区间树算法实现
04-08
算法导论实验：使用c++实现红黑树的建立，插入，旋转，删除，查找全操作以及区间树的全操作。并带有红黑树的可视化展示，采用graphviz工具，需要自行安装graphviz以实现树的可视化功能。
算法导论中红黑树的实现
07-18
根据算法导论中红黑树的讲解，用C写了一个关于红黑树的建立，查询节点，插入，删除操作
C++实现红黑树（含完整代码+图）
weixin_44628585的博客
08-09 2125
此文主要记录红黑树的操作，即节点的添加删除操作，并且有完整代码可供学习。欢迎大家阅读，如有问题，麻烦大家指出。
红黑树（C++实现）
2021dragon的博客
12-06 1万+
红黑树（C++实现）
【C++】红黑树的实现
m0_65679465的博客
05-16 588
红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。map 、set 两个关联式容器的底层就是红黑树。
算法导论-第13章-红黑树
最新发布
CSDN博客
05-21 213
第12章介绍了一棵高度为h的二叉搜索树，它可以支持任何一种基本动态集合操作，如SEARCHSUCCESSORMINIMUMMAXIMUMINSERT和DELETE等，其时间复杂度均为Oh。因此，如果搜素树的高度较低时，这些操作会执行的较快。然而，如果树的高度较高时，这些操作可能不比在链表上执行得快。（red-black tree）是“平衡”搜索树的一种，可以保证在最坏情况下基本动态集合操作得时间复杂度为Ologn。
C++实现红黑树
hdsHDS6的博客
06-28 1478
C++实现红黑树，插入和删除思路
算法导论的红黑树的C++实现源码
03-29
算法导论的红黑树的C++实现源码,并附加测试验证代码
Linux内核中红黑树算法的实现详解
09-15
红黑树是平衡二叉树的一种，它有很好的性质，树中的结点都是有序的，而且因为它本身就是平衡的，所以查找也不会出现非常恶劣的情况，基于...那么本文将详细的介绍Linux内核中红黑树算法的实现，有需要的可以参考借鉴。
算法导论红黑树C++代码实现
05-15
红黑树C++代码实现
红黑树实现源码
07-22
关于红黑树的功能实现
红黑树C++实现大学生课程设计
12-11
数据结构课程设计，实现红黑树。我这有详细的设计实验报告，外加PPT，需要的话留言发给你，仅供参考嘿嘿
红黑树的C++实现
01-24
程序为红黑树的C++代码实现，主要包括插入删除查找等操作，红黑树具体可以参考算法导论第3版第13章
红黑树C++实现
Brant_zero的博客
11-24 1314
红黑树c++实现，平衡二叉搜索树。插入、查找、平衡调整、平衡判定、高度检测、升序遍历(中序遍历)
C++:红黑树
zhang_si_hang的博客
08-21 1501
1.红黑树的概念红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。（最长的路径不超过最短路径的2倍，近似平衡）2.红黑树的性质1.每个结点不是红色就是黑色2.根节点是黑色的3. 如果一个节点是红色的，则它的两个孩子结点是黑色的(没有连续的红色节点)
红黑树的详细实现(C++)
code_peak
10-08 5555
红黑树概念(concept) 树型结构主要用于搜索，一直是科学领域的重要演算法，当中探讨了树可能遇到的问题：树的成长可能偏向于一边，也就是不平衡现象。 二叉树是常见且广泛使用的一种树，面临其可能退化成链表的潜藏缺点，在使用上难免让人担心其效率。此外，在一些应用上，可能不希望这样的不平衡的可能性发生。所以具有自动平衡左右数量分布效果的演算算法早在 1962 年被提出，称为 AVL 树。这种平衡成长的二叉搜索树被称为自平衡二叉搜索树。 接下来，介绍同为自平衡二叉搜索树的红黑树对平衡性的要求比 AVL 树还要宽松
算法导论——红黑树
WaterWin的博客
11-15 543
红黑树是二叉搜索树的一种特例，它对每个节点增加了一个颜色的属性，通过增加以下的条件使得这颗二叉树更加平衡： 1.每个节点或是红色的，或是黑色的。 2.根节点是黑色的。 3.每个叶节点是黑色的。 4.如果一个节点是红色的，那么它的两个子节点都是黑色的。 5.对每个节点，从该节点到其所有后代节点的简单路径上，均包含相同数目的黑色节点。 红黑树的插入和删除如果按照二叉树的处理，那么它的性质可能被破坏，那...
红黑树的C++完整实现源码
热门推荐
结构之法 算法之道
03-29 5万+
红黑树的C++完整实现源码作者：July、saturnman。时间：二零一一年三月二十九日。出处：http://blog.csdn.net/v_JULY_v。声明：版权所有，侵权必究。-------------------------------------------前言：    本人的原创作品红黑树系列文章，至此，已经写到第5篇了。虽然第三篇文章：红黑树的c源码实现与剖析，用c语言完整实现过红
《算法导论3rd第十三章》红黑树
懒猫的脚印
11-30 1436
算法导论 第十三章 红黑树 AVL树 平衡二叉树
java编写红黑树算法
01-29
红黑树是一种自平衡二叉搜索树，它在保证二叉搜索树的查询性能的同时，还能保证插入和删除操作的时间复杂度为 O(log n)。红黑树通常用来实现 Java 中的 TreeMap 和 TreeSet 类。 红黑树的规则如下： 1. 每个节点都...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值