红黑树的实现（C++）

最新推荐文章于 2024-08-14 14:00:10 发布
最新推荐文章于 2024-08-14 14:00:10 发布
阅读量1k 收藏 2
点赞数
分类专栏： 算法&&数据结构 文章标签： c++ iterator null parameters delete header
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fjz13/article/details/2589070
版权

这是做数据结构的副产品。

挺麻烦的一个东西，记录下来，以备以后只需。

红黑树的规则我不说太多，网上的资料太多。

代码之中，了无秘密：

/********************************************************************

Filename:	RBTree.h

CreatedTime:2008/06/20   10:55

Author:		fjz

Purpose:    红黑树

Version:    1.0

MODIFY:

Name:

Time:

Description:

*********************************************************************/

#pragma once

#include <iostream>

#include <stack>

namespace DS

{

	namespace Container

	{

		/************************************

		ClassName:	RBTreeNode

		Filename:	RBTree.h

		CreatedTime:2008/06/20   11:19

		Description:红黑树节点

		************************************/

		template<typename ElemType>

		class RBTreeNode

		{

		public:

			typedef enum {RED=0,/*红色为0*/ BLACK=1/*黑色为1*/}ColorType;

			ColorType mColor;			//节点颜色

			RBTreeNode* mParent;	//父节点

			RBTreeNode* mLeft;		//左节点

			RBTreeNode* mRight;		//右节点

			ElemType mValue;			//值

			typedef RBTreeNode<ElemType>* LinkType;		//链接类型

			RBTreeNode()

			{

				mColor=RED;

				mLeft=NULL;

				mParent=NULL;

				mRight=NULL;

			}

			RBTreeNode(const ElemType inValue)

			{

				mValue=inValue;

				mColor=RED;

				mLeft=NULL;

				mParent=NULL;

				mRight=NULL;

			}

			RBTreeNode(const RBTreeNode<ElemType>& inNode)	//只复制值和颜色

			{

				mValue=inNode.mValue;

				mColor=inNode.mColor;

				mLeft=NULL;

				mParent=NULL;

				mRight=NULL;

			}

			

			

			/************************************

			CreatedTime:2008/06/20   11:24	

			MethodName: Container::RBTreeNode::GetMinNode

			Access:    	public static 

			Parameters: const RBTreeNode * inRootNode	根结点

			Returns:   	RBTreeNode*	最小的节点

			Description:得到最小的节点（最左节点）

			Remark:			

			************************************/

			static RBTreeNode* GetMinNode(const RBTreeNode* inRootNode)

			{

				if (inRootNode==NULL)

					return NULL;

				RBTreeNode* tNode=const_cast<RBTreeNode*>(inRootNode);

				while (tNode->mLeft!=NULL)

				{

					tNode=tNode->mLeft;

				}

				return tNode;

			}

			/************************************

			CreatedTime:2008/06/20   11:24	

			MethodName: Container::RBTreeNode::GetMaxNode

			Access:    	public static 

			Parameters: const RBTreeNode * inRootNode	根结点

			Returns:   	RBTreeNode*	最大的节点

			Description:得到最大的节点（最右节点）

			Remark:			

			************************************/

			static RBTreeNode* GetMaxNode(const RBTreeNode* inRootNode)

			{

				if (inRootNode==NULL)

					return NULL;

				RBTreeNode* tNode=const_cast<RBTreeNode*>(inRootNode);

				while (tNode->mRight!=NULL)

				{

					tNode=tNode->mRight;

				}

				return tNode;

			}

		};

		/************************************

		ClassName:	RBTreeIterator

		Filename:	RBTree.h

		CreatedTime:2008/06/20   13:03

		Description:红黑树迭代器

		************************************/

		template<typename ElemType,typename RefType,typename PtrType>

		class RBTreeIterator

		{

		public:

			typedef ElemType ValueType;			//值类型

			typedef RefType ReferenceType;		//引用类型

			typedef PtrType PointerType;		//指针类型

			typedef RBTreeIterator<ElemType,ElemType&,ElemType*> Iterator;					//迭代器

			typedef RBTreeIterator<ElemType,const ElemType&,const ElemType*> ConstIterator;	//常量迭代器

			typedef	RBTreeIterator<ElemType,RefType,PtrType> Self;							//本身

