红黑树的研究

最新推荐文章于 2021-11-30 21:33:50 发布
最新推荐文章于 2021-11-30 21:33:50 发布
阅读量1.5k 收藏 3
点赞数
分类专栏： 数据结构算法 文章标签： 算法数据结构红黑树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaojsj111/article/details/41541577
版权

1 概念、原理


1.1  什么是红黑树，相对于平衡二叉树（AVL）有什么优点

红黑树（Red Black Tree）：是一颗二叉搜索树，它在每个结点上增加了一个存储位来表示结点的颜色，可以是RED或BLACK。通过对任何一条从根到叶子的简单路径上各个结点的颜色进行约束，红黑树确保没有一条路径会比其他路径长出2倍，因为是近似平衡的。

树中每个结点包含5个属性：color、key、left、right和p。如果一个结点没有子结点或父结点，则该结点相应指针属性的值为NIL。

红黑树和AVL树类似，都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。自从红黑树出来后，AVL树就被放到了博物馆里，据说是红黑树有更好的效率，更高的统计性能。红黑树和AVL树的区别在于它使用颜色来标识结点的高度，它所追求的是局部平衡而不是AVL树中的非常严格的平衡。


1.2  红黑树的规则：

  1. 根就是黑结点
  2. 一个结点不是红就是黑
  3. 每个叶子结点（NIL）是黑的
  4. 如果一个结点是红色的，则它的两个子结点都是黑色的。（即不存在两个连续的红色结点）
  5. 任意一个结点，到他的所有叶子结点的所有路径的黑高度（即黑色结点数）都是一样的。
  6. 每个叶子结点都带有两个空的黑色结点（被称为黑哨兵），如果一个结点n的只有一个左孩子，那么n的右孩子是一个黑哨兵；如果结点n只有一个右孩子，那么n的左孩子是一个黑哨兵

红黑树的这6个性质中，第6点是比较难理解的，但它却非常有必要。我们看图1中的左边这张图，如果不使用黑哨兵，它完全满足红黑树性质，结点50到两个叶结点8和叶结点82路径上的黑色结点数都为2个。但如果加入黑哨兵后（如图1右图中的小黑圆点），叶结点的个数变为8个黑哨兵，根结点50到这8个叶结点路径上的黑高度就不一样了，所以它并不是一棵红黑树


1.3 左旋、右旋：

不管是左旋还是右旋都不改变树中左，中，右节点的大小关系（即前后继的关系）。这也是定义左右旋的基本原则，下面是摘自算法导论一节中关于左右旋的定义。左右旋的定义太重要了，然后网上一大把讲红黑树的文章，但缺把这个最重要的两个概念的定义给忽略了，左右旋是有如下的明确定义的，并且他为什么这么定义，是很有讲究的，下面说的很清楚，这个选择可以改变树的结构，但不会改变二叉树的性质，这一点很重要。有了这个性质，就决定了这个旋转是唯一合法的。


左旋涉及到的结点的指针操作有三处（见如下图），如果我们把结点之间的连接表示为一条边的话，那这个旋转就涉及到3条边（如下图标注的1,2,3），而每条边都对应两个指针，即一个是从父指向儿子{左儿子(z.p->left)或右儿子(z.p->right)}，一个从儿子指向父（z.p）


左旋对应的代码（下面代码中的step1，step2，step3对应修改上面图中的边1，边2，边3）： 
bool RBTree::RB_left_rotate(RBTree & T, Node & z)
{
	Node * y = z.right;
	
	z.right = y->left;			//step1
	if(y->left != T.nil)		        //step1
		y->left->p = &z;		//step1		

	y->p = z.p;				//step2
	if(z.p == T.nil)
	{
		T.Root = y;
	}else if(z.p->left == &z)
	{
		z.p->left = y;
	}else  //z.p->right == z
	{
		z.p->right =y;
	}					//step2

	y->left = &z;				//step3
	z.p = y;				//step3

	return true;
}
右旋此处省略。详细的就参考下面的代码。

