C++ 写一颗红黑树 代码

最新推荐文章于 2025-02-23 10:39:53 发布
最新推荐文章于 2025-02-23 10:39:53 发布
阅读量448 收藏 7
点赞数 1
分类专栏： STL 文章标签： 数据结构 二叉树 算法 stl c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_24447809/article/details/111661534
版权

红黑树代码

#pragma once

const bool rb_red = false;
const bool rb_black = true;

class  node {
public:
	node(int n, bool color_type = true) :val(n), color(color_type), left(nullptr), right(nullptr), parent(nullptr) {};
	int val;
	node* left;
	node* right;
	node* parent;
	bool color;
};

template<typename T>
class rbtree
{
public:
	rbtree(node* _root = nullptr) :root(_root) {};
	void insert(T x);
	node* get_root() { return root; }
	node* predecessor(node* p);
	node* successor(node* p);
	void remove(T x);  //删除节点
	node* get_node(T x);		//根据键值找节点
private:
	
	void left_rotate(node* p);
	void fix_after_insert(node* p);
	void right_rotate(node* p);
	void fix_after_remove(node* p);
	bool get_color(node* p);
	node* root;
};
template<typename T>
bool rbtree<T>::get_color(node* p)
{
	if (p == nullptr)
		return rb_black;	//空节点默认黑色
	else
		return p->color;
}

/*寻找后继节点,即大于p->val的最小值*/
template<typename T>
node* rbtree<T>::successor(node* p)
{
	if (p == nullptr)
		return nullptr;
	else if (p->right)	//右节点都是大于p的
	{
		node* rbnode = p->right;
		while (rbnode->left)	//往左手边找小值
		{
			rbnode = rbnode->left;
		}
		return rbnode;		//后继节点一定没有左子树
	}
	else    //子节点没有小值，考虑往父节点方向找，删除操作时不执行此步
	{
		node* parent_node = p->parent;
		node* child_node = p;
		while (parent_node != nullptr && child_node == parent_node->right)
		{
			child_node = parent_node;
			parent_node = parent_node->parent;
		}
		return parent_node;
	}

}


/*寻找前驱节点,即小于p->val的最大值*/
template<typename T>
node* rbtree<T>::predecessor(node* p)
{
	if (p == nullptr)
		return nullptr;
	else if (p->left)		//左节点都是小于p的
	{
		node* rbnode = p->left;
		while (rbnode->right)	//往右手边找大值
		{
			rbnode = rbnode->right;
		}
		return rbnode;
	}
	else  //子节点没有小值，考虑往父节点方向找，删除操作时不执行此步
	{
		node* parent_node = p->parent;
		node* child_node = p;
		while (parent_node!=nullptr&& child_node == parent_node->left)
		{
			child_node = parent_node;
			parent_node = parent_node->parent;
		}
		return parent_node;
	}
}

/*删除节点
1.叶子节点直接删除。
2.只有一个子节点，子节点直接代替。
3.有两个子节点的话，需要找到前驱节点或者后继节点。
本函数采用后继节点方式
*/
template<typename T>
void rbtree<T>::remove(T x)
{
	node* delet_node = get_node(x);	//找到键值对应节点
	if (delet_node == nullptr)
		return;

	if (delet_node->left != nullptr && delet_node->right != nullptr)	//3.有两个子节点的话，需要找到前驱节点或者后继节点
	{
		node* successor_node = successor(delet_node);   //找后继节点
		delet_node->val = successor_node->val;		//相当于后继节点替代删除节点，不会破坏搜索树的结构
		delet_node = successor_node;				//现在情况变为删除后继节点，注意后继节点没有左子树
	}
	node* replace_node = delet_node->left != nullptr ? delet_node->left : delet_node->right;	//找替代节点

	if (replace_node != nullptr)
	{
		//替代节点认爹
		replace_node->parent = delet_node->parent;
		if (delet_node->parent == nullptr)	      //删除的是有一个子节点的根节点，注意，两个子节点的情况经上面处理后会变成后继节点
		{
			root = replace_node;
		}
		else if (delet_node == delet_node->parent->left)	//替代到左子树位置上，爹找儿子
		{
			delet_node->parent->left = replace_node;
		}
		else if(delet_node == delet_node->parent->right)   //替代到右子树位置上
		{
			delet_node->parent->right = replace_node;
		}
		
		//结构发生变化，需要重新调整树
		if (delet_node->color == rb_black)	//删除黑色节点才需要调整
		{
			fix_after_remove(replace_node);		//替代节点一定是红色
		}
		delet_node->left = delet_node->right = delet_node->parent = nullptr;	//删除节点变为游离节点
		//delete delet_node;
		
	}
	else if (delet_node->parent == nullptr)		//删除的是孤独的根节点
	{
		this->root = nullptr;
	}
	else	//删除的是叶子节点
	{
		if (delet_node->color == rb_black)		//删除黑色节点才需要调整
		{
			fix_after_remove(delet_node);
		}

		if (delet_node == delet_node->parent->left)		//父节点失去左儿子
		{
			delet_node->parent->left = nullptr;
		}
		else if(delet_node == delet_node->parent->right)
		{
			delet_node->parent->right = nullptr;		//父节点失去右儿子
		}
		delet_node->parent = nullptr;
	}


}