			typedef RBTreeNode<ElemType>* LinkType;											//链接类型

			LinkType mNode;	

		public:

			RBTreeIterator(){}

			RBTreeIterator(LinkType inNode){mNode=inNode;}

			RBTreeIterator(const RBTreeIterator& inOtherIterator){mNode=inOtherIterator.mNode;}

			void operator=(const RBTreeIterator& inOtherIterator){mNode=inOtherIterator.mNode;}

			ReferenceType operator*()const {return LinkType(mNode)->mValue;}	//取引用

			PointerType operator->()const {return &(operator*());}				//取地址

			bool operator==(const RBTreeIterator& inOtherIterator){return mNode==inOtherIterator.mNode;}

			bool operator!=(const RBTreeIterator& inOtherIterator){return mNode!=inOtherIterator.mNode;}

			Self& operator++(){Increment();return *this;}

			Self& operator++(int)

			{

				Self tInterator=*this;

				Increment();

				return tInterator;

			}

			Self& operator--(){Decrement();return *this;}

			Self operator--(int)

			{

				Self tIterator=*this;

				Decrement();

				return tIterator;

			}

			/************************************

			CreatedTime:2008/06/20   11:26	

			MethodName: Container::RBTreeIterator::Increment

			Access:    	public 

			Returns:   	void

			Description:到下一个节点

			Remark:		中序遍历的下一个节点	

			************************************/

			void Increment()

			{

				if (mNode->mRight!=NULL)		//如果有右子节点

				{

					mNode=mNode->mRight;		//先往右走

					while (mNode->mLeft!=NULL)

					{

						mNode=mNode->mLeft;		//一直向左

					}

				} 

				else							//没有右子节点

				{

					LinkType tNode=mNode->mParent;		//找出父节点

					while (mNode==tNode->mRight)			//如果本节点自己是个右节点

					{

						mNode=tNode;						//就一直向上，直到不为右节点

						tNode=tNode->mParent;

					}

					if (mNode->mRight!=tNode)			//若此时的右子节点不等于此时的父节点，此时的父节点为解

					{									//注：此状况与红黑树的有个头哑元节点有关！

						mNode=tNode;

					}

					//否则此时的mNode即可

				}

			}

			/************************************

			CreatedTime:2008/06/20   11:42	

			MethodName: Container::RBTreeIterator::Decrement

			Access:    	public 

			Returns:   	void

			Description:到上一个节点

			Remark:		中序遍历的上一个节点		

			************************************/

			void Decrement()

			{

				//注：此状况发生于mNode为Header时（mNode为End()时）

				if (mNode->mColor==RBTreeNode<ElemType>::RED&&mNode->mParent->mParent==mNode)	//如果是父节点，且父节点的父节点等于自己

				{

					mNode=mNode->mRight;												//右节点即为解

				} 

				else if (mNode->mLeft!=NULL)		//如果有左节点

				{

					LinkType tNode=mNode->mLeft;

					while (tNode->mRight!=NULL)			//寻找左节点的最右节点

					{

						tNode=tNode->mRight;

					}

					mNode=tNode;

				} 

				else		//非根结点，也无左节点

				{

					LinkType tNode=mNode->mParent;

					while (mNode==tNode->mLeft)			//如果本节点自己为左节点

					{

						mNode=tNode;					//一直向上，直到本节点不为左节点

						tNode=tNode->mParent;

					}

					mNode=tNode;						//此时的父节点为解

				}

			}

		};



		/************************************

		ClassName:	RBTree

		Filename:	RBTree.h

		CreatedTime:2008/06/20   15:55

		Description:红黑树

		************************************/

		template

			<

			typename Key,			//关键字类型

			typename ElemType,		//元素类型

			typename KeyOfElem,		//在元素中取得关键字的函数对象

			typename CompareType	//关键字对比函数对象

			>

		class RBTree

		{

		public:

			RBTree(void){Init();}

			~RBTree(void){Clear();delete mHeader;}

		public:

			typedef RBTreeIterator<ElemType,ElemType&,ElemType*> Iterator;	//迭代器类型

		protected:

			typedef Key KeyType;

			typedef RBTreeNode<ElemType> NodeType;				//节点类型

			typedef NodeType* LinkType;							//链接类型

