红黑树代码实现

最新推荐文章于 2023-07-04 13:45:42 发布
置顶 最新推荐文章于 2023-07-04 13:45:42 发布
阅读量210 收藏 1
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lpl312905509/article/details/103882721
版权

请对照红黑树原剖析一起看，如要问题，请各位大神不吝赐教

//网页测试工具   https://www.cs.usfca.edu/~galles/visualization/RedBlack.html


#include <assert.h>
#include <iostream>

using namespace  std;

#define RED		1
#define BLACK	2

template<typename T>
class Node
{
public:
	Node()
	{
	}
	inline operator T& ()
	{
		return data_;
	}

	T data_;
	int color_; //节点颜色
	Node<T>* left_; //左节点
	Node<T>* right_;//右节点
	Node<T>* parent_;//父节点
};

template <typename T>
class RBTree
{
public:
	RBTree()
	{
		tree_ = NULL;
//		count_ = 0;
	}

	virtual ~RBTree()
	{
		clear();
//		count_ = 0;
	}

	//清空AVLTree
	virtual void clear(Node<T>* node = NULL)
	{
		if (!node) node = tree_;

		if (!node) return;
		Node<T>* left = node->left_;
		Node<T>* right = node->right_;
		delete node;
		node = NULL;
		//这里还要去释放自己类内申请的内存
		{
			if (left)
				clear(left);
			if (right)
				clear(right);
		}
	}

	inline Node<T>* allocNode(const T& value)
	{
		Node<T>* newNode = new Node<T>;
		newNode->data_ = value;
		newNode->left_ = newNode->right_ = NULL;
		newNode->parent_ = NULL;
		setColor(newNode, RED);

		return newNode;
	}

	inline int height(Node<T>* node)
	{
		if (node == NULL)
		{
			return 0;
		}
		int rightheight = height(node->right_);
		int leftheight = height(node->left_);
		return rightheight > leftheight ? (rightheight + 1) : (leftheight + 1);
	}

	inline Node<T>* getUncleNode(Node<T>* node)
	{
		assert(node);

		if (node->parent_)
		{
			if (node->parent_->left_ == node)
				return node->parent_->right_;
			else
				return node->parent_->left_;
		}

		return NULL;
	}

	inline void setColor(Node<T>* node,int color)
	{
		assert(color == RED || color == BLACK);
		if (node)
			node->color_ = color;
	}

	//将节点右旋
	Node<T>* turnRight(Node<T>* node)
	{
		// 右旋使node的父节点的子节点替换为b
		Node<T>* b = node->left_;
		if (node->parent_ != NULL) {
			if (node->parent_->right_ == node)
			{
				node->parent_->right_ = b;
			}
			else
			{
				node->parent_->left_ = b;
			}
		}
		b->parent_ = node->parent_;
		//将b的右子树作为a的左子树，并将a作为b的右子树
		node->parent_ = b;
		node->left_ = b->right_;
		if (node->left_ != NULL)
			node->left_->parent_ = node;
		b->right_ = node;
		//返回b节点
		return b;
	}

	//将节点左旋
	Node<T>* turnLeft(Node<T>* node)
	{
		//左旋把node的父节点的子节点替换为b
		Node<T>* b = node->right_;
		if (node->parent_ != NULL) {
			if (node->parent_->right_ == node) {
				node->parent_->right_ = b;
			}
			else {
				node->parent_->left_ = b;
			}
		}
		b->parent_ = node->parent_;
		//将node作为b的左子树，并将b的左子树作为node的右子树
		node->parent_ = b;
		node->right_ = b->left_;
		b->left_ = node;
		if (node->right_ != NULL)
			node->right_->parent_ = node;
		//返回b节点
		return b;
	}

