算法导论第十三章--红黑树C++代码实现

最新推荐文章于 2021-11-12 16:17:09 发布
最新推荐文章于 2021-11-12 16:17:09 发布
阅读量5.4k 收藏 3
点赞数
分类专栏： 算法导论 文章标签： c++ 算法 null delete search insert
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuzhanchen1987/article/details/7816230
版权
红黑树的性质，各个操作的具体步骤在 透彻了解红黑树之一   透彻了解红黑树之二

        透彻了解红黑树之三

 透彻理解红黑树之四 透彻理解红黑树之五，中已经讲的很详细了，在这里只将代码实现贴出来：

BRTreeNode.h

#include<iostream>
using namespace std;
class BRTree;
class BRTreeNode
{
private:
	friend BRTree;
	int key;
	bool color;
	BRTreeNode* left;
	BRTreeNode* right;
	BRTreeNode* parent;
public:
	BRTreeNode():key(-1),color(0),left(NULL),right(NULL),parent(NULL){}
	BRTreeNode(BRTreeNode* node):key(node->key),color(node->color),left(node->left),right(node->right),parent(node->parent)
	{}
	BRTreeNode(int num,bool flag):key(num),color(flag),left(NULL),right(NULL),parent(NULL){}
	~BRTreeNode()
	{
		
	}
	int Getkey()
	{
		return key;
	}
	bool Getcolor()
	{
		return this->color;
	}
	BRTreeNode* GetLeft()
	{
		return this->left;
	}
	BRTreeNode* Getright()
	{
		return this->right;
	}
	BRTreeNode* Getparent()
	{
		return this->parent;
	}
	void Inorder()
	{
		if(this!=NULL)
		{
			this->left->Inorder();
			cout<<this->key<<" ";
			this->right->Inorder();
		}
	}
	void Preorder()
	{
		if(this!=NULL)
		{
			cout<<this->key<<" ";
			this->left->Preorder();
			this->right->Preorder();
		}
	}
	void Postorder()
	{
		if(this!=NULL)
		{
			this->left->Postorder();
			this->right->Postorder();
			cout<<this->key<<" ";
		}
	}
	void MakeEmpty()
	{
		if(this!=NULL)
		{
			this->left->MakeEmpty();
			this->right->MakeEmpty();
			delete this;
		}
	}
	int GetHeight()
	{
		int L,R;
		if(this==NULL)
		{
			return 0;
		}
		L=this->left->GetHeight();
		R=this->right->GetHeight();
		return 1+(L>R? L:R);
	}
};


 

BRTree.h