			typedef typename RBTreeNode<ElemType>::ColorType ColorType;		//颜色类型

		protected:

			size_t mCount;		//节点数量

			LinkType mHeader;	//头哑元节点

			CompareType mCompareKey;		//比较Key的函数对象

		public:

			LinkType& GetRoot()const {return (LinkType&)mHeader->mParent;}		//得到根节点

			LinkType& GetMostLeft()const {return(LinkType&) mHeader->mLeft;}	//得到最左节点

			LinkType& GetMostRight()const {return (LinkType&)mHeader->mRight;}	//得到最右节点

		protected:

			static LinkType& GetLeft(const LinkType inNode){return inNode->mLeft;}

			static LinkType& GetRight(const LinkType inNode){return inNode->mRight;}

			static LinkType& GetParent(const LinkType inNode){return inNode->mParent;}

			static ElemType& GetValue(const LinkType inNode){return inNode->mValue;}

			static KeyType GetKey(const LinkType inNode){return KeyOfElem()(GetValue(inNode));}

			static ColorType& GetColor(const LinkType inNode){return inNode->mColor;}

			static LinkType GetMinNode(LinkType inRootNode){return RBTreeNode::GetMinNode(inRootNode);}

			static LinkType GetMaxNode(LinkType inRootNode){return RBTreeNode::GetMaxNode(inRootNode);}

		private:

			/************************************

				CreatedTime:2008/06/20   16:48	

				MethodName: DS::Container::RBTree<Key, ElemType, KeyOfElem, CompareType>::Init

				Access:    	private 

				Returns:   	void

				Description:初始化

				Remark:			

			************************************/

			void Init()

			{

				

				mHeader=new NodeType();

				mHeader->mColor=RBTreeNode<ElemType>::RED;	//头哑元的颜色为红，用于区分header和root，在iterator::operator--之中

				mHeader->mParent=NULL;					//头哑元的父节点指向红黑树的根节点，此时为NULL

				mHeader->mLeft=mHeader;					//头哑元的左节点指向红黑树的最左节点，此时为本身

				mHeader->mRight=mHeader;				//头哑元的右节点指向红黑树的最右节点，此时为本身

				mCount=0;								//节点数量为0

				//注：根节点的父节点为头哑元

			}

			

			/************************************

				CreatedTime:2008/06/20   17:08	

				MethodName: DS::Container::RBTree<Key, ElemType, KeyOfElem, CompareType>::InsertHelp

				Access:    	private 

				Parameters: bool inIsLeft					是否在右边插入

				Parameters: LinkType inInsertNode		插入点之父节点

				Parameters: const ElemType & inInsertValue	新值

				Returns:   	bool	是否成功

				Description:插入节点

				Remark:			

			************************************/

			bool InsertHelp(bool inIsRight,LinkType inInsertNode,const ElemType& inInsertValue);

			void RebalanceInsert(LinkType inNewNode);

			void RebalanceDelete(LinkType inNewNode);

			void RotateLeft(LinkType inNewNode);

			void RotateRight(LinkType inNewNode);

		public:

			bool Delete(LinkType inDeleteNode);

			Iterator Begin()const{return GetMostLeft();}

			Iterator End()const{return mHeader;}

			bool IsEmpty()const {return mCount==0;}

			size_t GetCout()const{return mCount;}

			bool InsertUnique(const ElemType& inValue);

			bool InsertEqual(const ElemType& inValue);

			bool Delete(const ElemType& inValue);

			Iterator Find(const KeyType& inFindKey);

			/************************************

			CreatedTime:2008/06/20   16:48	

			MethodName: DS::Container::RBTree<Key, ElemType, KeyOfElem, CompareType>::Clear

			Access:    	private 

			Returns:   	void

			Description:析构清除

			Remark:			

			************************************/

			void Clear()

			{

				stack<LinkType> st;

				LinkType p=GetRoot();

				LinkType pre=0;					//pre表示最近一次访问的结点  !!!!!!



				while(!(p==0&&st.empty()))

				{

					while(p)			//沿着左孩子方向走到最左下 。

					{

						st.push(p);

						p = p->mLeft;

					}

					p = st.top();		

					if(p->mRight==0||p->mRight==pre)	//如果p没有右孩子或者其右孩子刚刚被访问过

					{

						st.pop();

						pre=p;

						delete p;

						p=NULL;

					}

					else	p = p->mRight;

				}

				Init();

			}

			

		};