/*根据键值找节点*/
template<typename T>
node* rbtree<T>::get_node(T x)
{
	node* rb_node = this->root;
	while (rb_node != nullptr)
	{
		if (x < rb_node->val)
			rb_node = rb_node->left;
		else if (x > rb_node->val)
			rb_node = rb_node->right;
		else
			return rb_node;
	}
	return nullptr;
}


/*二叉树调整变色*/
template<typename T>
void rbtree<T>::fix_after_insert(node* t)
{
	t->color = rb_red;
	//父节点是黑色就不用考虑调整
	while (t != root && t->parent->color == rb_red)	//父节点是红色节点就一直调整
	{
		node* parent_ptr = t->parent;
		if (t->parent == parent_ptr->parent->left)  //父节点是爷爷的左子节点,左边有3个节点（包括爷爷）情况
		{
			node* uncle_node = parent_ptr->parent->right;
			bool uncle_color = (uncle_node == nullptr ? rb_black : uncle_node->color);   //叔叔节点为空时默认为黑色节点
			if (uncle_color == rb_red)
				//叔叔节点为红色，说明新插入的元素合并了2-3-4树的4-节点，此时元素插入位置上方是一黑（爷爷节点）和两红（父亲和叔叔）结构
				//此时新插入元素和父亲节点构成了连续的两个红色节点，需要调整颜色
			{
				parent_ptr->color = rb_black;
				uncle_node->color = rb_black;	//叔叔和父亲变黑
				parent_ptr->parent->color = rb_red;	//爷爷变红
				t = parent_ptr->parent;
				//递归操作，t变为爷爷节点，再while判断爷爷节点的父节点是否是红色，如果是红色就继续调整

			}
			else    //叔叔节点为黑色，说明新插入的元素合并了2-3-4树的3-节点
			{
				if (t == parent_ptr->right)		//新插入元素在父节点右侧，需要调整成3节点左倾结构
				{
					t = parent_ptr;
					left_rotate(t);	//原来父亲节点左旋，t左旋完重新变成子节点
				}
				t->parent->color = rb_black;	//父亲变黑
				t->parent->parent->color = rb_red;		//爷爷变红
				right_rotate(t->parent->parent);	//爷爷节点右旋

			}
		}
		else	//父节点是爷爷的右子节点,右边有3个节点（包括爷爷）情况
		{
			node* uncle_node = parent_ptr->parent->left;
			bool uncle_color = (uncle_node == nullptr ? rb_black : uncle_node->color);   //叔叔节点为空时默认为黑色节点
			if (uncle_color == rb_red)
				//叔叔节点为红色，说明新插入的元素合并了2-3-4树的4-节点，此时元素插入位置上方是一黑（爷爷节点在上面）和两红（父亲和叔叔）结构
				//此时新插入元素和父亲节点构成了连续的两个红色节点，需要调整颜色
			{
				parent_ptr->color = rb_black;
				uncle_node->color = rb_black;	//叔叔和父亲变黑
				parent_ptr->parent->color = rb_red;	//爷爷变红
				t = parent_ptr->parent;
				//递归操作，t变为爷爷节点，再while判断爷爷节点的父节点是否是红色，如果是红色就继续调整
			}
			else    //叔叔节点为黑色，说明新插入的元素合并了2-3-4树的3-节点
			{
				if (t == parent_ptr->left)		//新插入元素在父节点右侧，需要调整成3节点右倾结构
				{
					t = parent_ptr;
					right_rotate(t);		//原来父亲节点右旋，t右旋完重新变成子节点
				}
				t->parent->color = rb_black;	//父亲变黑
				t->parent->parent->color = rb_red;		//爷爷变红
				left_rotate(t->parent->parent);	//爷爷节点左旋
			}
		}
	}
	root->color = rb_black;		//保证根节点是黑色
}