#include"BRTreeNode.h"
class BRTree
{
private:
	BRTreeNode* root;
	BRTreeNode* nil;
public:
	BRTree():nil(new BRTreeNode())
	{
		nil->color=0;
		nil->key=-1;
		nil->left=nil->right=nil->parent=NULL;
		root=nil;
	}
	~BRTree()
	{
		MakeEmpty(root);
		delete nil;
	}
	//清空以node为根节点的树
	void MakeEmpty(BRTreeNode*node)
	{
		if(node!=nil)
		{
			MakeEmpty(node->left);
			MakeEmpty(node->right);
			delete node;
		}
	}
	int Getkey(BRTreeNode* node)
	{
		return node->Getkey();
	}
	bool Getcolor(BRTreeNode* node)
	{
		return node->Getcolor();
	}
	BRTreeNode* Getroot()
	{
		return root;
	}
	BRTreeNode* GetParent(BRTreeNode*node)
	{
		return node->parent;
	}
	int GetHeight(BRTreeNode* node)
	{
		int L,R;
		if(node==nil)
			return 0;
		L=GetHeight(node->left);
		R=GetHeight(node->right);
		return 1+(L>R? L:R);
	}
	void Inorder(BRTreeNode*node)
	{
		if(node!=nil)
		{
			Inorder(node->left);
			cout<<node->key<<" ";
			Inorder(node->right);
		}
	}
	void Preorder(BRTreeNode*node)
	{
		if(node!=nil)
		{
			cout<<node->key<<" ";
			Preorder(node->left);
			Preorder(node->right);
		}
	}
	void Posetorder(BRTreeNode*node)
	{
		if(node!=nil)
		{
			Posetorder(node->left);
			Posetorder(node->right);
			cout<<node->key<<" ";
		}
	}
	//左旋节点node
	bool LeftRotate(BRTreeNode* node)
	{
		BRTreeNode*y;
		if(node->right==nil)
		{
			cout<<"can't left rotate!"<<endl;
			return 0;
		}
		y=node->right;
		node->right=y->left;
		if(y->left!=nil)
		{
			y->left->parent=node;
		}
		y->parent=node->parent;
		if(node->parent==nil)
		{
			root=y;
		}
		else if(node->parent->left==node)
		{
			node->parent->left=y;
		}
		else
		{
			node->parent->right=y;
		}
		y->left=node;
		node->parent=y;
		return 1;
	}
	//右旋节点
	bool RightRotate(BRTreeNode* node)
	{
		if(node->left==nil)
		{
			cout<<"can't rightrotate!"<<endl;
			return 0;
		}
		BRTreeNode* x;
		x=node->left;
		node->left=x->right;
		if(x->right!=nil)
		{
			x->right->parent=node;
		}
		x->parent=node->parent;
		if(node->parent==nil)
		{
			root=x;
		}
		else if(node->parent->left==node)
		{
			node->parent->left=x;
		}
		else
		{
			node->parent->right=x;
		}
		node->parent=x;
		x->right=node;
		return 1;
	}
	void Insert(int num)
	{
		BRTreeNode* node=new BRTreeNode(num,1);
		node->left=nil;
		node->right=nil;
		node->parent=nil;
		BRTreeNode* p=root,*q=nil;
		if(root==nil)
		{
			node->color=0;
			root=node;
			root->left=root->right=root->parent=nil;
			return ;
		}
		while(p!=nil)
		{
			if(p->key==num)
			{
				cout<<num<<"  has exist!"<<endl;
				return ;
			}
			else if(p->key>num)
			{
				q=p;
				p=p->left;
			}
			else
			{
				q=p;
				p=p->right;
			}
		}
		if(q->key>num)
		{
			q->left=node;
			node->parent=q;
		}
		else
		{
			q->right=node;
			node->parent=q;
		}
		RBInsertAdjust(node);
	}
	void RBInsertAdjust(BRTreeNode* node)
	{
		BRTreeNode* y;
		while(node->parent->color==1)
		{
			if(node->parent==node->parent->parent->left)
			{
				y=node->parent->parent->right;
				if(y->color==1)
				{
					node->parent->color=0;
					y->color=0;
					y->parent->color=1;
					node=node->parent->parent;
				}
				//此时y的颜色是黑色
				else 
				{
					//第二种情况
					if(node==node->parent->right)
					{
						node=node->parent;
						LeftRotate(node);
					}
					//第三种情况
					node->parent->color=0;
					node->parent->parent->color=1;
					RightRotate(node->parent->parent);
				}	
			}
			else
			{
				y=node->parent->parent->left;
				if(y->color==1)
				{
					node->parent->color=0;
					y->color=0;
					y->parent->color=1;
					node=node->parent->parent;
				}
				else 
				{
					if(node==node->parent->left)
					{
						node=node->parent;
						RightRotate(node);
					}
					node->parent->color=0;
					node->parent->parent->color=1;
					LeftRotate(node->parent->parent);
				}
			}
		}
		root->color=0;
	}
	BRTreeNode* Search(int num)
	{
		BRTreeNode* p=root;
		while(p!=nil)
		{
			if(p->key==num)
			{
				return p;
			}
			else if(p->key>num)
			{
				p=p->left;
			}
			else 
			{
				p=p->right;
			}
		}
		cout<<"there is no "<<num<<" in this tree!"<<endl;
		return nil;
	}
	//获取以node节点为根节点的树的最小元素，并返回该最小值
	int Minnum(BRTreeNode*node)
	{
		BRTreeNode*p=node;
		while(p->left!=nil)
		{
			p=p->left;
		}
		return p->key;
	}
	//获取以node节点为根节点的树的最da元素，并返回该最da值
	int Maxnum(BRTreeNode*node)
	{
		BRTreeNode*p=node;
		while(p->right!=nil)
		{
			p=p->right;
		}
		return p->key;
	}
	//获取以node节点为根节点的树的最小元素，并返回该节点
	BRTreeNode* MinNum(BRTreeNode*node)
	{
		BRTreeNode*p=node;
		while(p->left!=nil)
		{
			p=p->left;
		}
		return p;
	}
	//获取以node节点为根节点的树的最大元素
	BRTreeNode* MaxNum(BRTreeNode*node)
	{
		BRTreeNode*p=node;
		while(p->right!=nil)
		{
			p=p->right;
		}
		return p;
	}
	BRTreeNode*InorderSuccessor(BRTreeNode*node)
	{
		if(node->right!=nil)
		{
			return MinNum(node->right);
		}
		else
		{
			BRTreeNode*p=GetParent(node);
			while(p&&node==p->right)
			{
				node=p;
				p=GetParent(node);
			}
			return p;
		}
	}
	//中序遍历的前趋
	BRTreeNode*InordePredecessor(BRTreeNode*node)
	{
		if(node->left!=nil)
		{
			return MaxNum(node->left);
		}
		else
		{
			BRTreeNode*p=GetParent(node);
			while(p&&node==p->left)
			{
				node=p;
				p=GetParent(node);
			}
			return p;
		}	
	}
	bool Delete(int num)
	{
		BRTreeNode*z,*y,*x;  
        //寻找key值为num的节点p  
        z=Search(num); 
		//如果没有该节点则返回0
        if(z==nil)  
        {  
            return 0;  
        }
		if(z->left==nil||z->right==nil)
		{
			y=z;
		}
		else
			y=InorderSuccessor(z);
		if(y->left!=nil)
			x=y->left;
		else
			x=y->right;
		x->parent=y->parent;
		if(x->parent==nil)
			root=x;
		else if(y=y->parent->left)
			y->parent->left=x;
		else
			y->parent->right=x;
		if(y!=z)
		{
			z->key=y->key;
		}
		if(y->color==0)
		{
			RBTreeFixup(x);
		}
		return 1;
	}
	void RBTreeFixup(BRTreeNode* x)
	{
		BRTreeNode*w;
		while(x!=root&&x->color==0)
		{
			if(x==x->parent->left)
			{
				w=x->parent->right;
				if(w->color==1)
				{
					w->color=0;
					x->parent->color=1;
					LeftRotate(x->parent);
					w=x->parent->right;
				}
				if(w->left->color==0&&w->right->color==0)
				{
					w->color=1;
					x=x->parent;
				}
				else 
				{
					if(w->right->color==0)
					{
						w->color=1;
						RightRotate(w);
						w=x->parent->right;
					}
					w->color=x->parent->color;
					x->parent->color=0;
					w->right->color=0;
					LeftRotate(x->parent);
					x=root;
				}
			}
			else
			{
				w=x->parent->left;
				if(w->color==1)
				{
					w->color=0;
					x->parent->color=1;
					RightRotate(x->parent);
					w=x->parent->left;
				}
				if(w->right->color==0&&w->left->color==0)
				{
					w->color=1;
					x=x->parent;
				}
				else 
				{
					if(w->left->color==0)
					{
						w->color=1;
						LeftRotate(w);
						w=x->parent->left;
					}
					w->color=x->parent->color;
					x->parent->color=0;
					w->left->color=0;
					RightRotate(x->parent);
					x=root;
				}
			}
		}
		x->color=0;
	}
};


 