		template<typename Key,typename ElemType,typename KeyOfElem,typename  CompareType>

		bool DS::Container::RBTree<Key, ElemType, KeyOfElem, CompareType>::Delete( const ElemType& inValue )

		{

			Iterator i=Find(KeyOfElem()(inValue));

			if (i==End())

			{

				return false;

			}

			return Delete(i.mNode);

		}

		template<typename Key,typename ElemType,typename KeyOfElem,typename  CompareType>

		bool DS::Container::RBTree<Key, ElemType, KeyOfElem, CompareType>::Delete( LinkType inDeleteNode )

		{

			LinkType tAdjustNode,tSonNode;

			if(inDeleteNode->mLeft==NULL||inDeleteNode->mRight==NULL)

			{

				tAdjustNode=inDeleteNode;

			}

			else

			{ 

				Iterator i=Iterator(inDeleteNode);

				++i;

				tAdjustNode=i.mNode;		//后继节点

			}

			if(tAdjustNode->mLeft!=NULL)

			{

				tSonNode=tAdjustNode->mLeft;

			}

			else 

			{

				tSonNode=tAdjustNode->mRight;

			}

			if(tSonNode!=NULL)

			{

				tSonNode->mParent=tAdjustNode->mParent;

			}

			if(tAdjustNode->mParent==mHeader)	//父为头节点

			{

				GetRoot()=tSonNode;

			}

			else if(tAdjustNode==tAdjustNode->mParent->mLeft)

			{

				tAdjustNode->mParent->mLeft=tSonNode;

			}

			else

			{

				tAdjustNode->mParent->mRight=tSonNode;

			}

			if(tAdjustNode!=inDeleteNode)

			{

				inDeleteNode->mValue=tAdjustNode->mValue; 

			}

			if(tAdjustNode->mColor==RBTreeNode<ElemType>::BLACK)

			{

				RebalanceDelete(tSonNode);

			}

			GetMostLeft()=RBTreeNode<ElemType>::GetMinNode(GetRoot());

			GetMostRight()=RBTreeNode<ElemType>::GetMaxNode(GetRoot());

			//delete tAdjustNode;

			return true;

		}



		template<typename Key,typename ElemType,typename KeyOfElem,typename  CompareType>

		typename DS::Container::RBTree<Key, ElemType, KeyOfElem, CompareType>::

			Iterator DS::Container::RBTree<Key, ElemType, KeyOfElem, CompareType>::Find( const KeyType& inFindKey )

		{

			LinkType tFindNode=GetRoot();

			int tCompareResult;

			while (tFindNode!=NULL)

			{

				tCompareResult=mCompareKey(inFindKey,GetKey(tFindNode));

				if (tCompareResult>0)	//大于

				{

					tFindNode=GetRight(tFindNode);

				} 

				else if(tCompareResult<0)

				{

					tFindNode=GetLeft(tFindNode);

				}

				else

				{

					return  tFindNode;

				}

			}

			return End();



		}

		template<typename Key,typename ElemType,typename KeyOfElem,typename  CompareType>

		bool DS::Container::RBTree<Key, ElemType, KeyOfElem, CompareType>::InsertEqual( const ElemType& inValue )

		{

			LinkType tParentNode=mHeader;

			LinkType tInsertNode=GetRoot();

			KeyType tKey=KeyOfElem()(inValue);

			bool tCompareResult=false;		//小于等于

			while (tInsertNode!=NULL)

			{

				tParentNode=tInsertNode;

				tCompareResult=mCompareKey(tKey,GetKey(tInsertNode))>0;

				tInsertNode=tCompareResult?GetRight(tInsertNode):GetLeft(tInsertNode);

				//遇大向右，遇小等于向左

			}

			return InsertHelp(tCompareResult,tParentNode,inValue);

		}

		template<typename Key,typename ElemType,typename KeyOfElem,typename  CompareType>

		bool DS::Container::RBTree<Key, ElemType, KeyOfElem, CompareType>::InsertUnique( const ElemType& inValue )

