今天完成了红黑树的删除操作。插入、删除完成。

最新推荐文章于 2021-03-25 11:18:26 发布
最新推荐文章于 2021-03-25 11:18:26 发布
阅读量477 收藏 1
点赞数
文章标签： 红黑树 插入 删除 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tjweilong/article/details/8798674
版权 
#ifndef __BLACK_RED_TREE
#define __BLACK_RED_TREE

#include <iostream>

using namespace std;

#define RED 1
#define BLACK 0

#define OutMsg(FunName) (cout<<FunName<<endl)

#define PRINTFUN() cout<<__FUNCTION__<<endl

template<class T> class BlackTree;

template<class T> class BlackRedNode
{
public:
	template<class T> friend class BlackRedTree;
	BlackRedNode():Color(BLACK),Left(NULL),Right(NULL),Parent(NULL){;}
	BlackRedNode(const T& e,int NodeColor=BLACK,BlackRedNode<T>* LeftNode=NULL,BlackRedNode<T>* RightNode=NULL,BlackRedNode<T>* ParentNode=NULL):Data(e),Color(NodeColor),Left(LeftNode),Right(RightNode),Parent(ParentNode){;}
	

private:
	T Data;
	int Color;//0:black,1:red
	BlackRedNode<T>* Left,*Right;
	BlackRedNode<T>* Parent;

	
};

template<class T> class BlackRedTree
{
public:
	BlackRedTree():Root(NULL){;}
	BlackRedTree(const T& x);
	BlackRedTree<T>& Insert(const T& e);
	BlackRedTree<T>& Delete(const T& e);

	void PrintTree() const{PrintTree(Root,0);}//打印红黑树
	

private:

	void PrintTree(BlackRedNode<T>* Node,int Layer)const;

	BlackRedNode<T>* Root;

private:
	
	bool AdjustColorAfterInsert(BlackRedNode<T>* Node); //Node为新插入节点的指针。插入节点之后，判断是否违反RB2，如果违反则进行调整
	
	//XYr类型，调整之后，可能还需要继续调整
	bool LXr_AfterInsert(BlackRedNode<T>* Node);//插入之后，如果为LXr形式，则进行相应调整，其他与此类似，Node为插入的元素指针。X为L或者R
	bool RXr_AfterInsert(BlackRedNode<T>* Node);//插入之后为RXr类型：X为R或者L;
	//XYb类型，调整之后不再需要继续调整
	bool LLb_AfterInsert(BlackRedNode<T>* Node);
	bool LRb_AfterInsert(BlackRedNode<T>* Node);
	bool RRb_AfterInsert(BlackRedNode<T>* Node);
	bool RLb_AfterInsert(BlackRedNode<T>* Node);

	bool IfNeedAdjustAfterDelete(BlackRedNode<T>* Node,bool& NeedFlag);//该函数用来根据Node是否为黑色节点来设置NeedFlag为true或者false
	int GetRedChildNumOfNode(BlackRedNode<T>* Node);//获取Node的红色孩子的数量
	
	bool AdjustColorAfterDelete(BlackRedNode<T>* Y,BlackRedNode<T>* Py,int DirectionOfY);//Y为删除节点位置上的新节点，Y可能为NULL;Py表示Y的父节点;DirectionOfY表示Node是Node的父节点的左孩子（0）还是右孩子（1）
	//删除节点之后，颜色调整具体函数
	bool RbZero_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY);//参数含义与AdjustColorAfterDelete相同
	bool RbOne_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY);//Rb1型调整函数
	bool RbOne_VLeftRed_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY);//Rb1型调整函数：v的left是red
	bool RbOne_VRightRed_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY);//Rb1型调整函数:v的right是red
	bool RbTwo_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY);//
	
	bool RrZero_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY);
	bool RrOne_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY);
	bool RrOne_VRLr_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY);
	bool RrOne_VRRr_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY);
	bool RrTwo_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY);

	bool LbZero_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY);
	bool LbOne_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY);//Lb1型调整函数
	bool LbOne_VLeftRed_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY);//Lb1型调整函数：v的left是red
	bool LbOne_VRightRed_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY);//Lb1型调整函数:v的right是red
	bool LbTwo_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY);

	bool LrZero_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY);
	bool LrOne_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY);
	bool LrOne_VLRr_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY);
	bool LrOne_VLLr_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY);
	bool LrTwo_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY);

	int GetDirctionOfYInPy(BlackRedNode<T>* Y,BlackRedNode<T>* Py);//获取Y在Py子树上的位置：0，左子树，1：右子树

};

template<class T> BlackRedTree<T>::BlackRedTree(const T& x)
{
	Root = new BlackRedNode<T>(x);
}

template<class T> BlackRedTree<T>& BlackRedTree<T>::Insert(const T& e)
{
	if(!Root)
	{
		Root = new BlackRedNode<T>(e);
		return *this;
	}
	BlackRedNode<T>* Temp,*pTemp;
	int InsertDirection = 0;//0:左，1：右

	Temp = Root;
	while(Temp)
	{
		pTemp = Temp;
		if(e > Temp->Data)
		{
			Temp = Temp->Right;
			InsertDirection = 1;
		}
		else
		{
			Temp = Temp->Left;
			InsertDirection = 0;
		}
		if(Temp)
		{
			Temp->Parent = pTemp;
		}
	}
	//这里的temp即为要插入的位置
	Temp = new BlackRedNode<T>(e,RED);
	Temp->Parent = pTemp;
	if(InsertDirection)
	{
		pTemp->Right = Temp;
	}
	else
	{
		pTemp->Left = Temp;
	}
	//接下来调整颜色
	AdjustColorAfterInsert(Temp);
	return *this;

}

