C++实现红黑树核心插入实例代码

一、红黑树概念介绍

概念：

红黑树，也是一种二叉搜索树，它是在每个结点上增加一个存储位表示结点的颜色，可以是红或黑，然后通过对任何一条从根到叶子的路径上各个结点着色方式的限制，保证了没有一条路径会能超过其他路径的俩倍，因而是近似平衡的。map和set的底层数据结构就是用红黑树来封装的。

性质：

1.根节点是黑色的

2.不能出现连续的红色节点

3. 每条路径上有相同数量的黑色节点

4. 每个叶子(空节点)结点都是黑色

5. 每个结点不是红色就是黑色

满足上面的性质，红黑树就能保证：最长路径中节点个数不会超过最短路径节点个数的2倍。

优势：

假设全部的黑色节点有N个最短路径长度是logN 整棵树的节点数量：[N,2N]，最长路径长度：2logN。假设10亿个节点，AVL：最多查找30次左右；RB：最多查找60次左右。

综合而言，其实对于查找大量数据30次和60次没太大差别，而红黑树不要求绝对平衡，只需保证最长路径不超过最短路径的2倍，相对来说降低了插入和旋转的次数，所以在经常进行增删的结构中性能比AVL树更优。

二、红黑树模拟实现

（1）红黑树节点

enum Color
{
	RED=0,
	BLACK,
};
template<class K,class V>
struct RbTreeNode
{
	RbTreeNode<K, V>* _left;
	RbTreeNode<K, V>* _right;
	RbTreeNode<K, V>* _parent;
	pair<K, V>_kv;
	Color _col;
	RbTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _kv(kv)
		, _col(RED)
	{}
};

里面同样用三叉链，要有左孩子右孩子，父节点，以及pair类的类型来存储kv两个相同或不同类型的值(当我们使用make_pair函数创建一个pair对象，该函数会自动推断参数类型)，并在里面增加一个枚举，用来表示一个节点不是红色就是黑色。关于构造函数里面的颜色初始化为黑色还是红色，在插入会讲解。

（2）红黑树插入分析(核心)

插入和前面的AVL插入部分是一样的，在里面如果是根节点，那就把跟点为置为黑色。

那这有一个问题就是节点构造函数里面的一个问题：我们在申请一个新节点时，宁愿新增红色还是黑色？

因为不管是增哪种颜色，本质上是违反规则三还是违反规则四的问题，如果插入黑色，一定违反规则四，但它代价太大，违反规则三就不一定，因为它的父节点可能为红色也可能为黑色，如果在黑色节点下面插入就没影响，反之就会影响。

对于上面的做法会出现下面的两大情况，第一GPC为一一条直线，第二GPC为折线。

如图：

C++实现红黑树核心插入实例代码

G为祖父节点，P为父亲节点，C为当前节点，U为叔父节点

1、先解决当GPC为一条直线的时候：

（1）如果U存在且为红色，P必须变黑，U也得变黑，左右都增加了黑，那就把G变红,这样久能保持黑色节点不变，因为G现在变成红了，但是G的父节点如果是红色的还得继续处理，那就把G当成C节点，继续算它的祖父，再看U，如果U是红再把它变成黑。

C++实现红黑树核心插入实例代码

它的所对应的抽象图以及具象图：

C++实现红黑树核心插入实例代码

（2）如果U不存在或者存在且为黑又是两种情况

如果U不存在，再增加红节点，且有连续的红色节点，有可能会超过它的最短路径，只能旋转来降高度。把P变黑，把G给P的左，再把P作为左，同时把原来的G变红，这里就是左单旋加G和P变色。
如下例图：

C++实现红黑树核心插入实例代码

它所对应的抽象及具象图：

C++实现红黑树核心插入实例代码

如果U存在且为黑色

U存在且为黑是由第一种请况变化而来，这里发生了右单旋，P的左孩子作为G的左孩子，而G又作为P的右孩子，且P变为黑，G变为红。