		{

			LinkType tParentNode=mHeader;

			LinkType tInsertNode=GetRoot();

			KeyType tKey=KeyOfElem()(inValue);

			bool tCompareResult=false;		//小于等于

			while (tInsertNode!=NULL)

			{

				tParentNode=tInsertNode;

				tCompareResult=mCompareKey(tKey,GetKey(tInsertNode))>0;

				tInsertNode=tCompareResult?GetRight(tInsertNode):GetLeft(tInsertNode);

				//遇大向右，遇小等于向左

			}

			if (tCompareResult==true)	//如果大于,那么必不等！

			{

				return InsertHelp(true,tParentNode,inValue);

			}

			else	//如果小于等于,那么要判断

			{

				if (mCompareKey(GetKey(tParentNode),tKey)!=0)	//不等于

				{

					return InsertHelp(false,tParentNode,inValue);

				} 

				else

				{

					return false;

				}

			}

		

		}

		template<typename Key,typename ElemType,typename KeyOfElem,typename  CompareType>

		bool DS::Container::RBTree<Key, ElemType, KeyOfElem, CompareType>::InsertHelp(bool inIsRight,LinkType inInsertNode,const ElemType& inInsertValue)

		{

			LinkType inNewNode=new NodeType(inInsertValue);	//新增节点

			if (inInsertNode==mHeader)

			{

				GetRoot()=inNewNode;

				GetMostLeft()=inNewNode;

				GetMostRight()=inNewNode;

				GetParent(inNewNode)=mHeader;

			}

			else if (inIsRight==true)	//在右边插入

			{

				GetRight(inInsertNode)=inNewNode;

				if (inInsertNode==GetMostRight())

				{

					GetMostRight()=inNewNode;

				}

			} 

			else

			{

				GetLeft(inInsertNode)=inNewNode;

				if (inInsertNode==GetMostLeft())

				{

					GetMostLeft()=inNewNode;

				}

			}

			GetParent(inNewNode)=inInsertNode;

			++mCount;

			RebalanceInsert(inNewNode);

			return true;

		}

		template<typename Key,typename ElemType,typename KeyOfElem,typename  CompareType>

		void DS::Container::RBTree<Key, ElemType, KeyOfElem, CompareType>::RebalanceInsert(LinkType inNewNode)

		{

			LinkType& tRootNode=GetRoot();	//根节点

			LinkType tUncleNode;			//伯父节点 

			while (inNewNode!=tRootNode&&inNewNode->mParent->mColor==RBTreeNode<ElemType>::RED)	//父节点为红

			{

				if (inNewNode->mParent==inNewNode->mParent->mParent->mLeft)			//父节点为祖父节点之左节点

				{

					tUncleNode=inNewNode->mParent->mParent->mRight;					//为伯父节点

					if (tUncleNode!=NULL&&tUncleNode->mColor==RBTreeNode<ElemType>::RED)		//伯父节点存在且为红

					{

						inNewNode->mParent->mColor=RBTreeNode<ElemType>::BLACK;			//父节点为黑

						tUncleNode->mColor=RBTreeNode<ElemType>::BLACK;					//伯父节点为黑

						inNewNode->mParent->mParent->mColor=RBTreeNode<ElemType>::RED;	//祖父节点为红

						inNewNode=inNewNode->mParent->mParent;						//到祖父

					} 

					else//无伯父节点或为黑

					{

						

						if(inNewNode==inNewNode->mParent->mRight)				//新节点为父节点之右节点

						{

							//此时为内侧插入，需要旋转两次

							inNewNode=inNewNode->mParent;	//到达父节点

							RotateLeft(inNewNode);			//左旋

						}

						//如果为外侧插入，则只需右旋一次

						inNewNode->mParent->mColor=RBTreeNode<ElemType>::BLACK;				//父节点为黑

						inNewNode->mParent->mParent->mColor=RBTreeNode<ElemType>::RED;		//祖父节点为红

						RotateRight(inNewNode->mParent->mParent);				//右旋

					}

				} 

				else

				{

					tUncleNode=inNewNode->mParent->mParent->mLeft;					//为伯父节点

					if (tUncleNode!=NULL&&tUncleNode->mColor==RBTreeNode<ElemType>::RED)		//伯父节点存在且为红

					{

						inNewNode->mParent->mColor=RBTreeNode<ElemType>::BLACK;			//父节点为黑

						tUncleNode->mColor=RBTreeNode<ElemType>::BLACK;					//伯父节点为黑

						inNewNode->mParent->mParent->mColor=RBTreeNode<ElemType>::RED;	//祖父节点为红

						inNewNode=inNewNode->mParent->mParent;						//到祖父

					} 

					else//无伯父节点或为黑

					{



						if(inNewNode==inNewNode->mParent->mLeft)				//新节点为父节点之左节点

						{

							//此时为内侧插入，需要旋转两次

							inNewNode=inNewNode->mParent;	//到达父节点

							RotateRight(inNewNode);			//左旋

						}

						//如果为外侧插入，则只需右旋一次

						inNewNode->mParent->mColor=RBTreeNode<ElemType>::BLACK;				//父节点为黑

						inNewNode->mParent->mParent->mColor=RBTreeNode<ElemType>::RED;		//祖父节点为红

						RotateLeft(inNewNode->mParent->mParent);				//右旋

					}

				}

			}

			tRootNode->mColor=RBTreeNode<ElemType>::BLACK;		//根节点永远为黑



		}