template<class T> bool BlackRedTree<T>::AdjustColorAfterInsert(BlackRedNode<T>* Node)
{

	BlackRedNode<T>* PNode,*GNode;
	if(Node == Root)
	{
		Root->Color = BLACK;
		return true;
	}
	PNode = Node->Parent;
	if(PNode->Color == BLACK)
	{
		cout<<"PNode->Color == BLACK,这时候不需要调整颜色"<<endl;
		return true;
	}
	//既然PNode是红色的，那么一定有GNode存在,而且GNode一定是黑色的
	GNode = PNode->Parent;
	
	//一共有8种情况：LLr,LRr,RRr,RLr,LLb,LRb,RRb,RLb.(这种情况包括gu的另一个孩子是外部节点的情况)
	if(PNode == GNode->Left && (GNode->Right!=NULL && GNode->Right->Color == RED))//LXr
	{
		LXr_AfterInsert(Node);
		return AdjustColorAfterInsert(GNode);
	}

	if(PNode == GNode->Right && (GNode->Left!=NULL && GNode->Left->Color == RED))//RXr
	{
		RXr_AfterInsert(Node);
		return AdjustColorAfterInsert(GNode);
	}

	if(PNode == GNode->Left && Node == PNode->Left && (GNode->Right ==NULL || (GNode->Right!=NULL && GNode->Right->Color == BLACK) ))//LLb
	{
		return LLb_AfterInsert(Node);
	}
	
	if(PNode == GNode->Left && Node == PNode->Right && (GNode->Right ==NULL || (GNode->Right!=NULL && GNode->Right->Color == BLACK) ))//LRb
	{
		return LRb_AfterInsert(Node);
	}
	if(PNode == GNode->Right && Node == PNode->Right && (GNode->Left == NULL || (GNode->Left!=NULL && GNode->Left->Color == BLACK)))//RRb
	{
		return RRb_AfterInsert(Node);
	}
	if(PNode == GNode->Right && Node == PNode->Left && (GNode->Left == NULL || (GNode->Left!=NULL && GNode->Left->Color == BLACK)))//RLb
	{
		return RLb_AfterInsert(Node);
	}

}

template<class T> bool BlackRedTree<T>::LXr_AfterInsert(BlackRedNode<T>* Node)
{
	OutMsg("LXr_AfterInsert");
	BlackRedNode<T>* PNode,*GNode;
	PNode = Node->Parent;
	GNode = PNode->Parent;
	if( PNode!= GNode->Left || GNode->Right == NULL || (GNode->Right!=NULL && GNode->Right->Color!=RED) )
	{
		cout<<"插入节点之后，不是LXr类型"<<endl;
		return true;
	}
	//根据数据结构上给出的算法进行颜色调整
	GNode->Color = RED;
	PNode->Color = BLACK;
	GNode->Right->Color = BLACK;
	//这样调整完之后，可能还存在违反RB2，这个交给AdjustColorAfterInsert函数来处理
	return true;
}

template<class T> bool BlackRedTree<T>::RXr_AfterInsert(BlackRedNode<T>* Node)
{
	OutMsg("RXr_AfterInsert");
	BlackRedNode<T>* PNode,*GNode;
	PNode = Node->Parent;
	GNode = PNode->Parent;
	if(PNode!= GNode->Right || (GNode->Left!=NULL && GNode->Left->Color!=RED))
	{
		cout<<"插入节点之后，不是RXr类型"<<endl;
		return true;
	}
	//根据数据结构上给出的算法进行颜色调整
	GNode->Color = RED;
	PNode->Color = BLACK;
	GNode->Left->Color = BLACK;
	//这样调整完之后，可能还存在违反RB2，这个交给AdjustColorAfterInsert函数来处理
	return true;
}


template<class T>  bool BlackRedTree<T>::LLb_AfterInsert(BlackRedNode<T>* Node)
{
	OutMsg("LLb_AfterInsert");
	BlackRedNode<T>* PNode,*GNode;
	PNode = Node->Parent;
	GNode = PNode->Parent;
	if(PNode!= GNode->Left || Node!= PNode->Left || (GNode->Right!=NULL && GNode->Right->Color!=BLACK))
	{
		cout<<"插入节点之后，不是LLb类型"<<endl;
		return true;
	}
	//根据数据结构上给出的算法进行旋转
	BlackRedNode<T>* NewNode,*NodeToDelete; 
	NewNode = new BlackRedNode<T>(GNode->Data,RED);
	NodeToDelete = GNode->Left;

	NewNode->Left = NodeToDelete->Right;
	NewNode->Right = GNode->Right;
	
	GNode->Left = NodeToDelete->Left;
	GNode->Right = NewNode;
	GNode->Data = NodeToDelete->Data;
	//调整父节点
	if(NewNode)
	{
		NewNode->Parent = GNode;
		if(NewNode->Left)
		{
			NewNode->Left->Parent = NewNode;
		}
		if(NewNode->Right)
		{
			NewNode->Right->Parent = NewNode;
		}
	}
	if(GNode->Left)
	{
		GNode->Left->Parent = GNode;
	}
	if(GNode->Right)
	{
		GNode->Right->Parent = GNode;
	}

	//删除节点

	if(!NodeToDelete)
	{
		delete NodeToDelete;
		NodeToDelete = NULL;
	}
	return true;

}

template<class T>  bool BlackRedTree<T>::LRb_AfterInsert(BlackRedNode<T>* Node)
{
	OutMsg("LRb_AfterInsert");
	BlackRedNode<T>* PNode,*GNode;
	PNode = Node->Parent;
	GNode = PNode->Parent;
	if(PNode!= GNode->Left || Node!= PNode->Right || (GNode->Right!=NULL && GNode->Right->Color!=BLACK))
	{
		cout<<"插入节点之后，不是LRb类型"<<endl;
		return true;
	}
	//根据数据结构上给出的算法进行旋转
	BlackRedNode<T>* NewNode,*NodeToDelete; 
	NewNode = new BlackRedNode<T>(GNode->Data,RED);
	NodeToDelete = PNode ->Right;

	NewNode->Left = NodeToDelete->Right;
	NewNode->Right = GNode->Right;
	
	GNode->Left->Right = NodeToDelete->Left;
	GNode->Right = NewNode;
	GNode->Data = NodeToDelete->Data;

	PNode->Right = NodeToDelete ->Left;

	//调整父节点
	if(NewNode)
	{
		if(NewNode->Left)
		{
			NewNode->Left->Parent = NewNode;
		}
		if(NewNode->Right)
		{
			NewNode->Right->Parent = NewNode;
		}
	}
	if(GNode->Left->Right)
	{
		GNode->Left->Right->Parent = GNode;
	}
	if(GNode->Right)
	{
		GNode->Right->Parent = GNode;
	}
	if(PNode->Right)
	{
		PNode->Right->Parent = PNode;
	}

	//删除节点
	if(!NodeToDelete)
	{
		delete NodeToDelete;
		NodeToDelete = 0;
	}
	return true;
}