	//重新平衡node节点
	void insertRebalance(Node<T>* node, Node<T>* newNode)
	{
		if (!node) return;
		if (node->color_ == BLACK) //插入节点的父节点是黑节点
		{
			//不需要处理任何行为
		}
		else if (node->color_ == RED)//插入节点的父节点是红节点,必有祖父节点
		{
			Node<T>* uncleNode = getUncleNode(node);
			if (uncleNode && uncleNode->color_ == RED) //4.1
			{
				//处理：父节点、叔叔节点设为黑色 祖父节点设为红色
				
				setColor(node, BLACK);
				setColor(uncleNode, BLACK);
				if (node->parent_ != tree_)
				{
					setColor(node->parent_, RED);
				}
				insertRebalance(node->parent_->parent_, node->parent_);
			}
			//4.2
			else if ((!uncleNode || uncleNode->color_ == BLACK) && (node->parent_ && node->parent_->left_ && node->parent_->left_ == node))
			{
				if (node->left_ == newNode) //4.2.1
				{
					//处理：父节点设为黑色 将祖父节点设为红色 将祖父节点右旋
					setColor(node, BLACK);
					setColor(node->parent_, RED);
					turnRight(node->parent_);
				}
				else if (node->right_ == newNode)//4.2.2
				{
					//处理：将父节点左旋  插入节点设为黑色 祖父节点设为红色 对祖父节点左旋
					node = turnLeft(node);
					//得到4.2.1 进行4.2.1操作
					//						setColor(newNode, BLACK);
					//						setColor(newNode->parent_, RED);
					//						newNode->parent_ = turnRight(newNode->parent_);
					insertRebalance(node->parent_, node);
				}
			}
			//4.3
			else if ((!uncleNode || uncleNode->color_ == BLACK) && (node->parent_ && node->parent_->right_ && node->parent_->right_ == node))
			{
				if (node->right_ == newNode) //4.3.1
				{
					//处理:将父节点设为黑色 将祖父节点设为红色 对祖父节点左旋
					setColor(node, BLACK);
					setColor(node->parent_, RED);
					node = turnLeft(node->parent_);

					//						rebalance(turnLeft(node->parent_));
				}
				else if (node->left_ == newNode)//4.3.2
				{
					//处理：将父节点右旋  插入节点设为黑色 祖父节点设为红色 对祖父节点左旋
					node = turnRight(node);

					//得到4.3.1 进行4.3.1 操作
					//						setColor(newNode, BLACK);
					//						setColor(node->parent_, RED);
					//						node = turnLeft(node->parent_);
					insertRebalance(node->parent_, node);
				}
			}
		}
		else
		{
			assert(false);
		}

		//往上重新平衡

		if (node->parent_)
		{
//			rebalance(node->parent_,node);
		}
		else
		{
			tree_ = node;
		}
	}

	//replaceNode 替代节点 deleteNode 删除节点
	void deleteRebalance(Node<T>* replaceNode, Node<T>* deleteNode)
	{
		if (!replaceNode && !deleteNode) return;

		if (replaceNode->color_ == RED) //情景1
		{
			deleteNode->data_ = replaceNode->data_;

		}
		else if (replaceNode->color_ == BLACK) //必有兄弟节点
		{
			if (replaceNode->parent_->left_ == replaceNode)//2.1
			{
				Node<T>* replaceBrotherNode = replaceNode->parent_->right_; //替换节点的兄弟节点
				if (replaceBrotherNode->color_ == RED)//2.1.1 //必成立
				{
					replaceBrotherNode->color_ = BLACK;
					replaceNode->parent_->color_ = RED;
					Node<T>* node = turnLeft(replaceNode->parent_);
					if (!node->parent_) tree_ = node;
					deleteRebalance(replaceNode, replaceNode);
				}
				else if (replaceBrotherNode->color_ == BLACK) //2.1.2
				{
					if (replaceBrotherNode->right_ && replaceBrotherNode->right_->color_ == RED) //2.1.2.1
					{
						replaceBrotherNode->color_ = replaceBrotherNode->parent_->color_;
						replaceBrotherNode->right_->color_ = BLACK;
						replaceBrotherNode->parent_->color_ = BLACK;
						Node<T>* node = turnLeft(replaceBrotherNode->parent_);
						if (!node->parent_) tree_ = node;
					}
					else if((replaceBrotherNode->left_ && replaceBrotherNode->left_->color_ == RED) &&
						(!replaceBrotherNode->right_ || replaceBrotherNode->right_->color_ == BLACK))//2.1.2.2
					{
						replaceBrotherNode->color_ = RED;
						replaceBrotherNode->left_->color_ = BLACK;
						Node<T>* node = turnRight(replaceBrotherNode);
						if (!node->parent_) tree_ = node;
						deleteRebalance(replaceNode, replaceNode);
					}
					else if ((!replaceBrotherNode->left_ && !replaceBrotherNode->right_) ||
						(replaceBrotherNode->left_ && replaceBrotherNode->left_->color_ == BLACK
							&& replaceBrotherNode->right_ && replaceBrotherNode->right_->color_ == BLACK))//2.1.2.3
					{
						replaceBrotherNode->color_ = RED;
//						replaceBrotherNode->parent_->color_ = BLACK;
						deleteRebalance(replaceBrotherNode->parent_, replaceBrotherNode->parent_);
					}
				}
			}
			else if (replaceNode->parent_->right_ == replaceNode) //2.2
			{
				Node<T>* replaceBrotherNode = replaceNode->parent_->left_; //替换节点的兄弟节点
				if (replaceBrotherNode->color_ == RED)//2.2.1 //必成立
				{
					replaceBrotherNode->color_ = BLACK;
					replaceNode->parent_->color_ = RED;
					Node<T>* node = turnRight(replaceNode->parent_);
					if (!node->parent_) tree_ = node;
					deleteRebalance(replaceNode, replaceNode);
				}
				else if (replaceBrotherNode->color_ == BLACK) //2.2.2
				{
					if (replaceBrotherNode->left_ && replaceBrotherNode->left_->color_ == RED) //2.2.2.1
					{
						replaceBrotherNode->color_ = replaceBrotherNode->parent_->color_;
						replaceBrotherNode->left_->color_ = BLACK;
						replaceBrotherNode->parent_->color_ = BLACK;
						Node<T>* node = turnRight(replaceBrotherNode->parent_);
						if (!node->parent_) tree_ = node;
					}
					else if ((!replaceBrotherNode->left_ || replaceBrotherNode->left_->color_ == BLACK) &&
						(replaceBrotherNode->right_ && replaceBrotherNode->right_->color_ == RED))//2.2.2.2
					{
						replaceBrotherNode->color_ = RED;
						replaceBrotherNode->right_->color_ = BLACK;
						Node<T>* node = turnLeft(replaceBrotherNode);
						if (!node->parent_) tree_ = node;
						deleteRebalance(replaceNode, replaceNode);
					}
					else if ((!replaceBrotherNode->left_ && !replaceBrotherNode->right_) ||
						(replaceBrotherNode->left_ && replaceBrotherNode->left_->color_ == BLACK
							&& replaceBrotherNode->right_ && replaceBrotherNode->right_->color_ == BLACK))//2.2.2.3
					{
						replaceBrotherNode->color_ = RED;
						replaceBrotherNode->parent_->color_ = BLACK;
						//deleteRebalance(replaceBrotherNode->parent_, replaceBrotherNode->parent_);
					}
				}
			}
		}
	}