		template<typename Key,typename ElemType,typename KeyOfElem,typename  CompareType>

		void DS::Container::RBTree<Key, ElemType, KeyOfElem, CompareType>::RebalanceDelete(LinkType inAdjustNode)

		{



			LinkType tRootNode=GetRoot();

			LinkType tUncleNode = NULL;



			while (inAdjustNode!=NULL&&inAdjustNode != tRootNode&&inAdjustNode->mColor == RBTreeNode<ElemType>::BLACK) 

			{

				if (inAdjustNode == inAdjustNode->mParent->mLeft) 

				{

					tUncleNode = inAdjustNode->mParent->mRight;

					if (tUncleNode->mColor == RBTreeNode<ElemType>::RED) 

					{

						tUncleNode->mColor = RBTreeNode<ElemType>::BLACK;

						inAdjustNode->mParent->mColor = RBTreeNode<ElemType>::RED;

						RotateLeft(inAdjustNode->mParent);

						tUncleNode = inAdjustNode->mParent->mRight; 

					}

					if ((tUncleNode->mLeft->mColor == RBTreeNode<ElemType>::BLACK) && (tUncleNode->mRight->mColor == RBTreeNode<ElemType>::BLACK)) 

					{

						tUncleNode->mColor = RBTreeNode<ElemType>::RED;

						inAdjustNode = inAdjustNode->mParent; 

					}

					else if (tUncleNode->mRight->mColor == RBTreeNode<ElemType>::BLACK) 

					{

						tUncleNode->mColor = RBTreeNode<ElemType>::RED;

						tUncleNode->mLeft->mColor = RBTreeNode<ElemType>::BLACK;

						RotateRight(tUncleNode);

						tUncleNode = tUncleNode->mParent;

					}

					else 

					{ 

						tUncleNode->mColor = tUncleNode->mParent->mColor;

						inAdjustNode->mParent->mColor = RBTreeNode<ElemType>::BLACK;

						tUncleNode->mRight->mColor = RBTreeNode<ElemType>::BLACK;

						RotateLeft(inAdjustNode->mParent);

						inAdjustNode = tRootNode;

					}

				}

				else

				{

					tUncleNode=inAdjustNode->mParent->mRight;          

					if(tUncleNode->mColor==RBTreeNode<ElemType>::RED)      

					{

						tUncleNode->mColor=RBTreeNode<ElemType>::BLACK;

						inAdjustNode->mParent->mColor=RBTreeNode<ElemType>::RED;

						RotateRight(inAdjustNode->mParent);

						tUncleNode=inAdjustNode->mParent->mLeft;                

					}

					if(tUncleNode->mLeft->mColor==RBTreeNode<ElemType>::BLACK&&tUncleNode->mRight->mColor==RBTreeNode<ElemType>::BLACK)   

					{

						tUncleNode->mColor=RBTreeNode<ElemType>::RED;

						inAdjustNode=inAdjustNode->mParent;                                             

					}

					else if(tUncleNode->mLeft->mColor==RBTreeNode<ElemType>::RED)    

					{

						tUncleNode->mRight->mColor=RBTreeNode<ElemType>::BLACK;

						tUncleNode->mColor=RBTreeNode<ElemType>::RED;

						RotateLeft(tUncleNode);

						tUncleNode=inAdjustNode->mParent->mLeft; 

					}

					tUncleNode->mColor=inAdjustNode->mParent->mColor;

					inAdjustNode->mParent->mColor=RBTreeNode<ElemType>::BLACK;

					tUncleNode->mLeft->mColor=RBTreeNode<ElemType>::BLACK;

					RotateRight(inAdjustNode->mParent);     

				}

			}

			if (inAdjustNode!=NULL)

			{

				inAdjustNode->mColor = RBTreeNode<ElemType>::BLACK;

			}

		}