template<class T> bool BlackRedTree<T>::RRb_AfterInsert(BlackRedNode<T>* Node)
{
	OutMsg("RRb_AfterInsert");
	BlackRedNode<T>* PNode,*GNode;
	PNode = Node->Parent;
	GNode = PNode->Parent;
	if(PNode!= GNode->Right || Node!= PNode->Right || (GNode->Left!=NULL && GNode->Left->Color!=BLACK))
	{
		cout<<"插入节点之后，不是RRb类型"<<endl;
		return true;
	}
	//进行旋转
	BlackRedNode<T>* NewNode,*NodeToDelete;
	NewNode = new BlackRedNode<T>(GNode->Data,RED);
	NodeToDelete = PNode;

	NewNode->Left = GNode->Left;
	NewNode->Right = NodeToDelete->Left;
	
	GNode->Data = NodeToDelete->Data;
	GNode->Left = NewNode;
	GNode->Right = NodeToDelete->Right;

	//调整父节点
	if(NewNode)
	{
		if(NewNode->Left)
		{
			NewNode->Left->Parent = NewNode;
		}
		if(NewNode->Right)
		{
			NewNode->Right->Parent = NewNode;
		}
	}
	if(GNode->Left)
	{
		GNode->Left->Parent = GNode;
	}
	if(GNode->Right)
	{
		GNode->Right->Parent = GNode;
	}
	//删除节点
	if(!NodeToDelete)
	{
		delete NodeToDelete;
		NodeToDelete = 0;
	}
	return true;

}

template<class T> bool BlackRedTree<T>::RLb_AfterInsert(BlackRedNode<T>* Node)
{
	OutMsg("RLb_AfterInsert");
	BlackRedNode<T>* PNode,*GNode;
	PNode = Node->Parent;
	GNode = PNode->Parent;
	if(PNode!= GNode->Right || Node!= PNode->Left || (GNode->Left!=NULL && GNode->Left->Color!=BLACK))
	{
		cout<<"插入节点之后，不是RLb类型"<<endl;
		return true;
	}
	//进行旋转
	BlackRedNode<T>* NewNode,*NodeToDelete;
	NewNode = new BlackRedNode<T>(GNode->Data,RED);
	NodeToDelete = PNode->Left;

	NewNode->Left = GNode->Left;
	NewNode->Right = NodeToDelete->Left;
	
	GNode->Data = NodeToDelete->Data;
	GNode->Left = NewNode;
	GNode->Right->Left = NodeToDelete->Right;

	//调整父节点
	if(NewNode)
	{
		if(NewNode->Left)
		{
			NewNode->Left->Parent = NewNode;
		}
		if(NewNode->Right)
		{
			NewNode->Right->Parent = NewNode;
		}
	}
	if(GNode->Left)
	{
		GNode->Left->Parent = GNode;
	}
	if(GNode->Right->Left)
	{
		GNode->Right->Left->Parent = GNode;
	}
	//删除节点
	if(!NodeToDelete)
	{
		delete NodeToDelete;
		NodeToDelete = 0;
	}
	return true;
}

template <class T> void BlackRedTree<T>::PrintTree(BlackRedNode<T> *t,int layer) const{
    if(t == NULL ) return;
	if(t->Right) PrintTree(t->Right,layer+1);
    for(int i =0;i<layer;i++) cout<<"  ";
	cout<<t->Data<<":"<<t->Color<<endl;
	if(t->Left) PrintTree(t->Left,layer+1);
}

template<class T> BlackRedTree<T>& BlackRedTree<T>::Delete(const T& e)
{
	BlackRedNode<T>* Temp;
	Temp=Root;
	//先找到e值的节点
	while(Temp)
	{
		if(e > Temp->Data)
		{
			Temp = Temp->Right;
		}
		if(e< Temp->Data)
		{
			Temp = Temp->Left;
		}
		if(e == Temp->Data)
		{
			break;
		}
	}
	if(!Temp)
	{
		cout<<"没有找到节点："<<e<<endl;
		return *this;
	}
	//到这里Temp即为找到的值为e的节点
	
	//如果没有孩子则可直接删除
	//如果在temp只有一个孩子则将Temp的父节点指向其唯一孩子即可
	//如果有两个孩子，只需将该元素替换为它的左子树中的最大元素
	BlackRedNode<T> *Y;//代替被删除节点位置的节点
	BlackRedNode<T>* Py;//y的父节点
	int DirectionOfYInPy=0;//y是py左孩子，则为0，否则为1
	bool NeedAdjustFlag=false;//是否需要调整颜色的标志，如果删除的是黑色节点，需要调整颜色
	if(Temp->Left==NULL && Temp->Right==NULL)
	{
		if(Temp == Root)
		{
			delete Temp;
			Temp=NULL;
			return *this;
		}
		Py = Temp->Parent;
		if(Temp==Py->Left)
		{
			DirectionOfYInPy=0;
			Py->Left =NULL;
		}
		else
		{
			DirectionOfYInPy=1;
			Py->Right =NULL;
		}
		IfNeedAdjustAfterDelete(Temp,NeedAdjustFlag);

		delete Temp;
		Temp=NULL;
		Y=NULL;
	}
	else 
		if((Temp->Left==NULL && Temp->Right!=NULL) || (Temp->Left!=NULL && Temp->Right==NULL))
		{
			if(Temp==Root)
			{
				Py=Root;
			}
			else
			{
				Py = Temp->Parent;
			}
			
			if(Temp->Left)
			{
				Y=Temp->Left;
			}
			else
			{
				Y=Temp->Right;
			}
			Y->Parent = Py;
			if(Temp==Py->Left)
			{
				Py->Left = Y;
				DirectionOfYInPy =0;
			}
			else
			{
				Py->Right = Y;
				DirectionOfYInPy=1;
			}
			IfNeedAdjustAfterDelete(Temp,NeedAdjustFlag);
			if(Temp == Root)
			{
				Root = Py;
			}
			delete Temp;
			Temp=NULL;

		}
		else if(Temp->Left && Temp->Right)
		{
			Y=Temp->Left;
			Py=Temp;
			DirectionOfYInPy = 0;
			while(Y->Right)
			{
				Py=Y;
				Y=Y->Right;
				DirectionOfYInPy = 1;
			}
			Temp->Data = Y->Data;
			if(Y->Left)
			{
				if(DirectionOfYInPy == 1)
				{
					DirectionOfYInPy = 1;
				}
				else
				{
					DirectionOfYInPy = 0;
				}
				Temp=Y;
				Y->Left->Parent=Py;
				Py->Right = Y->Left;//根据Y是Temp左子树的最大孩子，知道Y一定是Py的右孩子
			}
			else
			{
				//Y已经是叶子节点
				if(DirectionOfYInPy == 1)
				{
					DirectionOfYInPy = 1;
				}
				else
				{
					DirectionOfYInPy = 0;
				}
				Temp = Y;
				Y = NULL;

				if(DirectionOfYInPy == 0)
				{
					Py->Left=NULL;
				}
				if(DirectionOfYInPy == 1)
				{
					Py->Right=NULL;
				}
				
			}
			IfNeedAdjustAfterDelete(Temp,NeedAdjustFlag);
			delete Temp;
			Temp=NULL;

			

		}
	//已经删除节点，并且y是删除节点的位置，py为y的父节点
	//进行颜色调整
	if(!NeedAdjustFlag)
	{
		return *this;
	}
	
	AdjustColorAfterDelete(Y,Py,DirectionOfYInPy);

	return *this;

}