C++实现红黑树核心插入实例代码

对于上面的U不存在或者存在为黑两种情况进行总结： P为G的左孩子时，C为P的左孩子进行右单旋转，如果P为G的右孩子，C为P的右孩子，进行左单旋转。P变为黑色，G变为红色。

旋转的目的就是为了防止最长路径超过最短路径的2倍。GPC为一条线的时候就是左单旋转或右单旋。

2、再解决GPC为折线的情况

（1）U存在且为黑

出现这种折线情况的原因是由第一种情况先变色而产生，然后p变成g的左，c变成p的右，c为红，p为红，g为黑，接着我们先以p为轴进行左旋转进行降低高度，在以g为轴进行右旋，且g变红，c变黑，因为这样才能保证不出现连续红结点且保证每个路径黑色数量一样。以上实际进行了双旋。

C++实现红黑树核心插入实例代码

（2）U不存在，直接右单旋

（3）插入代码思路(如何快速写插入算法)

C++实现红黑树核心插入实例代码

（一）先看左面这种大情况

插入C1肯定为红节点，P1如果是红，就需要开始作处理：先利用三叉链，从P1得出G1，进入核心环节：左面的这种情况是P1是G1的左孩子时，里面又要有分两种情况：

（1）如果是U存在且为红，我们把P1和U变为黑，G1变为红，更新C1到G1的位置，继续往上调整；

（2）如果是U不存在或黑(是一种情况)，如果U不存在就不能变黑，而且就算存在为黑说明是一定是由继续往上调整的那一步(情况(1))而来的即继续往上处理，我们还是是增加了节点，就可能导致最长路径超过最短路径的2倍或者一直用情况(1)的方式最终导致每条路径黑色数量不相等。这时候我们就要通过旋转方式降低高度加变色来解决。所以在这里又分两种：G1P1C1为直线和G1P1C1为折线：

如果是C1P1在一条直线上即C1是P1的左孩子，我们以G1为轴进行右单旋(哪边高往哪边降)，G1要变红，P1要变成黑，因为G1下来了P1作为根，不能出现连续的红节点P要变黑，又因为保证黑色数量相等，G1要变红。如果是C1和P1，G1是折线的时候即C1是P1的右孩子，这时候需要先以P1为轴进行左单旋，再以G1为轴进行右单旋，最终C1做了根节点，G1是右孩子，因为P1是红，C1是红不能出现连续红节点，需把C1变黑，但是还要保证黑色数量相等，就把G1变红。最后结束break，只有情况(1)才会继续向上来回处理。

（二）再看右面这种大情况

和（一）情况类似

P2是G2的右孩子，同理那旋转方式就根上面相反。

所以我们的插入函数：

bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}
		cur = new Node(kv);
		if (parent->_kv.first > kv.first)
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}
		cur->_parent = parent;
		while (parent && parent->_col == RED)
		{
			Node* grandf = parent->_parent;
			if (grandf->_left == parent)
			{
				Node* unc = grandf->_right;
				if (unc && unc->_col == RED)//u存在且为红，变色处理
				{
					parent->_col = BLACK;
					unc->_col = BLACK;
					grandf->_col = RED;
					cur = grandf;//继续往上调整
					parent = cur->_parent;
				}
				else//u不存在或者黑
				{
					if (parent->_left == cur)
					{
						RotateR(grandf);
						parent->_col = BLACK;
						grandf->_col = RED;
					}
					else
					{
						RotateL(parent);
						RotateR(grandf);
						cur->_col = BLACK;
						grandf->_col = RED;
					}
					break;
				}
			}
			else
			{
				Node* unc = grandf->_left;
				if (unc && unc->_col == RED)
				{
					parent->_col = BLACK;
					unc->_col = BLACK;
					grandf->_col = RED;
					cur = grandf;
					parent = cur->_parent;
				}
				else
				{
					if (parent->_right == cur)
					{
						RotateL(grandf);
						parent->_col = BLACK;
						grandf->_col = RED;
					}
					else
					{
						RotateR(parent);
						RotateL(grandf);
						cur->_col = BLACK;
						grandf->_col = RED;
					}
					break;
				}
			}
		}
		_root->_col = BLACK;
		return true;
	}