		template<typename Key,typename ElemType,typename KeyOfElem,typename  CompareType>

		void DS::Container::RBTree<Key, ElemType, KeyOfElem, CompareType>::RotateLeft(LinkType inNewNode)

		{

			LinkType tRightNode=inNewNode->mRight;		//右节点

			inNewNode->mRight=tRightNode->mLeft;

			LinkType& tRootNode=mHeader->mParent;

			if (tRightNode->mLeft!=NULL)

			{

				tRightNode->mLeft->mParent=inNewNode;

			}

			tRightNode->mParent=inNewNode->mParent;

			

			/*if (inNewNode==tRootNode)

			{

				tRootNode=tRightNode;

			} */

			if (inNewNode->mParent==mHeader)

			{

				tRootNode=tRightNode;

			}

			else if(inNewNode==inNewNode->mParent->mLeft)

			{

				inNewNode->mParent->mLeft=tRightNode;

			}

			else

			{

				inNewNode->mParent->mRight=tRightNode;

			}

			inNewNode->mRight=tRightNode->mLeft;	//此句不可忘！与<<算法导论>>的不同

			tRightNode->mLeft=inNewNode;

			inNewNode->mParent=tRightNode;

		}

		template<typename Key,typename ElemType,typename KeyOfElem,typename  CompareType>

		void DS::Container::RBTree<Key, ElemType, KeyOfElem, CompareType>::RotateRight(LinkType inNewNode)