template<class T> bool BlackRedTree<T>::AdjustColorAfterDelete(BlackRedNode<T>* Y,BlackRedNode<T>* Py,int DirectionOfY)
{
	if(Py==NULL)
	{
		Root ->Color=BLACK;
		return true;
	}
	/*
	if(DirectionOfY!=0 || DirectionOfY!=1)
	{
		cout<<"Error,AdjustColorAfterDelete,DirectionOfY:"<<Y<<endl;
		return false;
	}
	*/

	BlackRedNode<T>* AnotherChildOfPy;//Y的父节点的另外一个孩子的指针
	int OldColorOfPy ;

	if(DirectionOfY==1)//右孩子
	{
		AnotherChildOfPy = Py->Left;
		if(AnotherChildOfPy->Color == BLACK)
		{
			
			switch( GetRedChildNumOfNode(AnotherChildOfPy) )
			{
			case 0:
				OldColorOfPy = Py->Color;
				RbZero_AfterDelete(Py,DirectionOfY);
				if(OldColorOfPy == BLACK)
				{
					Y= Py;
					Py= Py->Parent;
					
					return AdjustColorAfterDelete(Y,Py,GetDirctionOfYInPy(Y,Py));
				}
				break;
			case 1:
				RbOne_AfterDelete(Py,DirectionOfY);
				break;
			case 2:
				RbTwo_AfterDelete(Py,DirectionOfY);
				break;
			}
		}
		else
		{
			switch( GetRedChildNumOfNode(AnotherChildOfPy->Right) )
			{
			case 0:
				RrZero_AfterDelete(Py,DirectionOfY);
				break;
			case 1:
				RrOne_AfterDelete(Py,DirectionOfY);
				break;
			case 2:
				RrTwo_AfterDelete(Py,DirectionOfY);
				break;
			}

		}
	}
	else
	{
		AnotherChildOfPy = Py->Right;
		if(AnotherChildOfPy->Color == BLACK)
		{
			
			switch( GetRedChildNumOfNode(AnotherChildOfPy) )
			{
			case 0:
				OldColorOfPy = Py->Color;
				LbZero_AfterDelete(Py,DirectionOfY);
				if(OldColorOfPy == BLACK)
				{
					Y= Py;
					Py= Py->Parent;
					
					return AdjustColorAfterDelete(Y,Py,GetDirctionOfYInPy(Y,Py));
				}

				break;
			case 1:
				LbOne_AfterDelete(Py,DirectionOfY);
				break;
			case 2:
				LbTwo_AfterDelete(Py,DirectionOfY);
				break;
			}
		}
		else
		{
			switch( GetRedChildNumOfNode(AnotherChildOfPy) )
			{
			case 0:
				LrZero_AfterDelete(Py,DirectionOfY);
				break;
			case 1:
				LrOne_AfterDelete(Py,DirectionOfY);
				break;
			case 2:
				LrTwo_AfterDelete(Py,DirectionOfY);
				break;
			}

		}

	}
	return true;

}

template<class T> bool BlackRedTree<T>::IfNeedAdjustAfterDelete(BlackRedNode<T>* Node,bool& NeedFlag)
{
	if(Node->Color == BLACK)
	{
		NeedFlag = true;
	}
	else
	{
		NeedFlag = false;
	}
	return true;
}

template<class T> int BlackRedTree<T>::GetRedChildNumOfNode(BlackRedNode<T>* Node)
{
	int Count=0;
	if(Node->Left)
	{
		if(Node->Left->Color == RED)
		{
			Count+=1;
		}
	}
	if(Node->Right)
	{
		if(Node->Right->Color == RED)
		{
			Count+=1;
		}
	}
	return Count;
}

template<class T> int BlackRedTree<T>:: GetDirctionOfYInPy(BlackRedNode<T>* Y,BlackRedNode<T>* Py)
{
	if(!Py)
	{
		return -1;
	}
	if(Y==Py->Left)
	{
		return 0;
	}
	if(Y==Py->Right)
	{
		return 1;
	}
	return -1;
}

template<class T> bool BlackRedTree<T>:: RbZero_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY)
{
	PRINTFUN();
	Py->Color = BLACK;

	/*
	if(DirectionOfY==0)
	{
		Py->Right->Color = RED;
	}
	*/	
	Py->Left->Color = RED;
	return true;
}

template<class T> bool BlackRedTree<T>::RbOne_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY)
{
	PRINTFUN();
	if(Py->Left->Left && Py->Left->Left->Color == RED)
	{
		RbOne_VLeftRed_AfterDelete(Py,DirectionOfY);
	}
	else
	{
		RbOne_VRightRed_AfterDelete(Py,DirectionOfY);
	}
	return true;
}