	//插入操作
	void insert(const T& value, Node<T>* root = NULL)
	{
		if (!root) root = tree_;

		Node<T>* node = select(value, root);

		if (node == NULL) //为空 代表tree为空
		{
			tree_ = allocNode(value);
			setColor(tree_, BLACK);
		}
		else if (node->data_ == value) //更新节点
		{
			tree_->data_ = value;
		}
		else if (node->data_ != value)
		{
			Node<T>* newNode = allocNode(value);
			newNode->parent_ = node;

			if (node->data_ > value) //新增节点比跟节点小 则查到根节点的左节点上
			{
				node->left_ = newNode;
			}
			else if (node->data_ < value)//新增节点比跟节点大 则查到根节点的右节点上
			{
				node->right_ = newNode;
			}

			insertRebalance(node,newNode);
		}
	}



	//查询操作 递归查询 未找到返回可以插入的根节点
	//const T& value 要查询的value
	//Node<T>* root 从哪个根节点开始查询 默认从根节点开始
	Node<T>* select(const T& value, Node<T>* root = NULL)
	{
		if (!root) root = tree_;

		if (!root) return NULL;

		if (root->data_ == value) //找到该节点
			return root;
		else if (root->data_ > value) //
		{
			if (root->left_)
				return select(value, root->left_); //继续到左子节点查询
			else
				return root; //返回根节点
		}
		else if (root->data_ < value)
		{
			if (root->right_)
				return select(value, root->right_); //继续到右子节点查询
			else
				return root;//返回根节点
		}

		return NULL;
	}

	//获取该根节点上最小的节点
	inline Node<T>* getmin(Node<T>* node)
	{
		if (node->left_)
			getmin(node->left_);
		else
			return node;
	}

	//删除节点  当该节点只有一个子节点或没有子节点
	void delnodeifhas1childornot(Node<T>* node)
	{
		if (!node) return;
		if (node->parent_ == NULL) //是根节点
		{
			tree_ = node->left_ ? node->left_ : node->right_;
			tree_->parent_ = NULL;
		}
		else
		{
			Node<T>* childNode = node->left_ ? node->left_ : node->right_;

			if (childNode)//有孩子节点
			{
				assert(childNode->color_ == RED); //该孩子节点颜色必是红色 那么node 必是黑色
				assert(node->color_ == BLACK);
				childNode->parent_ = node->parent_;
				childNode->color_ = BLACK;
			}
			else //如果没有孩子节点 
			{
				if (node->color_ == BLACK) //删除节点是黑色 需要自平衡
				{
					deleteRebalance(node, node);
				}
			}

			if (node->parent_->left_ == node)
			{
				node->parent_->left_ = childNode;
			}
			else
			{
				node->parent_->right_ = childNode;
			}

//			rebalance(node->parent_);
		}
		delete node;
		node = NULL;
	}