main.cpp

#include"BRTree.h"
int main()
{
	BRTree tree;
	int a[8]={11,2,1,7,5,8,14,15};
	int i;
	for(i=0;i<8;i++)
	{
		tree.Insert(a[i]);
	}
	tree.Inorder(tree.Getroot());
	cout<<endl;
	tree.Insert(4);
	tree.Inorder(tree.Getroot());
	cout<<endl;
	tree.Insert(6);
	tree.Inorder(tree.Getroot());
	cout<<endl;
	tree.Insert(3);
	tree.Inorder(tree.Getroot());
	cout<<endl;
	cout<<tree.GetHeight(tree.Getroot());
	cout<<endl;
	tree.Delete(2);
	tree.Inorder(tree.Getroot());
	cout<<endl;
}


 

liuzhanchen1987
关注
专栏目录
算法导论 第13章 红黑树（图文详细解说）
程序缘
08-27 2801
二叉查找树的基本操作包括搜索、插入、删除、取最大和最小值等都能够在O(h)时间复杂度内实现，因此能在期望时间O(lgn)下实现，但是二叉查找树的平衡性在这些操作中并没有得到维护，因此其高度可能会变得很高，当其高度较高时，而二叉查找树的性能就未必比链表好了，所以二叉查找树的集合操作是期望时间O(lgn)，最坏情况下为O(n)。 红黑树也是一种二叉查找树，它拥有二叉查找树的性质，同时红黑树还
算法导论第十三章习题13-3——AVL树（高度平衡树）C++代码详细实现
小博客
08-03 5409
AVL树是一种高度平衡树，对于每一个节点，其左子树的高度与右子树的高度相差之多为1。 AVL树是比红黑树更加平衡的树（红黑树中左右子树高度之比小于2）。 AVL树除了平衡性较好外，与普通的二叉查找树没什么大的区别。所以AVL树的代码实现可以基于前面的二叉树实现代码算法导论第十二章——二叉查找树的C++代码实现来实现。实现AVL树的关键在于维持树的平衡性。所以每插入一个节点或删除都有可能要对树进
算法导论的红黑树的C++实现源码
03-29
算法导论的红黑树的C++实现源码,并附加测试验证代码
算法导论 红黑树的C++代码实现
sinat_24520925的专栏
12-16 626
红黑树为满足下列五个条件的特殊二叉树 每个结点要么是红的要么是黑的。  根结点是黑的。  每个叶结点（叶结点即指树尾端NIL指针或NULL结点）都是黑的。  如果一个结点是红的，那么它的两个儿子都是黑的。   对于任意结点而言，其到叶结点树尾端NIL指针的每条路径都包含相同数目的黑结点。 本文代码根据算法导论上的伪代码编写，按照先序、中序、后序输出。可直接运行，如有错误，欢迎大家指正~~~
算法导论-红黑树C++实现
爱冒险的技术宅
11-10 3776
红黑树的定义： 一棵二叉查找树如果满足下面的红黑性质，则为一棵红黑树： 1）每个节点或是红的，或是黑的。 2）根节点是黑的。 3）每个叶节点（NIL）是黑节点。 4）如果一个节点是红的，则它的两个儿子都是黑的。 5）对每个节点，从该节点到其子孙节点的所有路径上包含相同节点数目的黑节点。 C++代码实现： BRTreeNode.h #ifndef BRTREENODE_
算法导论：c++实现红黑树
imcy的博客
12-21 370
数据结构性质 这里定义一个结构体保存颜色enum colorRB { black = 0, red, }; struct TreeNode_RB { int val; colorRB color; TreeNode_RB *left; TreeNode_RB *right; TreeNode_RB *parent; TreeNod
算法导论 第三版 中文版
10-12
通过阅读《算法导论》第三版中文版，读者不仅可以学习到各种算法的具体实现，还能理解它们背后的数学原理和设计思想。对于想要深入学习计算机科学，或者准备面试和研究工作的程序员来说，这本书无疑是必备的参考书目...
算法导论---------------散列表（hash table）
chen
11-30 1457
摘要： 　　本章介绍了散列表（hash table）的概念、散列函数的设计及散列冲突的处理。散列表类似与字典的目录，查找的元素都有一个key与之对应，在实践当中，散列技术的效率是很高的，合理的设计散函数和冲突处理方法，可以使得在散列表中查找一个元素的期望时间为O(1)。散列表是普通数组概念的推广，在散列表中，不是直接把关键字用作数组下标，而是根据关键字通过散列函数计算出来的。书中介绍散列表非
算法导论(part2)
09-09
一、本书的内容 目前，市面上有关计算机算法的书很多，有些叙述严谨但不全面，...第13章 红黑树 13．1 红黑树的性质 13．2 旋转 13．3 插入 13．4 删除 第14章 数据结构的扩张 14．1 动态顺序统计 14．2 如何...
算法导论中红黑树的实现
07-18
根据算法导论中红黑树的讲解，用C写了一个关于红黑树的建立，查询节点，插入，删除操作
算法导论红黑树C++实现
sinat_15652045的博客
07-28 348
用一个类封装了红黑树的一些属性，水平有限，敬请批评指正，谢谢！#include "Header.h"enum NodeColor { Red, Black };struct RBTreeNode{RBTreeNode* leftchild;RBTreeNode* rightchild;RBTreeNode* parents;//char color;NodeColor color;int key;
算法导论红黑树的C++实现
hyjjkk的专栏
04-09 2012
按照算法导论里的红黑树伪代码用C++实现了一下， 并附带一些测试代码。 #include #include using namespace std; enum Color{RED,BLACK};//颜色标记 template class Binary_Tree_Node//红黑树节点 { public: Binary_Tree_Node() { parent=NULL; l
红黑树 C++源代码实现
老衣的专栏
04-15 1517
<br /> 今天看了csdn博主july写的红黑树系列，觉得他写的非常好，研究了很长时间的红黑树 ，终于觉得明白些了。july写的C++源代码实现，已经非常好了，我只是在他的基础上  稍微做了一下修改，能够知道每个节点是个红  还是黑色的。<br />july的博客地址：http://blog.csdn.net/v_JULY_v/archive/2011/03/29/6285620.aspx，可以去他那看看他的系列！<br />直接上代码：<br />RB_tree.h<br />//file RBTre
算法导论 第13章 红黑树 C++源代码
Full_Speed_Turbo
12-10 1204
参考了[1]CLRS的《算法导论》3rd.和[2]July、saturnman的  红黑树的C++完整实现源码 //FILE:RBTREE.H //BY FULL_SPEED_TURBO //2013-12-10 #include #include enum RB_color{RED,BLACK}; //using namespace std; struct node { int
红黑树的c++ 实现
sysucph的专栏
04-05 143
红黑树，这个算法导论上有算法流程的介绍，这里简单实现了一下。不同于avl树，红黑树黑色叶子节点还是很有用，在处理删除操作时，多了null的叶子节点，算法写起来顺很多，因为有可能删除了节点之后，调整是从黑色的叶子节点开始的。 #ifndef __RBTREE_H__ #define __RBTREE_H__ #include <vector> #define RBTREE_NOD...
算法导论--红黑树
勿在浮砂筑高台
05-17 5379
红黑树是平衡搜索树的一种，可以保证在最坏情况下基本动态集合操作的时间复杂度为Lgn。红黑树在二叉搜索树的基础上结点增加了一个属性color，值为black或者red,即一个节点的属性有：left,right,p,color,key。同时，红黑树使用一个哨兵T_NIL代替以一般搜索树中的NULL,T_NIL也是一个普通的结点，也具有以上5个属性，它的color属性为black,其他属性为任意值。即叶子结点的左右孩子全部指向哨兵，以及根节点的父指针也指向哨兵。
算法导论06--红黑树构建算法
张嘉睿的博客
11-12 1084
一、目的 1．熟悉算法设计的基本思想 2．掌握构建红黑树的方法 二、内容与设计思想 编写随机整数生成算法，生成S到T范围内的N个随机整数并输出； 编写红黑树构建算法，中序遍历各节点，输出颜色和值； 随机生成1e2、1e3、1e4、1e5、1e6个不同的数，使用红黑树构建算法，并画图描述不同情况下的运行时间差异； 三、使用环境 推荐使用C/C++集成编译环境。 四、实验过程 1、写出红黑树构建算法的源代码 #include<bits/stdc++.h> using namespace std;
建立红黑树的完整可行代码（算法导论）
头号玩家的博客
02-07 663
推荐一篇介绍红黑树的良心博客 首先要说明我学习红黑树插入时的经验：初次看时很懵逼，不要紧，放到第二天再看一遍就清楚多了，这时候开始自己把算法整理一遍。第三天再看了然于心，可以再把各种情况考虑一遍，然后就可以写代码了。必须说明的是，《算法导论》上的伪代码真的丑，显得没有什么条理，而且漏掉了几个细节，所有直接按书写的代码不经过细心调试是不能成功的。所有我推荐不看书自己写出来，肯定比看书快而且准确。
算法导论：数据结构篇--红黑树详解
总结来说，《算法导论》中的红黑树章节是理解数据结构中的高级主题，特别是动态数据结构实现的重要部分，它为高效的搜索和排序算法提供了基础，是所有希望深入学习计算机科学和算法设计的学生和专业人士的必备参考...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值