template<class T>  bool BlackRedTree<T>::RbOne_VLeftRed_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY)
{
	PRINTFUN();
	BlackRedNode<T>* NewNode,*NodeToDelete;
	NewNode= new BlackRedNode<T>(Py->Data,BLACK);
	NodeToDelete = Py->Left;

	NewNode->Left = NodeToDelete->Right;
	NewNode->Right = Py->Left;

	Py->Left = NodeToDelete->Left;
	Py->Right = NewNode;
	Py->Data = NodeToDelete->Data;

	//调整父节点信息
	if(Py->Left)
	{
		Py->Left->Parent = Py;
	}
	if(Py->Right)
	{
		Py->Right->Parent = Py;
	}
	if(NewNode->Left)
	{
		NewNode->Left->Parent = NewNode;
	}
	if(NewNode->Right)
	{
		NewNode->Right->Parent = NewNode;
	}
	
	//调整颜色
	if(Py->Left)
	{
		Py->Left->Color = BLACK;
	}

	if(NodeToDelete)
	{
		delete NodeToDelete;
		NodeToDelete = NULL;
	}
	return true;

}

template<class T> bool BlackRedTree<T>::RbOne_VRightRed_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY)
{
	PRINTFUN();
	BlackRedNode<T>* NewNode,*NodeToDelete;
	NewNode= new BlackRedNode<T>(Py->Data,BLACK);
	NodeToDelete = Py->Left->Right;

	NewNode->Left = NodeToDelete->Right;
	NewNode->Right = Py->Right;

	Py->Left->Right = NodeToDelete->Left;
	Py->Right = NewNode;
	Py->Data = NodeToDelete->Data;

	//调整父节点信息
	if(Py->Left->Right)
	{
		Py->Left->Right->Parent = Py->Left;
	}
	if(Py->Right)
	{
		Py->Right->Parent = Py;
	}
	if(NewNode->Left)
	{
		NewNode->Left->Parent = NewNode;
	}
	if(NewNode->Right)
	{
		NewNode->Right->Parent = NewNode;
	}
	
	//调整颜色
	

	if(NodeToDelete)
	{
		delete NodeToDelete;
		NodeToDelete = NULL;
	}
	return true;
}

template<class T> bool  BlackRedTree<T>:: RbTwo_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY)
{
	PRINTFUN();
	BlackRedNode<T>* NewNode,*NodeToDelete;
	NewNode= new BlackRedNode<T>(Py->Data,BLACK);
	NodeToDelete = Py->Left->Right;

	NewNode->Left = NodeToDelete->Right;
	NewNode->Right = Py->Right;

	Py->Left->Right = NodeToDelete->Left;
	Py->Right = NewNode;
	Py->Data = NodeToDelete->Data;

	//调整父节点信息
	if(Py->Left->Right)
	{
		Py->Left->Right->Parent = Py->Left;
	}
	if(Py->Right)
	{
		Py->Right->Parent = Py;
	}
	if(NewNode->Left)
	{
		NewNode->Left->Parent = NewNode;
	}
	if(NewNode->Right)
	{
		NewNode->Right->Parent = NewNode;
	}
	
	//调整颜色

	if(NodeToDelete)
	{
		delete NodeToDelete;
		NodeToDelete = NULL;
	}
	return true;
}

template<class T> bool BlackRedTree<T>::RrZero_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY)
{
	PRINTFUN();
	BlackRedNode<T>* NewNode,*NodeToDelete;
	NewNode = new BlackRedNode<T>(Py->Data,BLACK);
	NodeToDelete = Py->Left;

	NewNode->Left = NodeToDelete->Right;
	NewNode->Left->Color = RED;
	NewNode->Right = Py->Right;

	Py->Data = NodeToDelete->Data;
	Py->Left = NodeToDelete->Left;
	Py->Right = NewNode;

	//调整父指针
	if(NewNode->Left)
	{
		NewNode->Left->Parent = NewNode;
	}
	if(NewNode->Right)
	{
		NewNode->Right->Parent = NewNode;
	}
	if(Py->Left)
	{
		Py->Left->Parent = Py;
	}
	if(Py->Right)
	{
		Py->Right ->Parent =Py;
	}
	if(NodeToDelete)
	{
		delete NodeToDelete;
		NodeToDelete = NULL;
	}
	return true;
}

template<class T> bool BlackRedTree<T>::RrOne_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY)
{
	PRINTFUN();
	if(Py->Left->Right->Left!=NULL && Py->Left->Right->Left->Color==RED)
	{
		return RrOne_VRLr_AfterDelete(Py,DirectionOfY);
	}
	else
	{
		return RrOne_VRRr_AfterDelete(Py,DirectionOfY);
	}
}

template<class T> bool BlackRedTree<T>:: RrOne_VRLr_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY)
{
	PRINTFUN();
	BlackRedNode<T>* NewNode,*NodeToDelete;
	NewNode= new BlackRedNode<T>(Py->Data,BLACK);
	NodeToDelete = Py->Left->Right;

	NewNode->Left = NodeToDelete->Right;
	NewNode->Right = Py->Right;

	Py->Left->Right = NodeToDelete->Left;
	Py->Left->Right->Color = BLACK;
	Py->Right = NewNode;
	Py->Data = NodeToDelete->Data;

	//调整父节点信息
	if(Py->Left->Right)
	{
		Py->Left->Right->Parent = Py->Left;
	}
	if(Py->Right)
	{
		Py->Right->Parent = Py;
	}
	if(NewNode->Left)
	{
		NewNode->Left->Parent = NewNode;
	}
	if(NewNode->Right)
	{
		NewNode->Right->Parent = NewNode;
	}
	
	//调整颜色

	if(NodeToDelete)
	{
		delete NodeToDelete;
		NodeToDelete = NULL;
	}
	return true;
}

template<class T> bool BlackRedTree<T>:: RrOne_VRRr_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY)
{
	PRINTFUN();
	BlackRedNode<T>* NewNode,*NodeToDelete;
	NewNode= new BlackRedNode<T>(Py->Data,BLACK);
	NodeToDelete = Py->Left->Right->Right;

	NewNode->Left = NodeToDelete->Right;
	NewNode->Right = Py->Right;

	Py->Left->Right->Right = NodeToDelete->Left;
	
	Py->Right = NewNode;
	Py->Data = NodeToDelete->Data;

	//调整父节点信息
	if(Py->Left->Right->Right)
	{
		Py->Left->Right->Right->Parent = Py->Left->Right;
	}
	if(Py->Right)
	{
		Py->Right->Parent = Py;
	}
	if(NewNode->Left)
	{
		NewNode->Left->Parent = NewNode;
	}
	if(NewNode->Right)
	{
		NewNode->Right->Parent = NewNode;
	}
	
	//调整颜色

	if(NodeToDelete)
	{
		delete NodeToDelete;
		NodeToDelete = NULL;
	}
	return true;
}