/*删除后调整树的位置*/
template<typename T>
void rbtree<T>::fix_after_remove(node* p)
{
	while (p!=root && p->color == rb_black)		//黑色叶子节点删除进入此处
	{
		if (p == p->parent->left)	//p在左子树
		{
			node* brother_node = p->parent->right;	//兄弟节点，不一定是2-3-4树中真正和p在同一层的兄弟节点
			if (brother_node->color == rb_red)		//判断是否是真正的兄弟节点
			{
				brother_node->color = rb_black;			//变色
				p->parent->color = rb_red;
				left_rotate(p->parent);
				brother_node = p->parent->right;	//此时找到在2-3-4树中真正和p在同一层的兄弟节点

			}

			//找兄弟节点借，兄弟没得借
			if (get_color(brother_node->left)==rb_black && get_color(brother_node->right)==rb_black)	//注意空节点默认黑色
			{
				brother_node->color = rb_red;		//兄弟节点变红来平衡这一层的黑节点平衡
				p = p->parent;	//在while循环中向上递归
			}

			//找兄弟节点借，兄弟有得借
			//操作就是把父节点拉下来到删除位置，从兄弟节点中借一个节点喜当爹
			else
			{
				//分两种情况，兄弟节点是3-节点或者4-节点的情况

				if (brother_node->right->color == rb_black)	//3-节点情况，要借的节点在兄弟节点左边
				{
					brother_node->color = rb_red;
					brother_node->left->color = rb_black;
					right_rotate(brother_node);		//右旋，把要借的节点拉上来成为新的兄弟节点
					brother_node = p->parent->right;	//新的兄弟节点
				}
				brother_node->color = brother_node->parent->color;	//变为父亲节点颜色，主要考虑父节点为红色情况
				brother_node->parent->color = rb_black;		//父节点变黑
				brother_node->right->color = rb_black;
				left_rotate(p->parent);
				p = root;		//结束循环
			}

		}
		else		//p在右子树
		{
			node* brother_node = p->parent->left;	//兄弟节点，不一定是2-3-4树中真正和p在同一层的兄弟节点
			if (brother_node->color == rb_red)		//判断是否是真正的兄弟节点
			{
				brother_node->color = rb_black;			//变色
				p->parent->color = rb_red;
				right_rotate(p->parent);
				brother_node = p->parent->left;	//此时找到在2-3-4树中真正和p在同一层的兄弟节点

			}

			//找兄弟节点借，兄弟没得借
			if (get_color(brother_node->left) == rb_black && get_color(brother_node->right) == rb_black)	//注意空节点默认黑色
			{
				brother_node->color = rb_red;		//兄弟节点变红来平衡这一层的黑节点平衡
				p = p->parent;	//在while循环中向上递归
			}

			//找兄弟节点借，兄弟有得借
			//操作就是把父节点拉下来到删除位置，从兄弟节点中借一个节点喜当爹
			else
			{
				//分两种情况，兄弟节点是3-节点或者4-节点的情况

				if (brother_node->left->color == rb_black)	//3-节点情况，要借的节点在兄弟节点左边
				{
					brother_node->color = rb_red;
					brother_node->right->color = rb_black;
					left_rotate(brother_node);		//右旋，把要借的节点拉上来成为新的兄弟节点
					brother_node = p->parent->left;	//新的兄弟节点
				}
				brother_node->color = brother_node->parent->color;	//变为父亲节点颜色，主要考虑父节点为红色情况
				brother_node->parent->color = rb_black;		//父节点变黑
				brother_node->left->color = rb_black;
				right_rotate(p->parent);
				p = root;		//结束循环
			}
		}
	}
	p->color=rb_black;	//补偿删除的黑色节点
	
}



/*插入元数*/
template<typename T>
void rbtree<T>::insert(T x)
{
	//没有元素的话直接插入
	if (this->root == nullptr)
	{
		this->root = new node(x, rb_black);
		this->root->parent = nullptr;
		return;
	}
	bool left_or_right;		//记录插入在左还是右位置
	node* parent = root;
	node* t = root;
	while (t != nullptr)
	{
		parent = t;	//保存父节点位置
		if (x > t->val)
		{
			t = t->right;
			left_or_right = 0;
		}
			
		else if (x < t->val)
		{
			t = t->left;
			left_or_right = 1;	
		}	
		else
			return;  //相同元素返回
	}
	t = new node(x, rb_red);	//到达叶子节点，new节点
	if (left_or_right)		//左边插入
		parent->left = t;
	else					//右边插入
		parent->right = t;
	t->parent = parent;

	//插入之后调整树，旋转和变色
	fix_after_insert(t);
}