2 红黑树的插入


2.1 插入规则

插入规则规定，刚插入的新结点都是红色的，这样就保证了，新插入的结点不破外树的黑高度（即红黑树的性质5得以保持），但可能会导致出现两个连续的红色结点（破外性质4）。所以当新插入的节点跟他对应的父节点都是红色时（z和z.p的color都是RED时），需要做些旋转和着色来保持树的红黑性质。
分三种情况（z是新插入的结点，且是红色的；z.p是z的父节点，且也是红色的；y是z的叔（z.p.p.right or z.p.p.left））：
  1. z的叔结点y是红色的
  2. z的叔结点y是黑色的，且z是一个右孩子
  3. z的叔结点y是黑色的，且z是一个左孩子
关于情况1的处理，见下面（摘自算法导论）

情况2可以通过左旋变成情况3，注意由于这里左旋的A和B结点都是红色，所以该旋转不改变红黑树的性质。
情况3：通过交换B和C的颜色，并且左旋或右旋来达到使树保持红黑的性质




由于刚插入的结点都是红色的，即插入时，保证了树的黑高度不变，但我们知道一颗树从最开始只有一个结点（即黑高速是1），到后面随着结点的不断插入，树的黑高度会增加，那是怎么增加的呢？奥秘就是在红黑树的第一条性质中（根结点是黑结点）。

2.2 红黑树的插入实例
在了解了红黑树的插入规则后，理解和深化这个过程最有效的方法就是自己试着动手画几个数值被插入到红黑树时，应该如何变换这个节点，使其满足红黑树的性质。
例如下面就用算法导论一书中的一个题目来加深理解红黑的这个插入变换过程：将关键字41,38,31,12,19,8连续地插入一颗初始为空的红黑树之后，试画出该结果树。 下面即是这个插入的变换过程图：


3红黑树的删除

红黑树本身是一棵二叉查找树，它的删除和二叉查找树的删除类似。首先要找到真正的删除点，当被删除结点n存在左右孩子时，真正的删除点应该是n的中序遍历前驱（或后继），关于这一点请复习二叉查找树的删除。如下图所示，当删除结点20时，实际被删除的结点应该为18，结点20的数据变为18。


3.1 删除时一些重要的结论：

  1. 删除操作中真正被删除的必定是只有一个红色孩子或没有孩子的结点。
  2. 如果真正的删除点是一个红色结点，那么它必定是一个叶子结点
关于第一点做如下说明：因为正真被删除的节点，一定是所在分支最小或是最大的节点，所以他不可能是带有两个孩子的节点，因为如果是这样的话，这个节点即不是最大的，也不是最小的。所以该节点只能是一个不带孩子或是只带一个孩子的节点。如果带一个孩子，则这个孩子只能是红色的，如果是黑色的，则会出现黑高不一致的情形。
关于第二点的说明：根据第一点的结论，该红色节点如果不是叶子节点，则只能是带一个孩子的红色节点，并且该孩子还只能是黑色的，这样的，就会导致黑高度不一致，所以只能是红色不带孩子的叶子节点。

3.2 红黑树的删除过程：

在红黑树的删除操作中，删除的目标结点标记为z，而真正被删除的则是z的后继y（tree_minimum（z.right）），而x则是y的后继(y.right，为什么不是y.left?因为y已经是所在分支的最小值，如果y存在左分支，则y就不会是最小的，所以y的后继只能是y.right，按升序排列).
删除过程中，将y迁移到z：即在删除结点z前，将z的左右孩子指针（y.left/right=z.left/right）、父指针（y.p=z.p）、颜色(y.color=z.color)拷贝到y，但保留y的key值，并将原来z的左右孩子对应的父指针修改指向为y(z.left.p=y,z.right.p=y), 还需要将将z的父的孩子指针修改指向y（z.p.left/right=y）,然后将y的后继x填充到y原来的位置:
  • 当y是黑色时（z.color == BLACK），由于y被删除了，所以会导致红黑树的黑高度减少，所以需要进行变换，让树重新恢复黑高度;此时会将y的黑色虚拟的加到x上面，使x成为一个双重的黑色。但在实际的变换过程中，x可能是双重黑色或是红黑色，这个要特别注意。变换的目的就是将双重黑或是红黑结点中的一重黑在该结点所在的分支变换出一个额外的黑色结点，从而达到保持树的黑高度的目的。
  • 当y是红色时（z.color == RED），由于删除的y并未影响黑高度，并且由于y是红色的，则y的后继x必定是黑色的，所以不会出现连续两个红色，所以此时只需要将x填充到y的位置即可。