template<class T> bool BlackRedTree<T>::RrTwo_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY)
{
	PRINTFUN();
	BlackRedNode<T>* NewNode,*NodeToDelete;
	NewNode= new BlackRedNode<T>(Py->Data,BLACK);
	NodeToDelete = Py->Left->Right->Right;

	NewNode->Left = NodeToDelete->Right;
	NewNode->Right = Py->Right;

	Py->Left->Right->Right = NodeToDelete->Left;
	
	Py->Right = NewNode;
	Py->Data = NodeToDelete->Data;

	//调整父节点信息
	if(Py->Left->Right->Right)
	{
		Py->Left->Right->Right->Parent = Py->Left->Right;
	}
	if(Py->Right)
	{
		Py->Right->Parent = Py;
	}
	if(NewNode->Left)
	{
		NewNode->Left->Parent = NewNode;
	}
	if(NewNode->Right)
	{
		NewNode->Right->Parent = NewNode;
	}
	
	//调整颜色

	if(NodeToDelete)
	{
		delete NodeToDelete;
		NodeToDelete = NULL;
	}
	return true;
}

template<class T> bool BlackRedTree<T>::LbZero_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY)
{
	PRINTFUN();
	Py->Color = BLACK;

	if(DirectionOfY==0)
	{
		Py->Right->Color = RED;
	}	
	return true;
}


template<class T> bool BlackRedTree<T>::LbOne_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY)//Lb1型调整函数
{
	PRINTFUN();
	if(Py->Right->Left && Py->Right->Left->Color == RED)
	{
		LbOne_VLeftRed_AfterDelete(Py,DirectionOfY);
	}
	else
	{
		LbOne_VRightRed_AfterDelete(Py,DirectionOfY);
	}
	return true;
}
template<class T> bool BlackRedTree<T>::LbOne_VLeftRed_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY)//Rb1型调整函数：v的left是red
{
	PRINTFUN();
	BlackRedNode<T>* NewNode,*NodeToDelete;
	NewNode= new BlackRedNode<T>(Py->Data,BLACK);
	NodeToDelete = Py->Left;

	NewNode->Left = Py->Left ;
	NewNode->Right = NodeToDelete->Left;

	Py->Left = NewNode ;
	Py->Right->Left = NodeToDelete->Right;
	Py->Data = NodeToDelete->Data;

	//调整父节点信息
	if(Py->Left)
	{
		Py->Left->Parent = Py;
	}
	if(Py->Right->Left)
	{
		Py->Right->Left->Parent = Py->Right;
	}
	if(NewNode->Left)
	{
		NewNode->Left->Parent = NewNode;
	}
	if(NewNode->Right)
	{
		NewNode->Right->Parent = NewNode;
	}
	
	//调整颜色


	if(NodeToDelete)
	{
		delete NodeToDelete;
		NodeToDelete = NULL;
	}
	return true;


}
template<class T> bool BlackRedTree<T>::LbOne_VRightRed_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY)//Rb1型调整函数:v的right是red
{
	PRINTFUN();
	BlackRedNode<T>* NewNode,*NodeToDelete;
	NewNode= new BlackRedNode<T>(Py->Data,BLACK);
	NodeToDelete = Py->Right;

	NewNode->Left = Py->Left;
	NewNode->Right = NodeToDelete->Left;

	Py->Left =NewNode ;
	Py->Right = NodeToDelete->Right;
	Py->Data = NodeToDelete->Data;

	//调整父节点信息
	if(Py->Left)
	{
		Py->Left->Parent = Py;
	}
	if(Py->Right)
	{
		Py->Right->Parent = Py;
	}
	if(NewNode->Left)
	{
		NewNode->Left->Parent = NewNode;
	}
	if(NewNode->Right)
	{
		NewNode->Right->Parent = NewNode;
	}
	
	//调整颜色
	if(Py->Right)
	{
		Py->Right->Color = BLACK;
	}

	if(NodeToDelete)
	{
		delete NodeToDelete;
		NodeToDelete = NULL;
	}
	return true;
}

template<class T> bool BlackRedTree<T>::LbTwo_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY)
{
	PRINTFUN();
	BlackRedNode<T>* NewNode,*NodeToDelete;
	NewNode= new BlackRedNode<T>(Py->Data,BLACK);
	NodeToDelete = Py->Right->Left;

	NewNode->Left = Py->Left ;
	NewNode->Right = NodeToDelete->Left;

	Py->Right->Left = NodeToDelete->Right;
	Py->Left = NewNode;
	Py->Data = NodeToDelete->Data;

	//调整父节点信息
	if(Py->Right->Left)
	{
		Py->Right->Left->Parent = Py->Right;
	}
	if(Py->Left)
	{
		Py->Left->Parent = Py;
	}
	if(NewNode->Left)
	{
		NewNode->Left->Parent = NewNode;
	}
	if(NewNode->Right)
	{
		NewNode->Right->Parent = NewNode;
	}
	
	//调整颜色

	if(NodeToDelete)
	{
		delete NodeToDelete;
		NodeToDelete = NULL;
	}
	return true;
}

template<class T> bool BlackRedTree<T>::LrZero_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY)
{
	PRINTFUN();
	BlackRedNode<T>* NewNode,*NodeToDelete;
	NewNode = new BlackRedNode<T>(Py->Data,BLACK);
	NodeToDelete = Py->Right;

	NewNode->Left = Py->Left;
	NewNode->Right = NodeToDelete->Left;
	NewNode->Right->Color = RED;

	Py->Data = NodeToDelete->Data;
	Py->Left =NewNode ;
	Py->Right =NodeToDelete->Right ;

	//调整父指针
	if(NewNode->Left)
	{
		NewNode->Left->Parent = NewNode;
	}
	if(NewNode->Right)
	{
		NewNode->Right->Parent = NewNode;
	}
	if(Py->Left)
	{
		Py->Left->Parent = Py;
	}
	if(Py->Right)
	{
		Py->Right ->Parent =Py;
	}
	if(NodeToDelete)
	{
		delete NodeToDelete;
		NodeToDelete = NULL;
	}
	return true;
}