/*左旋*/
template<typename T>
void rbtree<T>::left_rotate(node* p)
{
	node* rbnode = p->right;
	rbnode->parent = p->parent;
	p->right = rbnode->left;
	if (rbnode->left != nullptr)
		rbnode->left->parent = p;
	if (p == root)
		root = rbnode;
	else if (p == p->parent->left)
		p->parent->left = rbnode;
	else if (p == p->parent->right)
		p->parent->right = rbnode;
	rbnode->left = p;
	p->parent = rbnode;
}


/*右旋*/
template<typename T>
void rbtree<T>::right_rotate(node* p)
{
	node* rbnode = p->left;
	rbnode->parent = p->parent;
	p->left = rbnode->right;
	if (rbnode->right != nullptr)
		rbnode->right->parent = p;
	if (p == root)
		root = rbnode;
	else if (p == p->parent->left)
		p->parent->left = rbnode;
	else
		p->parent->right = rbnode;
	rbnode->right = p;
	p->parent = rbnode;
}

测试函数（插入）

#include<iostream>
#include<queue>
#include"rbtree.h"
#include<string>
using namespace std;

string to_rb_color(bool color_type)
{
	if (color_type)
		return "<黑>";
	else
		return "<红>";
}

//  ************* 输出图形二叉树 *************
void output_impl(node* n, bool left, string const& indent)
{
	if (n->right)
	{
		output_impl(n->right, false, indent + (left ? "|     " : "      "));
	}
	cout << indent;
	cout << (left ? '\\' : '/');
	cout << "-----";
	cout << n->val << to_rb_color(n->color) << endl;
	if (n->left)
	{
		output_impl(n->left, true, indent + (left ? "      " : "|     "));
	}
}
void output(node* root)
{
	if (root == nullptr)
		return;
	if (root->right)
	{
		output_impl(root->right, false, "");
	}
	cout << root->val << to_rb_color(root->color)<< endl;
	if (root->left)
	{
		output_impl(root->left, true, "");
	}
	}
//  ***************************************

int main()
{
	rbtree<int> tree;
	int n = 20;
	int x = 1;
	while (n--)
	{
		tree.insert(x);
		x += 2;
	}
	output(tree.get_root());

	return 0;
}

测试结果（插入）

在这里插入图片描述

测试函数（删除）

int main()
{
	rbtree<int> tree;
	int n = 20;
	int x = 1;
	while (n--)
	{
		tree.insert(x);
		x += 2;
	}
	
	tree.remove(15);
	tree.remove(7);
	tree.remove(29);
	output(tree.get_root());
	return 0;
}

测试结果（删除）

在这里插入图片描述