删除的基本算法（当y为BLACK时，分四种情况来讨论，详细见下面）：


当z.color == BLACK时，则需要做些变换来保持红黑树的平衡（分为4中情况，对应上面代码的四种case）:

  • case1 x的兄弟结点w（w=x.p.right/left）是红色的
  • case2 x的兄弟结点w是黑色的，而且w的两个子结点都是黑色的（双黑）
  • case3 x的兄弟结点w是黑色的，w的左孩子是红色的，w的右孩子是黑色的
  • case4 x的兄弟结点w是黑色的，且w的右孩子是红色的

4 c++源代码实现

该红黑树的c++实现，是根据《算法导论》中的伪代码实现的。
主要是实现了红黑树的插入、删除操作。RBTree.h文件如下，主要是类的声明 
#pragma once
#include <iostream>
#include <stdlib.h>

class RBTree
{
	class Node;
private:
	bool RB_left_rotate(RBTree & T, Node & z);
	Node * tree_minimum(RBTree & T,Node & z);
	bool RB_right_rotate(RBTree & T, Node & z);
	bool RB_transplant(RBTree & T, Node & old_one, Node & new_one);
	bool RB_insert_fixup(RBTree & T, Node * z);
	bool RB_delete_fixup(RBTree & T, Node * z);
public:
	enum {BLACK = 0, RED};
	class Node{
		public:
			Node * left;
			Node * right;
			Node * p;
			bool color;
			int key;

			//Node & operator=(const Node & z){left = z.left; right = z.right; p = z.p; color = z.color;}
			Node(Node * L, Node  * R, Node * P, bool C = RED, int key1 = -1 )
			{left = L; right = R; p = P; color = C; key = key1;
				std::cout <<"not default contructor function"<<std::endl; }
			Node(){left = NULL; right = NULL; p = NULL; color = RED; key = -1;
				std::cout << "default contructor function"<<std::endl;}
	};
	Node *Root;
	Node *nil;
	// 红黑树的插入
	bool RB_insert(RBTree & T, Node & z);
	// 红黑树的删除
	RBTree::Node * RB_delete(RBTree & T, Node & z);
	// 红黑树的查找（依赖于遍历）
	RBTree::Node * RB_search(RBTree & T, int key);
	// 红黑树的遍历
	RBTree::Node *  RB_next(RBTree & T);
	RBTree::Node *  RB_next(const Node * z); 
	RBTree(void);
	~RBTree(void);
};
RBTree.cpp文件如下，主要是类的定义 
#include "RBTree.h"
#include <string>
using std::cout;
using std::cin;
using std::endl;
using std::string;
//using namespace Redblack;

RBTree::RBTree(void)
{
	cout <<"RBTree()\n";
	nil = new Node(NULL, NULL, NULL, BLACK, -1);
	Root = nil;
}