template<class T> bool BlackRedTree<T>::LrOne_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY)
{
	PRINTFUN();
	if(Py->Right->Left->Left!=NULL && Py->Right->Left->Left->Color == RED)
	{
		return LrOne_VLLr_AfterDelete(Py,DirectionOfY);
	}
	else
	{
		return LrOne_VLRr_AfterDelete(Py,DirectionOfY);
	}
}


template<class T> bool BlackRedTree<T>:: LrOne_VLRr_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY)
{
	PRINTFUN();
	BlackRedNode<T>* NewNode,*NodeToDelete;
	NewNode= new BlackRedNode<T>(Py->Data,BLACK);
	NodeToDelete = Py->Right->Left;

	NewNode->Left = Py->Left;
	NewNode->Right =NodeToDelete->Left;

	Py->Right->Left = NodeToDelete->Right;
	Py->Left = NewNode;

	Py->Data = NodeToDelete->Data;

	//调整父节点信息
	if(Py->Right->Left)
	{
		Py->Right->Left->Parent =Py->Right;
	}
	if(Py->Left)
	{
		Py->Left->Parent = Py;
	}
	if(NewNode->Left)
	{
		NewNode->Left->Parent = NewNode;
	}
	if(NewNode->Right)
	{
		NewNode->Right->Parent = NewNode;
	}
	
	//调整颜色
	Py->Right->Left->Color = BLACK;

	if(NodeToDelete)
	{
		delete NodeToDelete;
		NodeToDelete = NULL;
	}
	return true;
}
template<class T> bool BlackRedTree<T>::LrOne_VLLr_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY)
{
	PRINTFUN();
	BlackRedNode<T>* NewNode,*NodeToDelete;
	NewNode= new BlackRedNode<T>(Py->Data,BLACK);
	NodeToDelete = Py->Right->Left->Left;

	NewNode->Left = Py->Left;
	NewNode->Right = NodeToDelete->Left;

	Py->Right->Left->Left = NodeToDelete->Right;
	
	Py->Left = NewNode;
	Py->Data = NodeToDelete->Data;

	//调整父节点信息
	if(Py->Right->Left->Left)
	{
		Py->Right->Left->Left->Parent =Py->Right->Left;
	}
	if(Py->Left)
	{
		Py->Left->Parent = Py;
	}
	if(NewNode->Left)
	{
		NewNode->Left->Parent = NewNode;
	}
	if(NewNode->Right)
	{
		NewNode->Right->Parent = NewNode;
	}
	
	//调整颜色

	if(NodeToDelete)
	{
		delete NodeToDelete;
		NodeToDelete = NULL;
	}
	return true;
}

template<class T> bool BlackRedTree<T>::LrTwo_AfterDelete(BlackRedNode<T>* Py,int DirectionOfY)
{
	PRINTFUN();
	BlackRedNode<T>* NewNode,*NodeToDelete;
	NewNode= new BlackRedNode<T>(Py->Data,BLACK);
	NodeToDelete = Py->Right->Left->Left;

	NewNode->Left = Py->Left;
	NewNode->Right = NodeToDelete->Left;

	Py->Right->Left->Left = NodeToDelete->Right;
	
	Py->Left = NewNode;
	Py->Data = NodeToDelete->Data;

	//调整父节点信息
	if(Py->Right->Left->Left)
	{
		Py->Right->Left->Left->Parent =Py->Right->Left;
	}
	if(Py->Left)
	{
		Py->Left->Parent = Py;
	}
	if(NewNode->Left)
	{
		NewNode->Left->Parent = NewNode;
	}
	if(NewNode->Right)
	{
		NewNode->Right->Parent = NewNode;
	}
	
	//调整颜色

	if(NodeToDelete)
	{
		delete NodeToDelete;
		NodeToDelete = NULL;
	}
	return true;
}

#endif


//practise.cpp

#include "BlackRedTree.h"

void main()
{
	BlackRedTree<int> Bl;
	int a[] = {1,2,3,4,5,6,7,8,9,10,11,12,14,90,88,60};
	for(int i= 0;i<sizeof(a)/sizeof(int);i++)
	{
		//cout<<"a[i]:"<<a[i]<<endl;
		cout<<"===================="<<endl;
		Bl.Insert(a[i]);
		
		
	}
	Bl.PrintTree();
	cout<<"输入要删除的节点值"<<endl;

	int DelItem;
	cin >> DelItem;
	Bl.Delete(DelItem);
	Bl.PrintTree();

	return;
}


 