		{

			LinkType tRightNode=inNewNode->mLeft;		//左节点

			inNewNode->mRight=tRightNode->mRight;

			LinkType& tRootNode=mHeader->mParent;

			if (tRightNode->mRight!=NULL)

			{

				tRightNode->mRight->mParent=inNewNode;

			}

			tRightNode->mParent=inNewNode->mParent;

			/*if (inNewNode==tRootNode)

			{

				tRootNode=tRightNode;

			} */

			if (inNewNode->mParent==mHeader)

			{

				tRootNode=tRightNode;

			}

			else if(inNewNode==inNewNode->mParent->mRight)

			{

				inNewNode->mParent->mRight=tRightNode;

			}

			else

			{

				inNewNode->mParent->mLeft=tRightNode;

			}

			inNewNode->mLeft=tRightNode->mRight;	//此句不可忘！与<<算法导论>>的不同

			tRightNode->mRight=inNewNode;

			inNewNode->mParent=tRightNode;

		}



	}

}
fjz13
关注
专栏目录
C++红黑树实现过程
09-15
在C++中实现红黑树，需要理解并遵循红黑树的五个性质： 1. 每个节点要么是红色，要么是黑色。 2. 根节点是黑色。 3. 所有叶子节点（NIL或空节点）是黑色。 4. 如果一个节点是红色，则它的两个子节点都是黑色。 5. ...
【C++详解】——红黑树
weixin_69519040的博客
06-26 1658
本文介绍了红黑树的概念、性质，详细解释了红黑树插入节点的过程。
c++——红黑树
Britney_dark的博客
11-13 4749
愿你终将与重要的人重逢！
【C++】---红黑树详解
最新发布
weixin_75128035的博客
08-14 994
为什么我们看似亲近，却貌合神离？
C++数据结构 —— 红黑树
weixin_59913110的博客
03-03 4822
enum Corlor //枚举颜色RED,BLACKtemplate //为了方便，使用K模型K _key;{}
C++红黑树(图文详解)
qq_42433334的博客
06-14 2497
添加链接描述
【C++】红黑树详解（附迭代器以及插入实现），适合初学者
jhao的博客
07-13 2504
红黑树的简单实现附有迭代器实现，代码都有详细解释，适合于初学者和想要理解STL map/set原理的朋友观看。
红黑树的实现C++代码
07-27
用C++代码实现了一个红黑树，大家可以一起学习学习，有问题也可以直接给我留言
红黑树的C++实现
01-24
红黑树是数据结构和算法领域中的一个重要概念，广泛应用于各种系统和库，如C++ STL中的`std::map`和`std::set`就是基于红黑树实现的。理解并能熟练应用红黑树，对于提升编程能力，尤其是处理复杂数据结构和算法问题...
C++简单实现红黑树的插入
06-06
总的来说，C++实现红黑树的插入操作涉及到对红黑树特性的深入理解、节点结构体的设计、颜色调整规则的编码以及旋转操作的实现。这是一项既挑战性又富有成就感的任务，能帮助开发者更好地掌握数据结构和算法。
C++:红黑树
zhang_si_hang的博客
08-21 1808
1.红黑树的概念红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。（最长的路径不超过最短路径的2倍，近似平衡）2.红黑树的性质1.每个结点不是红色就是黑色2.根节点是黑色的3. 如果一个节点是红色的，则它的两个孩子结点是黑色的(没有连续的红色节点)
【C++】红黑树
qq_62939852的博客
05-13 1022
使用枚举来记录红色与黑色，用_col表示当前节点颜色但是在构造函数中为什么默认是红色呢？为什么不能是黑色呢？
红黑树的模拟实现
qq_56663697的博客
02-28 688
文章目录红黑树的概念红黑树的性质红黑树节点的定义红黑树的插入操作按照二叉搜索的树规则插入新节点调整红黑树红黑树的验证红黑树与AVL树的比较 红黑树的概念 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。 红黑树的性质 每个结点不是红色就是黑色。 根节点是黑色的。 如果一个节点是红色的，则它的两个孩子结点是黑色的。 对于每个结点，从该结点到
【C++】红黑树（Red Black Tree）
knous
08-04 477
红黑树的一些操作
C++【红黑树】
芊樱烛渊的博客
11-05 1060
AVLTree：要求左右高度差不超过1红黑树：AVLTree过分严格，可能会导致过分的旋转，那能不能不要那么严格呢？需要达到的目的，最长路径不超过最短路径的二倍。也就是说，我们的AVLTree是严格平衡，我们的红黑树是不严格平衡，而是近似平衡结果：相对而言，插入同样的数据，AVL树的旋转更多，红黑树的旋转次数更少假设N是100w，AVL树为logN的高度，也就是大概20左右但是我们的红黑树的话，最短的高度大概是logN也就是20左右，最深的应该为2*logN，为40次左右。
【C++】-- 红黑树详解
局部变量和全局变量
09-06 1389
红黑树也是一种二叉搜索树，在每个结点上增加一个存储位，来表示该节点的颜色，节点要么是红色要么是黑色。满足以下性质： （1）每个结点不是红色就是黑色 （2）根节点是黑色的 （3）没有连续的红色节点 （4）每条路径上都包含相同数目的黑色节点
红黑树的详细实现(C++)
code_peak
10-08 6435
红黑树概念(concept) 树型结构主要用于搜索，一直是科学领域的重要演算法，当中探讨了树可能遇到的问题：树的成长可能偏向于一边，也就是不平衡现象。 二叉树是常见且广泛使用的一种树，面临其可能退化成链表的潜藏缺点，在使用上难免让人担心其效率。此外，在一些应用上，可能不希望这样的不平衡的可能性发生。所以具有自动平衡左右数量分布效果的演算算法早在 1962 年被提出，称为 AVL 树。这种平衡成长的二叉搜索树被称为自平衡二叉搜索树。 接下来，介绍同为自平衡二叉搜索树的红黑树对平衡性的要求比 AVL 树还要宽松
【数据结构】6.5 红黑树（C++）
weixin_52811588的博客
04-12 1042
红黑树是一颗近似平衡的二叉搜索树，它的使用非常广泛，所以在面试中经常是一个经典问题，现在让我们来一起学习吧
C++实现红黑树模板类
"这是一个C++实现的红黑树模板类，包含插入、删除和查找操作，以及旋转函数。" 红黑树是一种自平衡的二叉查找树（BST），它在进行插入和删除操作后能保持相对较好的平衡性，从而提供高效的查找、插入和删除性能。在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值