	void delnodeifhas2child(Node<T>* node)
	{
		Node<T>* after = getmin(node->right_);
		node->data_ = after->data_;
		delnodeifhas1childornot(after);
	}

	void del(const T& value)
	{
		Node<T>* node = select(value, tree_);
		if (node->data_ == value)
		{
			if (node->left_ && node->right_) 
			{
				delnodeifhas2child(node);
			}
			else
			{
				delnodeifhas1childornot(node);
			}
		}
	}


	//先序遍历
	void preOrderTraverse(Node<T> *root = NULL)
	{
//		if (!root) root = tree_;
		if (root)
		{
			printf("%d  ", root->data_);
			preOrderTraverse(root->left_);
			preOrderTraverse(root->right_);
		}
	}

	//中序遍历
	void midOrderTraverse(Node<T> *root = NULL)
	{
		if (root)
		{
			midOrderTraverse(root->left_);
			printf("%d  ", root->data_);
			midOrderTraverse(root->right_);
		}
	}

	//后序遍历
	void postOrderTraverse(Node<T> *root = NULL)
	{
		if (!root) root = tree_;
		if (root)
		{
			postOrderTraverse(root->left_);
			postOrderTraverse(root->right_);
			printf("%d  ", root->data_);
		}
	}

	Node<T>* getTree()
	{
		return tree_;
	}

private:
	Node<T>* tree_;  //AVL tree的树根
//	int count_;  //节点数

};