（4）判断平衡函数

bool IsBalance()
	{
		if (_root && _root->_col == RED)
		{
			cout << "根节点颜色错误" << endl;
			return false;
		}
		int Bsign = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
			{
				++Bsign;
			}
			cur = cur->_left;
		}
		return _check(_root, 0, Bsign);
	}
	bool _check(Node* root, int Bnum, int Bsign)
	{
		if (root == nullptr)
		{
			if (Bnum != Bsign)
			{
				cout << "黑色节点数量不相等" << endl;
				return false;
			}
			return true;
		}
		if (root->_col == BLACK)
		{
			++Bnum;
		}
		if (root->_col == RED && root->_parent && root->_parent->_col == RED)
		{
			cout << "连续红色节点" << endl;
			return false;
		}
		return _check(root->_left,Bnum,Bsign) && _check(root->_right, Bnum, Bsign);
	}
	void _Destroy(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_Destroy(root->_left);
		_Destroy(root->_right);
		delete root;
	}

首先不能以最长路径不超过最短路径2倍为准则判断平衡，它只是结果。

还是要以前面说的规则：

第一个：先检查根是不是黑色的；

第二个：再检查连续的红色节点：如果是红色的就去检查儿子，这种方式不行，因为孩子可能不存在，可以改为它的父亲，如果是红一定有父亲，如果父亲为红就存在连续红色节点直接返回假；

还有一个：最重要的规则：判断黑色节点的数量是否相等，我们需要先记录一下黑色数量，我们可以先获取一条路径的黑色数量Bsign，然后以它为标准，如何让每条路径以它标准判断是否相等？我们可以在参数里面的形参传值Bnum，往下递归就会往下传，下一层++不会影响上一层++，因为下一层是上一层的拷贝，只要有一条不相等就返回假。

（5）查找函数

Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < key)
			{
				cur = cur->_right;
			}
			else if (cur->_kv.first > key)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}
		return nullptr;
	}

从根开始走，如果比它大，就往右边走，如果比它小，就往左边走，如果相等说明找到，否则返回空。

（6）测试函数

void Test()
{
	int arr[] = { 33, 22, 6, 1, 3, 5, 66, 7, 16, 14, 16, 3, 7, 11, 9, 36, 18, 14, 15 };
	RbTree<int, int> t;
	for (auto n : arr)
	{
		t.Insert(make_pair(n, n));
	}
	t.Inorder();
	cout << endl;
	cout << t.IsBalance() << endl;
	cout << "高度："<<t.height() << endl;
	cout << endl;
	cout << "随机数据测试:" << endl;
	srand(time(0));
	const size_t N = 100000;
	RbTree<int, int> r;
	for (size_t i = 0; i < N; ++i)
	{
		size_t x = rand() + i;
		r.Insert(make_pair(x, x));
	}
	cout << r.IsBalance() << endl;
	cout <<"高度："<< r.height() << endl;
}

（7）测试结果

C++实现红黑树核心插入实例代码

三、红黑树源代码

（1）RbTree.h