tjweilong
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
理解红黑树（下）删除操作
ZeaLot4J的博客
11-14 8720
1. 引言红黑树的结点增删改查效率非常优良，都为logn，其应用十分广泛： 1. Linux内核进程调度由红黑树管理进程控制块。 2. Epoll用红黑树管理事件块。 3. nginx服务器用红黑树管理定时器。 4. C++ STL中的map和set的底层实现为红黑树。 5. Java中的TreeMap和TreeSet由红黑树实现。 6. Java8开始，HashMap中，当
数据结构 - 红黑树（Red Black Tree）删除详解与实现（Java）
aqm63700的博客
09-18 294
　　本篇要讲的就是红黑树的删除操作 　　　　　　红黑树插入操作请参考数据结构 - 红黑树（Red Black Tree）插入详解与实现（Java） 　　红黑树的删除是红黑树操作中比较麻烦且比较有意思的一部分。 　　在此之前，重申一遍红黑树的五个定义： 　　　　1. 红黑树的节点不是黑色的就是红色的 　　　　2. 红黑树的根节点一定是黑色的 　　　　3. 红黑树的所有叶...
红黑树插入、删除、查找算法学习
雨纷飞
11-11 5146
红黑树(red-black tree)是许多“平衡”搜索树中的一种，可以保证在最坏情况下基本动态集合操作的时间复杂度为O(lgn)，文章讲述红黑树的性质，结构描述，插入、删除算法分析，最后完成一个C语言测试程序。
RBT(红黑树)的删除算法
xiaoguobaf的博客
08-03 5108
2-3树中删除最小键作为一个热身，回到2-3树来看下删除，简单起见，从删除最小键开始。如果含有最小键的节点不是2节点（3节点或4节点），那么直接删除该节点，不会破坏树的平衡性，但是如果是2节点，由于删除后变为空节点，有可能会破坏平衡性，故删除最小键的思路是沿左链接向下进行变换，确保当前节点不是2节点。 根节点根节点的左右孩子都为2节点此时将3个2节点合并为一个4节点 根节点的右孩子不为2节点左孩
用python实现AVL树、B树、红黑树的插入、查找和删除操作
最新发布
10-16
红黑树的插入、查找和删除操作同样保证O(log n)的时间复杂度，但插入和删除可能涉及到颜色调整和旋转。在Python中，我们需要定义节点类，包括节点值、颜色、左右子节点，以及相应的旋转和颜色调整规则。 对于这些...
红黑树插入删除的平衡操作
03-17
红黑树插入，删除时各种状态的平衡操作。
红黑树插入删除伪算法
03-10
**红黑树删除操作**： 1. 删除操作首先找到待删除节点，然后替换节点（如果节点有子节点）、删除节点（如果节点无子节点）或合并节点（如果节点有两个子节点）。 2. 替换或删除后，可能需要通过颜色调整和旋转来维护...
红黑树的插入详细图解，直接拿下红黑树
08-17
红黑树的插入操作虽然复杂，但是它保证了在最坏情况下，插入、查找和删除的时间复杂度都为O(log n)，使得它成为关联数组和其他高效数据结构的理想选择。在实际应用中，红黑树被广泛用于数据库索引、内存管理、编译器...
红黑树插入删除算法
09-27
红黑树插入删除算法，算法导论上算法，可以运行
实现红黑树中
tjweilong的专栏
03-14 355
2013-3-19 23:02 完成红黑树的插入操作，红黑树的搜索与搜索二叉树的搜索函数是相同的。每天抽点时间看书。   //BLTreePractise.cpp #include "BlackRedTree.h" void main() { BlackRedTree Bl; int a[] = {1,2,3,9,5,4,10,6,8,7}; for(int i= 0;i<sizeo
红黑树的删除之3（共四篇）
lm2009200的博客
04-13 6768
红黑树的删除操作是红黑树最复杂的操作了，只要搞明白这个，基本上就明白红黑树的调整。RB-DELETE(T, z) y = z; y-original-color = y.color; if z.left == T.NIL x = z.right; RB-TRANSPLANT(T, z, z.right); else if z.right == T.NIL x
红黑树删除操作的各种情况分析
马小超
12-07 1342
目录 删除情况具体分析 1. 删除的节点没有子节点的情况 2. 删除的节点只有一个子节点时 3. 如果删除节点有两个子节点时 红黑树删除平衡情况分析 红黑书的删除本质上是一个穷举的过程。 删除情况具体分析 1. 删除的节点没有子节点的情况  a、如果为红色，直接删除即可，不会影响黑色节点的数量   删除红色节点（13）示例（不影响黑色节点数量，不需要平衡操作）  b、如果为黑色，删除的时候需要进行平衡操作   删除示例，删除节点11（平衡操作后面会介绍到） 2. 删除的节点只有一个子..
红黑树从头至尾插入和删除结点的全程演示图
热门推荐
结构之法 算法之道
03-28 7万+
                     红黑树插入和删除结点的全程演示作者：July、saturnman。时间：二零一一年三月二十八日。声明：版权所有，侵权必究。-----------------------------------引言：    目前图书上，抑或网上讲解红黑树的资料层次不齐，混乱不清，没有一个完整而统一的阐述。而本人迄今为止最满意的作品，红黑树系列，虽然从头至尾，讲的有根有据，层次清晰，然距离读者真正做到红黑树于胸中了如指掌，则还缺点什么。    缺点什么列?对了，就是一个完完整整的，包含
死磕红黑树——聊聊红黑树的删除
zzy893037505的博客
03-25 3562
红黑树删除简介 红黑树删除包括 删除结点 和 删除后的调整 两个阶段。 红黑树的删除为什么难理解？主要就是因为： 逻辑删除算法 和 计算机删除算法 有出入。即人脑的演算过程和用代码实现时的计算过程有出入，想要完全理解“红黑树”需要同时掌握两种算法。 对可能出现的情形判断经验不足。这个主要跟没有熟记“红黑树的性质”有一定的关系。 复杂的中文表述增加了理解和记忆的难度。比如什么“父结点的右子树的左子结点”，“兄弟结点的左子结点为黑色”。 “黑高” 树的高度：指的是从该结点到叶子结点的最长路径。
红黑树（Red-Black tree）（插入与删除操作）
不积跬步，无以致千里；不积小流，无以成江海
07-09 2298
前面讲了平衡二叉树（AVL），可以完美地实现将查找复杂度控制在O(logn)。但是AVL增加删除节点的时候，需要不断地判断左右树的高度差，这个频繁的操作降低了性能。为此提出了红黑树。什么样的树叫做红黑树呢？ 红黑树需要满足以下五个性质（摘自算法导论）： 1、每个节点不是红的就是黑的； 2、根节点是黑的； 3、每个叶子节点（也就是树的尾端NULL节点）是黑的； 4、如果一个节点是红的，那么
红黑树的经典介绍
坚持
04-21 997
目录 1 红黑树的介绍 2 红黑树的应用 3 红黑树的时间复杂度和相关证明 4 红黑树的基本操作(一) 左旋和右旋 5 红黑树的基本操作(二) 添加 6 红黑树的基本操作(三) 删除        作者：Sky Wang    于 2013-08-08                                概述：R-B Tree，又称为“红黑树”。本文参考
红黑树的删除操作分析（简单粗暴有道理）
窗外阴天的博客
02-02 4839
看了很多材料，关于红黑树的删除，大概所有的总结都大同小异，今天先聊聊对红黑树删除的情况分析： 红黑树的删除操作 1：节点命名约定 D表示要被删除的节点。即：取 Delete 的首字母； P 表示父节点。即：取 Parent 的首字母； S表示兄弟姐妹节点。即：取 Sibling的首字母； U表示叔伯节点。即：取Uncle的首字母； G表示祖父节点。即：取 Grandfather的首字
红黑树插入删除详解：规则与操作推导
红黑树是一种自平衡二叉查找树，它通过颜色标记节点，保证了查找、插入和删除操作的高效性能。在这个详细的整理文档中，我们将探讨红黑树插入和删除操作的关键步骤以及旋转原则。 1. 插入操作: - 插入过程与普通...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值