RBTree::~RBTree(void)
{
	if(nil){
		delete nil;
		nil = NULL;
	}
}
//递归实现方法
RBTree::Node * RBTree::tree_minimum(RBTree & T,Node & z)
{
	if(z.left == T.nil)
		return &z;
	else
	{
		return tree_minimum(T,*(z.left));
	}
}
bool RBTree::RB_left_rotate(RBTree & T, Node & z)
{
	Node * y = z.right;
	
	z.right = y->left;			//step1
	if(y->left != T.nil)		//step1
		y->left->p = &z;		//step1		

	y->p = z.p;					//step2
	if(z.p == T.nil)
	{
		T.Root = y;
	}else if(z.p->left == &z)
	{
		z.p->left = y;
	}else  //z.p->right == z
	{
		z.p->right =y;
	}							//step2

	y->left = &z;				//step3
	z.p = y;					//step3

	return true;
}
bool RBTree::RB_right_rotate(RBTree & T, Node & z)
{
	Node * y = z.left;

	z.left = y->right;
	if(y->right != T.nil)
		y->right->p = &z;

	y->p = z.p;
	if(z.p == T.nil)
	{
		T.Root = y;
	}else if(z.p->left == &z)
	{
		z.p->left = y;
	}else //z.p->right == &z
	{
		z.p->right = y;
	}

	y->right = &z;
	z.p = y;

	return true;
}
/*将v迁移到u的位置，
case1:
	u为root
case2：u为右分支
   \      ------->        \
    u					   v
................................
case3：u为左分支
	 /      ------->        /
    u					   v
*/
bool RBTree::RB_transplant(RBTree & T, Node & u, Node & v)
{
	if(u.p == T.nil) //case1
	{
		T.Root = &v;
	}else if(&u == u.p->right) //case2
	{
		u.p->right = &v;
	}else //case3
	{
		u.p->left = &v;
	}
	v.p = u.p;
	return true;
}
//bool RBTree::RB_insert_fixup(RBTree & T, Node & z)
bool RBTree::RB_insert_fixup(RBTree & T, Node * z)
{
	Node * uncle;
	while(z->p->color == RED)
	{
		if(z->p == z->p->p->left)  //父节点处在左分支
		{
			uncle = z->p->p->right;
			if(uncle->color == RED)						//case1
			{
				z->p->color = BLACK;					//case1
				uncle->color = BLACK;					//case1
				z->p->p->color = RED;					//case1
				z = z->p->p;							//case1
			}else
			{
				if( z == z->p->right )					//case2
				{										
					z = z->p;							//case2
					RB_left_rotate(T, *z);				//case2
				}						
				z->p->color = BLACK;					//case3
				z->p->p->color = RED;					//case3
				RB_right_rotate(T, *(z->p->p));         //case3

			}
		}else		 //父节点处在右分支,跟父亲处在左分支的代码基本相同，除了“左”和“右”互换
		{
			uncle = z->p->p->left;
			if(uncle->color == RED)						
			{
				z->p->color = BLACK;					
				uncle->color = BLACK;					
				z->p->p->color = RED;					
				z = z->p->p;							
			}else
			{
				if( z == z->p->left )					
				{										
					z = z->p;							
					RB_right_rotate(T, *z);				
				}						
				z->p->color = BLACK;					
				z->p->p->color = RED;					
				RB_left_rotate(T, *(z->p->p));         

			}
		}
	}
	T.Root->color = BLACK;
	return true;
}
/**/
bool RBTree::RB_delete_fixup(RBTree & T, Node * x)
{
	Node *w;// w is brother of x node
	//to be continued
	while(x != T.Root && x->color == BLACK)
	{
		if(x == x->p->left)//x 是左分支  
		{
			w = x->p->right;
			if(w->color == RED)                         //case1
			{
				w->color = BLACK;						//case1
				x->p->color = RED;						//case1
				RB_left_rotate(T,*(x->p));				//case1
				w = x->p->right;						//case1
			}else //w->color == BLACK
			{
				if(w->left->color == BLACK && w->right->color == BLACK)	//case2
				{
					w->color = RED;										//case2
					x = x->p;											//case2
				}else if(w->right->color == BLACK)						//case2
				{
					w->left->color = BLACK;								//case3
					w->color = RED;										//case3
					RB_right_rotate(T,*(w));							//case3
					w = x->p->right;									//case3
				}else													//case4
				{
					w->color = x->p->color;								//case4
					x->p->color = BLACK;								//case4
					w->right->color = BLACK;							//case4
					RB_left_rotate(T,*(x->p));							//case4
					x = T.Root;											//case4
				}
			}
		}else x 是右分支，情况跟以上一样，除了“左”与“右”互换
		{
			w = x->p->left;
			if(w->color == RED)                         //case1
			{
				w->color = BLACK;						//case1
				x->p->color = RED;						//case1
				RB_right_rotate(T,*(x->p));				//case1
				w = x->p->left;							//case1
			}else //w->color == BLACK
			{
				if(w->left->color == BLACK && w->right->color == BLACK)	//case2
				{
					w->color = RED;										//case2
					x = x->p;											//case2
				}else if(w->left->color == BLACK)						//case2
				{
					w->right->color = BLACK;							//case3
					w->color = RED;										//case3
					RB_left_rotate(T,*(w));								//case3
					w = x->p->left;										//case3
				}else													//case4
				{
					w->color = x->p->color;								//case4
					x->p->color = BLACK;								//case4
					w->left->color = BLACK;								//case4
					RB_right_rotate(T,*(x->p));							//case4
					x = T.Root;											//case4
				}
			}
		}
	}
	x->color = BLACK;
	return true;
}
bool RBTree::RB_insert(RBTree & T, Node & z)
{
	Node * parent = T.nil;
	Node * son = T.Root;
	while(son != T.nil)//在二叉树中，找到插入位置
	{
		parent = son;
		if(z.key > son->key)
			son = son->right;
		else
			son = son->left;
	}
	z.p = parent; // parent 指向被插入点的父节点
	if(parent == T.nil) //如果z是目前tree中的唯一节点，则修改T.Root
		T.Root = & z;
	else if (parent->key > z.key)//插入到左分支
		parent->left = & z;
	else
		parent->right = & z;//插入到右分支

	z.left = T.nil;
	z.right = T.nil;
	z.color = RED;		//被插入点，默认都是红色

	RB_insert_fixup(T, &z);//由于可能存在两个连续的红色节点，从而破外红黑树的性质，故需要修正
	return true;
}
RBTree::Node * RBTree::RB_delete(RBTree & T, Node & z)
{
	//z 是要删除的节点
	//y 是真正被删除的节点
	//x 是真正被删除节点的右孩子
	Node * y = &z;
	Node * x;
	bool y_orig_color = y->color;
	if(z.left == T.nil)//被删除节点左为空
	{
		x = z.right;
		RB_transplant(T, z, *(z.right));
	}else if(z.right == T.nil)//被删除节点右为空
	{
		x = z.left;
		RB_transplant(T, z, *(z.left));
	}else//被删除节点左右不为空: y迁移到z的位置，并保留z的颜色，x填充y的位置
	{
		y = tree_minimum(T,*(z.right));//y节点的左侧最小的节点即是真正被删除的节点
		y_orig_color = y->color;
		x = y->right;//
		/* case 1
			z
			 \
			  y
			   \
			    x
		*/
		if(y->p == &z)       //case1
		{
			x->p = y;
		}else
		{					//case2
			/* case 2
				z
				 \
				 ...
					 \
					  y
					   \
						x
			*/
			RB_transplant(T, *y, *(y->right));//将x填充到y的位置
			y->right = z.right;	//复制z的右分支到y
			y->right->p = y;
		}
		RB_transplant(T, z, *y);//将y迁移到z的位置，保留z的颜色和左右分支信息
		//复制z的左分支到y
		y->left = z.left;
		y->left->p = y;
		//将y染成z的颜色
		y->color = z.color;
	}
	if(y_orig_color == BLACK)//当y为黑色时，删除y会导致y附近的黑高速减少1，所以需要重新重新旋转和着色
		RB_delete_fixup(T, x);
	return  &z;
}