int main()
{
	{
		RBTree<int> rb;
		rb.insert(3);
		rb.insert(4);
		rb.insert(5);
		rb.insert(6);
		rb.insert(7);
		rb.insert(8);
		rb.insert(9);
		rb.insert(10);
		rb.insert(11);
		rb.insert(12);
		rb.insert(13);
		rb.del(3);
		rb.preOrderTraverse(rb.getTree());
		cout << endl;
		rb.midOrderTraverse(rb.getTree());
	}

	system("pause");
	return 0;
}
lpl312905509
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
1.常用数据结构-红黑树
Happy_wu的专栏
04-20 242
R-B Tree简介    R-B Tree，全称是Red-Black Tree，又称为“红黑树”，它一种特殊的二叉查找树。红黑树的每个节点上都有存储位表示节点的颜色，可以是红(Red)或黑(Black)。要想了解红黑树，不防先自己建一个红黑树：https://www.cs.usfca.edu/~galles/visualization/RedBlack.html红黑树的特性:（1）每个节点或者是...
红黑树动画在线演示网站
wwsprin_start的博客
06-17 3158
链接dihttps://www.cs.usfca.edu/~galles/visualization/RedBlack.html
一个红黑树生成网址
ada_ayah的专栏
01-25 3344
https://www.cs.usfca.edu/~galles/visualization/RedBlack.html
红黑树学习
思维缜密的博客
11-17 902
先推荐一个在线红黑树的网站https://www.cs.usfca.edu/~galles/visualization/RedBlack.html 在理解删除的时候帮了大忙 目录 节点定义 性质 平衡 插入 情景1：空树，插入完调整为黑色 情景2：已经key存在 情景3：插入的双亲是黑色的 情景4：插入的双亲是红色 4.1双亲节点是祖父节点的左孩子 4.1.1叔叔节点存在且...
红黑树视频 http://gauss.ececs.uc.edu/RedBlack/redblack.html
诺尔曼
12-08 1563
http://gauss.ececs.uc.edu/RedBlack/redblack.html 红黑树视频
红黑树代码
zhaojinjia的专栏
10-29 1271
为了能更好的理解红黑树，我把我写的关于红黑树代码放在博客里，如果有什么问题，欢迎大家留言，谢谢  定义一个结点部分 enum COLOR{RED, BLACK}; class CRB_Node { public: CRB_Node(void); CRB_Node(const int item, CRB_Node * lch,CRB_Node * rch, CRB_Node *par
红黑树定义及其代码实现
公众号：风景邮递Yuan的博客
06-16 746
红黑树是一种自平衡二叉查找树，它在每个节点上增加了一个存储位来表示节点的颜色，可以是红色或黑色。通过对任何一条从根到叶子节点的路径上各个节点的颜色进行约束，红黑树确保没有一条路径会比其他路径长出两倍，因此，红黑树是近似平衡的。5. 对于每个节点，从该节点到其所有后代叶子节点的简单路径上，均包含相同数目的黑色节点。4. 如果一个节点是红色的，则它的两个子节点都是黑色的。3. 每个叶子节点（NIL节点，空节点）是黑色的。1. 每个节点要么是红色，要么是黑色。2. 根节点是黑色的。
红黑树的原理及代码实现
qq_52093121的博客
06-28 982
红黑树的原理这篇博文讲解的很详细了，不熟悉红黑树的定义可以看看：红黑树的详细原理讲解咱们直接进入代码实现讲解：创建一棵红黑树，先从创建红黑树的节点开始： 1.红黑树首先是一个二叉树，所以需要一个左儿子节点的指针，右儿子节点的指针 2.红黑树是有BALCK和RED两种颜色的，所以每个节点应该有颜色 3.红黑树是Key-Value存储的 4.因为之后要进行旋转等调整，所以还需要一个父节点的信息 所以红黑树节点定义如下： 2.创建红黑树整体结构 红黑树有五个性质： 为了方便整棵红黑树的维护，我们默认叶子节点是空
红黑树（图文详解+C语言200行代码实现）
zhao_Tao_WA的博客
07-04 2756
本文以图文形式详细介绍了红黑树的性质以及各种调整策略，包括插入调整和删除调整，最后以200行精简的C语言代码实现了红黑树
RedBlackBinaryTree.html
05-04
可以可视化模拟红黑树。可以一次性全部插入，一个一个插入。双击删除。每一个数必须是三位数以内，用单字节英文,逗号隔开。
红黑树实现代码+详细注释
ltrbless的博客
05-19 1549
简介 因为网上太多红黑树原理的讲解了，不需要再去讲解原理，所以在这就提供一些将原理不错的博客，然后主要是给红黑树代码的实现，用的c++语言模板实现红黑树，并附带详细注释。（目前只实现了红黑树的插入与查询操作，并可视化打印红黑树）。 红黑树插入操作的流程图：（参考：红黑树总结 - lukazan - 博客园 (cnblogs.com)，该博客用图详细解释了红黑树插入操作的事件，然后我用红色对其事件进行了编号，以便于和代码注释相对应） 红黑树的本质其实就是2-3树，在上面推荐的博客中也有提到。 代码
红黑树原理详解及代码实现
CodePanda@GPF的博客
05-23 2635
红黑树原理及代码实践
红黑树 图文详解与代码实现
qq_54831038的博客
09-01 995
红黑树被应用于数据结构map/set的封装的底层，也应用于Linux的数据内核，在进程调度CFS，虚拟内存管理，共享内存slab等场景都有广泛应用。数据结构的角度看，（1）用于存储。无论数据是否平衡都可以在O（logN)的复杂度下完成 搜索、插入、删除操作。（2）用于排序。找到最小值和最大值红黑树黑色和红色 也可看成两种状态，红黑区分的状态中，可以根据实际需求添加业务逻辑。......
红黑树内容及代码实现
m0_56821563的博客
07-02 339
本篇博客讲述了数据结构中红黑树的概念，并给出C++的实现。
C++实现红黑树（含完整代码+图）
weixin_44628585的博客
08-09 2248
此文主要记录红黑树的操作，即节点的添加删除操作，并且有完整代码可供学习。欢迎大家阅读，如有问题，麻烦大家指出。
补档：红黑树代码实现+简略讲解
to_upper的博客
03-02 569
红黑树
11.1红黑树的复习
pc的博客
02-07 165
红黑树产生的原因： 之前我们学习过二叉查找树,大部分情况下,发现它的查询效率比单纯的链表和数组的查询效率要高很多(二叉查找树相当于二分查找) 但如果按顺序插入的9,8,7,6,5,4,3,2,1 会发现二叉树变成链表样子，如果我们要查找1这个元素，查找的效率依旧会很低 效率低的原因在于这个树并不平衡，为了保证查找树的平衡性，引入2-3路平衡查找树与红黑树 但2-3查找树实现起来比较复杂，而且添加数据或删除数据的时候，为维护平衡问题可能会使得效率降低，所以引入红黑树 红黑树主要是对2-3树进行编码，红黑树
Java红黑树代码实现
最新发布
09-08
下面是一个简单的Java红黑树代码实现示例： ```java // 定义红黑树节点 class Node { int data; // 节点数据 Node left; // 左子节点 Node right; // 右子节点 Node parent; // 父节点 boolean isRed; // 是否...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值