[C++]——红黑树（附源码）
麦麦的博客
10-28 3947
本文为大家进行了红黑树的讲解，关于其定义、性质以及如何插入等等
C++高阶：红黑树实现
2301_81699364的博客
10-20 1001
分析：因为p和u都是红色，g是黑色，把p和u变黑，左边子树路径各增加⼀个黑色结点，g再变红，相 当于保持g所在子树的黑色结点的数量不变，同时解决了c和p连续红色结点的问题，需要继续往上更新是因为，g是红色，如果g的父亲还是红色，那么就还需要继续处理；u不存在，则c一定是新增结点，u存在且为黑，则c一定不是新增，c之前是黑色的，是在c的子树中插入，符合情况1，变色将c从黑色变成红色，更新上来的。分析：p必须变黑，才能解决，连续红色结点的问题，u不存在或者是黑色的，这里单纯的变色无法解决问题，需要旋转+变色。
红黑树精短C++代码
04-13
红黑树实现前去后继排名的查询，代码经过精心简短，题目测试参考洛谷
【C++】 ——红黑树C++完整代码
Vicky_Cr的博客
04-13 345
红黑树完整代码 #pragma once #include <iostream> using namespace std; enum Colour { BLACK, RED, }; template <class T> struct RBTreeNode { RBTreeNode<T>* _left; RBTreeNode<T>* _ri...
C++——红黑树
最新发布
曾几何时的博客
02-23 305
与AVL树相同的使用三叉链表实现，多了一个枚举类型的成员，用来表示每个结点的红黑颜色。
C++ 红黑树
weixin_53946312的博客
01-28 1648
红黑树
C++:红黑树
zhang_si_hang的博客
08-21 2047
1.红黑树的概念红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。（最长的路径不超过最短路径的2倍，近似平衡）2.红黑树的性质1.每个结点不是红色就是黑色2.根节点是黑色的3. 如果一个节点是红色的，则它的两个孩子结点是黑色的(没有连续的红色节点)
C++实现红黑树（含完整代码+图）
weixin_44628585的博客
08-09 2729
此文主要记录红黑树的操作，即节点的添加删除操作，并且有完整代码可供学习。欢迎大家阅读，如有问题，麻烦大家指出。
使用C++写一颗红黑树
08-09
在实现删除函数时，需要首先找到要删除的节点，并根据它的子节点情况进行相应的操作，以保证删除后的树仍然是一颗红黑树。 在搜索函数中，可以利用红黑树的特性，在树中进行二分查找来提高搜索的效率。 除了基本的...
【C++】红黑树
春风不语。
10-17 1549
本篇内容到这里就结束了，主要讲了红黑树的定义以及插入接口的实现逻辑，希望对大家有所帮助，祝生活愉快，下篇再见！
C++中红黑树的实现
CSQCSQCC的博客
10-26 1382
/如果为空树，插入的节点作为根//根必须为黑色//找到空位置else//插入节点//插入一个红色的节点else//如果出现连续的红色节点进入下列循环if (parent == grandfather->_left) //如果叔叔节点在右边//变色//继续向上更新else //叔叔不存在或者存在且为黑色if (cur == parent->_left) //插入到p的左边。
红黑树C++代码实现
01-21
描述： 实现红黑树、二叉搜索树相关算法：插入（红黑树涉及树的调整：左旋右旋等），删除，搜索（指定Key值节点）。 另外，红黑树实现计算树黑高的算法。 1).插入测试，输入 8，11，17，15，6，1，22，25，27，建立红黑树，按照 红黑树信息输出方式 输出整棵红黑树以及黑高。 2).删除测试，删除1）中红黑树中Key=15的节点，按照 红黑树信息输出方式 输出调整后的整棵红黑树以及黑高。 3).随机产生300,000个不同自然数Key值（1－300,000），建立红黑树，查找Key=15000的节点，输出查找花费时间。 随机产生300,000个不同自然数Key值（1－300,000），建立二叉搜索树，查找Key=15000的节点，输出查找花费时间。 4). 重复3－5次3）中操作，求各自平均时间。 5). 在1)－4)的红黑树算法基础上修改完成P307 14.1-4算法 OS_Key_Rank(T,k). 输入 1,2,3,4,5,6,7,8 建树， k=6, 输出OS_Key_Rank的返回值。 详细信息看readme!
红黑树代码
03-30
红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树红黑树
红黑树C++实现
01-27
红黑树的C++完整实现代码
红黑树的C++实现
05-13
红黑树（Red Black Tree） 是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。 它是在1972年由Rudolf Bayer发明的，当时被称为平衡二叉B树（symmetric binary B-trees）。后来，在1978年被 Leo J. Guibas 和 Robert Sedgewick 修改为如今的“红黑树”。
算法导论 红黑树的C++代码实现
sinat_24520925的专栏
12-16 658
红黑树为满足下列五个条件的特殊二叉树 每个结点要么是红的要么是黑的。  根结点是黑的。  每个叶结点（叶结点即指树尾端NIL指针或NULL结点）都是黑的。  如果一个结点是红的，那么它的两个儿子都是黑的。   对于任意结点而言，其到叶结点树尾端NIL指针的每条路径都包含相同数目的黑结点。 本文代码根据算法导论上的伪代码编写，按照先序、中序、后序输出。可直接运行，如有错误，欢迎大家指正~~~
【红黑树】的详细实现(C++)附代码
Linuxhus的博客
02-02 2423
红黑树的介绍 红黑树(Red-Black Tree，简称R-B Tree)，它一种特殊的二叉查找树。 红黑树是特殊的二叉查找树，意味着它满足二叉查找树的特征：任意一个节点所包含的键值，大于等于左孩子的键值，小于等于右孩子的键值。 除了具备该特性之外，红黑树还包括许多额外的信息。红黑树的每个节点上都有存储位表示节点的颜色，颜色是红(Red)或黑(Black)。 红黑树一棵在每个结点上增加了一个存储位来表示结点颜色（红色RED或黑色BLACK）的二叉搜索树。 二叉搜索树简单的说就是：对树中任何结点x，其左
C++实现红黑树
hdsHDS6的博客
06-28 1828
C++实现红黑树，插入和删除思路
红黑树的C++代码实现
yantingtao_sunny的博客
04-24 1102
#include #include using namespace std; #define BLACK 0 #define RED 1 template class my_rbtree;//前置声明 /* 类名:my_rbnode(红黑树节点) */ template class my_rbnode { friend class my_rbtree;//友元 public:
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值