RBTree::Node * RBTree::RB_search(RBTree & T, int key)
{
	return NULL;
}
RBTree::Node *  RBTree::RB_next(RBTree & T)
{
	return NULL;
}
RBTree::Node *  RBTree::RB_next(const Node * z)
{
	return NULL;
}
#include <stdlib.h>
#include <time.h>
int main()
{
	bool exit = true;
	string temp;
	RBTree Tree;
	cout<<"Tree.nil "<<Tree.nil<<endl;
	cout <<"please input key of node to be inserted !!!"<<endl;
	srand(time(NULL));
	//while(exit)
	for(int i=0;i<6;i++)
	{
		RBTree::Node * new_node = new RBTree::Node(); 
		cin>> new_node->key;
		cout<<"key:"<<new_node->key<<endl;
		//new_node->key = rand()%191 +10; // 10 <= key <= 200
		Tree.RB_insert(Tree, *new_node);
	}
	cout << "red black tree contructed!!!\n";
	cout <<"begin to delete the root the first time\n";
	RBTree::Node * tmp;
	tmp = Tree.RB_delete(Tree, *(Tree.Root));
	cout <<"begin to delete the root the first time finihed: "<<tmp->key<<endl;
	delete tmp;

	
	tmp = Tree.RB_delete(Tree, *(Tree.Root));
	cout <<"begin to delete the root the second time finihed: "<<tmp->key<<endl;
	delete tmp;

	
	tmp = Tree.RB_delete(Tree, *(Tree.Root));
	cout <<"begin to delete the root the third time finihed: "<<tmp->key<<endl;
	delete tmp;

	
	tmp = Tree.RB_delete(Tree, *(Tree.Root));
	cout <<"begin to delete the root the fourth time finihed: "<<tmp->key<<endl;
	delete tmp;

	cout <<"test end!"<<endl;
	cout<<"godby"<<endl;
	system("pause");
	return 0;
}