#pragma once
#include<iostream>
#include<utility>
#include<ctime>
using namespace std;
enum Color
{
	RED=0,
	BLACK,
};
template<class K,class V>
struct RbTreeNode
{
	RbTreeNode<K, V>* _left;
	RbTreeNode<K, V>* _right;
	RbTreeNode<K, V>* _parent;
	pair<K, V>_kv;
	Color _col;
	RbTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _kv(kv)
		, _col(RED)
	{}
};
template <class K,class V>
class RbTree
{
	typedef RbTreeNode<K, V> Node;
public:
	~RbTree()
	{
		_Destroy(_root);
		_root = nullptr;
	}
	bool Insert(const pair<K, V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_kv.first > kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}
		cur = new Node(kv);
		if (parent->_kv.first > kv.first)
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}
		cur->_parent = parent;
		while (parent && parent->_col == RED)
		{
			Node* grandf = parent->_parent;
			if (grandf->_left == parent)
			{
				Node* unc = grandf->_right;
				if (unc && unc->_col == RED)//u存在且为红，变色处理
				{
					parent->_col = BLACK;
					unc->_col = BLACK;
					grandf->_col = RED;
					cur = grandf;//继续往上调整
					parent = cur->_parent;
				}
				else//u不存在或者黑
				{
					if (parent->_left == cur)
					{
						RotateR(grandf);
						parent->_col = BLACK;
						grandf->_col = RED;
					}
					else
					{
						RotateL(parent);
						RotateR(grandf);
						cur->_col = BLACK;
						grandf->_col = RED;
					}
					break;
				}
			}
			else
			{
				Node* unc = grandf->_left;
				if (unc && unc->_col == RED)
				{
					parent->_col = BLACK;
					unc->_col = BLACK;
					grandf->_col = RED;
					cur = grandf;
					parent = cur->_parent;
				}
				else
				{
					if (parent->_right == cur)
					{
						RotateL(grandf);
						parent->_col = BLACK;
						grandf->_col = RED;
					}
					else
					{
						RotateR(parent);
						RotateL(grandf);
						cur->_col = BLACK;
						grandf->_col = RED;
					}
					break;
				}
			}
		}
		_root->_col = BLACK;
		return true;
	}
	Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_kv.first < key)
			{
				cur = cur->_right;
			}
			else if (cur->_kv.first > key)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}
		return nullptr;
	}
	void Inorder()
	{
		_InOrder(_root);
	}
	int height()
	{
		return _Height(_root);
	}
	bool IsBalance()
	{
		if (_root && _root->_col == RED)
		{
			cout << "根节点颜色错误" << endl;
			return false;
		}
		int Bsign = 0;
		Node* cur = _root;
		while (cur)
		{
			if (cur->_col == BLACK)
			{
				++Bsign;
			}
			cur = cur->_left;
		}
		return _check(_root, 0, Bsign);
	}
private:
	void RotateL(Node* parent)//左单旋
	{
		Node* suR = parent->_right;//11的右孩子即22
		Node* suRL = suR->_left;//11的右孩子的左孩子即b
		Node* ppnode = parent->_parent;//维护父结点的父结点
		parent->_right = suRL;//11右孩子链接b
		if (suRL)//如果b不为空
			suRL->_parent = parent;//更新双亲结点
		suR->_left = parent;//22上提，左孩子链接11
		parent->_parent = suR;//更新双亲结点
		if (ppnode == nullptr)
		{
			_root = suR;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = suR;
			}
			else
			{
				ppnode->_right = suR;
			}
			suR->_parent = ppnode;
		}
	}
	void RotateR(Node* parent)//右单旋
	{
		Node* suL = parent->_left;
		Node* suLR = suL->_right;
		parent->_left = suLR;
		if (suLR)
			suLR->_parent = parent;
		Node* ppnode = parent->_parent;
		suL->_right = parent;
		parent->_parent = suL;
		if (parent == _root)
		{
			_root = suL;
			_root->_parent = nullptr;
		}
		else
		{
			if (ppnode->_left == parent)
			{
				ppnode->_left = suL;
			}
			else
			{
				ppnode->_right = suL;
			}
			suL->_parent = ppnode;
		}
	}
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_InOrder(root->_left);
		cout << root->_kv.first << " ";
		_InOrder(root->_right);
	}
	int _Height(Node* root)
	{
		if (root == NULL)
			return 0;
		int leftH = _Height(root->_left);
		int rightH = _Height(root->_right);
		return leftH > rightH ? leftH + 1 : rightH + 1;
	}
	bool _check(Node* root, int Bnum, int Bsign)
	{
		if (root == nullptr)
		{
			if (Bnum != Bsign)
			{
				cout << "黑色节点数量不相等" << endl;
				return false;
			}
			return true;
		}
		if (root->_col == BLACK)
		{
			++Bnum;
		}
		if (root->_col == RED && root->_parent && root->_parent->_col == RED)
		{
			cout << "连续红色节点" << endl;
			return false;
		}
		return _check(root->_left,Bnum,Bsign) && _check(root->_right, Bnum, Bsign);
	}
	void _Destroy(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_Destroy(root->_left);
		_Destroy(root->_right);
		delete root;
	}