5 参考资料

1  <<算法导论>>
2  <<c++ primer>>

xiaojsj111
关注
专栏目录
《算法导论》实验六：红黑树插入算法（C++）——控制台树型显示
allin_allin的恋爱小屋
12-15 3502
我们知道一颗高度为h的二叉搜索树，可以支持任何一种基本动态集合操作，且其时间复杂度均为O(h)。因此，二叉搜索树的性能与树的高度密切相关，如果树的高度较高时，这些集合操作可能并不比在链表上执行得快。所以让树中的元素尽量地平衡在树的两侧，使得树的高度尽量地低，便可提高二叉搜索树的性能。而红黑树（red-black- tree）是许多“平衡的”查找树中的一种，可以保证在最坏情况下基本动态集合。
linux kernel中的红黑树及红黑树测试代码移植
最新发布
08-11
可以用来研究红黑树代码，已经在项目中使用。附上运行结果 xw@xw-virtual-machine:~/share/test/rbtree$ ./rbtest KERN_ALERT rbtree testing key=1 key=2 key=3 key=4 key=5 key=6 key=7 key=8 key=9 key=10 erase ...
算法练习五 红黑树上 实现了左旋转、右旋转、以及插入
xiaoqiangXX的专栏
05-01 1509
为了检验红黑树的正确性，这里的输入数组为 41 67 34 0 69 24 78 58 62 64  最后的输出结果为： 62 黑 L[62] = 41 红 R[62] = 69 红 L[41] = 24 黑 R[41] = 58 黑 L[69] = 67 黑 R[69] = 79 黑 L[24] = 0   红 R[24] = 34 红   红黑树的节点 #pragma
算法导论习题练习——红黑树的插入和删除
热门推荐
Lavi的专栏
12-17 1万+
题目13.3-2 将关键字 41、38、31、12、19、8 连续地插入一棵初始化为空的红黑树之后，试画出该结果树。 Solution： 13.4-3 在练习13.3-2中，我们将关键字41，38，31，12，19，8连续插入一棵初始为空的树中，从而得到一棵红黑树。请给出从该树中连续删除关键字8，12，19，31，38，41后的结果。 Solution： 首先，节点关键字为8的节点为红色
第13章 红黑树
江湖乱飘
01-26 2066
13.1 红黑树的性质 13.1-1 按照图13-1(a)的方式，画出在关键字集合{1，2，...，15}上高度为3的完全二叉搜索树。以三种不同方式向图中加入NIL叶结点并对各结点着色，使所得的红黑树的黑高分别为2、3和4。 13.1-2 如果插入的结点被标记为红色，所得的树不是一颗红黑树，因为违反了红黑性质4。如果该结点被标记为黑色，所得的树也不是一颗红黑树，因为违反了红黑性质5。 ...
《算法导论3rd第十三章》红黑树
懒猫的脚印
11-30 1553
算法导论 第十三章 红黑树 AVL树 平衡二叉树
算法（销售员问题）.rar_研究生_红黑树
09-23
在描述中提到的“研究生课程中的程序实现”，暗示这是一个针对研究生级别的计算机科学教学项目，要求学生使用C++语言解决TSP问题，并且可能会涉及红黑树的数据结构来优化算法的效率。可能的实现方式是使用红黑树存储...
win32 红黑树模拟器
12-19
红黑树是一种自平衡二叉查找树，由Rudolf Bayer在1972年提出。它是计算机科学中用于高效存储和检索数据的数据结构。在Win32环境下，开发一个红黑树模拟器是为了帮助程序员更好地理解和调试红黑树算法。这个模拟器...
算法导论13.4删除 练习总结
chan15的博客
10-18 3358
13.4-1 在执行 RB-DELETE-FIXUP 之后，证明：树根一定是黑色的。 ANSWER： case 1：要进入循环，则 x.color = BLACK，且 x ≠ T.nil，所以不可能从case 1退出循环，所以必定会进入case 2,3,4。 case 2：w = x.p.right，则 w 不可能是T.root；如果从case 2退出循环，则 x = T.root，则23行
红黑树的删除真的很难吗？其实是你没找到好的解题思路，不信你点击进来看看，建议收藏哦!!!
波波烤鸭的博客
06-15 1864
  上一篇介绍了红黑树的插入操作，这篇来给大家介绍下红黑树的删除操作。 红黑树删除节点   红黑树的节点的删除其实也分为两步： 先删除节点(这步和普通的二叉树删除是一样的) 然后再调整 1.删除节点   要删除这个节点先需要找到这个节点，找到节点就是普通的二分查找，具体代码如下 private RBNode getNode(K key){ RBNode node = this.root; while (node != null ){ int
算法练习——最大连续子数组
weixin_30384217的博客
07-27 212
前言：一周一算法，任道而重远！ 问题描述：给定一个数组A[0,…,n-1],求A的连续子数组，使得该子数组的和最大。 比如：数组：A =[1, -2, 3, 10, -4, 7, 2, -5]　　　最大子数组：3, 10, -4, 7, 2 1：直接求取 思想：先从第一个元素开始向后累加， 每次累加后与之前的和比较，保留最大值，再从第二个元素开始向后累加，保留...
算法导论 练习题 13.4-7
苦海无涯闯进来
05-14 483
1
红黑树的插入过程
onlyou2030的博客
07-20 749
题目：将关键字41,38,31,12,19,8连续地插入一棵初始为空的红黑树后，试画出该结果树。
算法导论 练习题 13.3-6
苦海无涯闯进来
05-13 359
1
41.树
qq_41627390的博客
06-29 152
红黑树
sh310059703的专栏
09-17 505
http://baike.baidu.com/view/133754.htm?fr=aladdin
C语言实现红黑树详解及代码示例
"C语言实现红黑树的实例代码，包含插入、查找、删除操作以及旋转函数" 在计算机科学中，红黑树是一种自平衡二叉查找树（AVL树的一种变种），它在保持数据有序的...如果你正在学习或研究红黑树，这是一个很好的起点。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值