private:
	Node* _root;
};
void Test()
{
	int arr[] = { 33, 22, 6, 1, 3, 5, 66, 7, 16, 14, 16, 3, 7, 11, 9, 36, 18, 14, 15 };
	RbTree<int, int> t;
	for (auto n : arr)
	{
		t.Insert(make_pair(n, n));
	}
	t.Inorder();
	cout << endl;
	cout << t.IsBalance() << endl;
	cout << "高度："<<t.height() << endl;
	cout << endl;
	cout << "随机数据测试:" << endl;
	srand(time(0));
	const size_t N = 100000;
	RbTree<int, int> r;
	for (size_t i = 0; i < N; ++i)
	{
		size_t x = rand() + i;
		r.Insert(make_pair(x, x));
	}
	cout << r.IsBalance() << endl;
	cout <<"高度："<< r.height() << endl;
}

（2）Test.cpp

#include"RbTree.h"
int main()
{
	Test();
	return 0;
}

总结

声明：本站所有文章，如无特殊说明或标注，均为本站原创发布。任何个人或组织，在未征得本站同意时，禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益，可联系我们进行处理。

C++实现红黑树核心插入实例代码

目录

一、红黑树概念介绍

二、红黑树模拟实现

（1）红黑树节点

（2）红黑树插入分析(核心)

（3）插入代码思路(如何快速写插入算法)

（4）判断平衡函数

（5）查找函数

（6）测试函数

（7）测试结果

三、红黑树源代码

（1）RbTree.h

（2）Test.cpp

总结

评论(0)

提示：请文明发言取消回复

作者信息

本站推荐

Ai五阶体系课入门通识理论+实操带你快速入门

衣刀君45节摄影课2024全套摄影教程大全

用iPhone拍电影感大片，Apple Log 8节课实战教学（课件+素材）

2025抖店运营攻略，掌握抖店技巧，打造月销百万，新手入门到精通

2025Tk跨境淘金课：涵盖养号、剪辑、店铺注册到选品、定价、营销等

翼狐网-UE5-CG视频蓝图运用特训营（价值4999元）【无水印版】

热门资源

苹果cms海螺影视模板/大橙子模板/仿B站模板/v7模板/带手机移动端+详细安装使用说明

【已测】修复版H5骰子微信竞猜游戏骰宝免公众号版修复登录ID相同完美全套源码对接免签支付

网页游戏卧龙吟一键服务端加远程工具带架设教程

邪风曲单机版 2D回合制网络游戏源码一键安装即玩服务端公益服+GM工具

完整可用版本去水印小程序源码带教程源码

仙侠H5【苍穹剑诀】一键即玩端+授权后台+外网教程

C++实现红黑树核心插入实例代码

目录

一、红黑树概念介绍

二、红黑树模拟实现

（1）红黑树节点

（2）红黑树插入分析(核心)

（3）插入代码思路(如何快速写插入算法)

（4）判断平衡函数

（5）查找函数

（6）测试函数

（7）测试结果

三、红黑树源代码

（1）RbTree.h

（2）Test.cpp

总结

评论(0)

提示：请文明发言 取消回复

相关文章

作者信息

本站推荐

热门资源

提示：请文明发言取消回复