红黑树的模拟实现

于 2023-11-11 18:41:30 发布
阅读量124 收藏
点赞数
分类专栏： 数据结构（精） 文章标签： 算法 开发语言 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63783532/article/details/134347767
版权

一、介绍

1. 概念

  • 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。
  • 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的

2. 性质

  1. 每个结点不是红色就是黑色
  2. 根节点是黑色的
  3. 如果一个节点是红色的，则它的两个孩子结点是黑色的
  4. 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点
  5. 每个叶子结点都是黑色的(此处的叶子结点指的是空结点)

3. 结点定义

enum Colour//两种颜色
{
	RED,
	BLACK
};

//定义红黑树的结点
template<class K, class V>
struct RBTreeNode
{
	RBTreeNode* _left;
	RBTreeNode* _right;
	RBTreeNode* _parent;
	pair<K, V> _kv;
	Colour _col;

	RBTreeNode(const pair<K, V>& kv)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_kv(kv)
		,_col(RED)
	{}
};

二、插入的3种情况

（一）情况1

  • 因为cur为当前插入新结点（红色），而不能有连在一起的红色节点，所以parent结点需要变成黑色。
  • 控制每条路径上黑节点的数量相同，那么就要把uncle变黑
  • grandparent如果不是根节点，需要继续向上调整，所以grandparent需要变成红色

//情况1：uncle存在且为红色
if (uncle != nullptr && uncle->_col == RED)
{
	//调整颜色
	parent->_col = uncle->_col = BLACK;
	grandfather->_col = RED;

	//继续往上调整
	cur = grandfather;
	parent = cur->_parent;
}

 

（二）情况2

//情况2
if (cur == parent->_left)
{
	//             grandfather
	//        parent
	//    cur
	RotateR(grandfather);//右旋转
	//调整颜色
	parent->_col = BLACK;
	grandfather->_col = RED;

}

 

（三）情况3

 

 

else//cur在parent的右边
{
	//             grandfather
	//        parent
	//              cur
	RotateL(parent);//先左旋转
	RotateR(grandfather);//再右旋转
	//调整颜色
	cur->_col = BLACK;
	grandfather->_col = RED;
}

（四）插入代码

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//已经存在一样的值，直接返回false
		{
			return false;
		}
	}

	//链接
	cur = new Node(kv);
	cur->_col = RED;
	if (parent->_kv.first < kv.first)
	{
		parent->_right = cur;
		cur->_parent = parent;
	}
	else
	{
		parent->_left = cur;
		cur->_parent = parent;
	}

	//调整
	while (parent && parent->_col == RED)//如果父亲结点是黑色直接结束
	{
		Node* grandfather = parent->_parent;
		if (parent == grandfather->_left)
		{
			//         grandfather
			//      parent     uncle
			//   cur
			//
			Node* uncle = grandfather->_right;
			//情况1：uncle存在且为红色
			if (uncle != nullptr && uncle->_col == RED)
			{
				//调整颜色
				parent->_col = uncle->_col = BLACK;
				grandfather->_col = RED;

				//继续往上调整
				cur = grandfather;
				parent = cur->_parent;
			}
			else//uncle不存在或者uncle为黑色
			{   //情况2
				if (cur == parent->_left)
				{
					//             grandfather
					//        parent
					//    cur
					RotateR(grandfather);//右旋转
					//调整颜色
					parent->_col = BLACK;
					grandfather->_col = RED;

				}
				else//cur在parent的右边
				{
					//             grandfather
					//        parent
					//              cur
					RotateL(parent);//先左旋转
					RotateR(grandfather);//再右旋转
					//调整颜色
					cur->_col = BLACK;
					grandfather->_col = RED;
				}
				break;
			}
		}
		else//parent == grandfather->_right
		{
			Node* uncle = grandfather->_left;

			//         g
			//      u    p
			//             c
			//
			//情况1：uncle存在且为红色
			if (uncle != nullptr && uncle->_col == RED)
			{
				//调整颜色
				parent->_col = uncle->_col = BLACK;
				grandfather->_col = RED;

				//继续往上调整
				cur = grandfather;
				parent = cur->_parent;
			}
			else//uncle不存在或者uncle为黑色
			{
				if (cur == parent->_right)
				{
					//           g
					//              p
					//                 c
					RotateL(grandfather);
					//调整颜色
					parent->_col = BLACK;
					grandfather->_col = RED;
				}
				else
				{
					//         g
					//             p
					//           c
					RotateR(parent);//先右旋
					RotateL(grandfather);//再左旋

					//调整颜色
					cur->_col = BLACK;
					grandfather->_col = RED;

				}
				break;
			}
		}
	}
	_root->_col = BLACK;
	return true;
}

三、判断是否近似平衡

//	// 根节点->当前节点这条路径的黑色节点的数量
bool Check(Node* root, int blacknum, const int refVal)
{
	if (root == nullptr)//走到了一条路径的尽头
	{
		if (blacknum != refVal)
		{
			cout << "存在黑色节点数量不相等的路径" << endl;
			return false;
		}

		return true;
	}

	if (root->_col == RED && root->_parent->_col == RED)
	{
		cout << "有连续的红色节点" << endl;
		return false;
	}

	if (root->_col == BLACK)
	{
		++blacknum;
	}

	return Check(root->_left, blacknum, refVal)
		&& Check(root->_right, blacknum, refVal);
}

bool IsBalance()//判断是否平衡
{
	if (_root == nullptr)
		return true;

	if (_root->_col == RED)//根结点如果是红色
		return false;

	int refVal = 0;
	Node* cur = _root;
	while (cur)//计算其中一条路径上的黑色节点数量作为参考值
	{
		if (cur->_col == BLACK)
		{
			++refVal;
		}

		cur = cur->_left;
	}

	int blacknum = 0;
	return Check(_root, blacknum, refVal);
}

四、完整代码

#pragma once
#include<iostream>
#include<vector>
#include<string>
using namespace std;
enum Colour//两种颜色
{
	RED,
	BLACK
};

//定义红黑树的结点
template<class K, class V>
struct RBTreeNode
{
	RBTreeNode* _left;
	RBTreeNode* _right;
	RBTreeNode* _parent;
	pair<K, V> _kv;
	Colour _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:
	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//已经存在一样的值，直接返回false
			{
				return false;
			}
		}

		//链接
		cur = new Node(kv);
		cur->_col = RED;
		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_left = cur;
			cur->_parent = parent;
		}

		//调整
		while (parent && parent->_col == RED)//如果父亲结点是黑色直接结束
		{
			Node* grandfather = parent->_parent;
			if (parent == grandfather->_left)
			{
				//         grandfather
				//      parent     uncle
				//   cur
				//
				Node* uncle = grandfather->_right;
				//情况1：uncle存在且为红色
				if (uncle != nullptr && uncle->_col == RED)
				{
					//调整颜色
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;
					
					//继续往上调整
					cur = grandfather;
					parent = cur->_parent;
				}
				else//uncle不存在或者uncle为黑色
				{   //情况2
					if (cur == parent->_left)
					{
						//             grandfather
						//        parent
						//    cur
						RotateR(grandfather);//右旋转
						//调整颜色
						parent->_col = BLACK;
						grandfather->_col = RED;

					}
					else//cur在parent的右边
					{
						//             grandfather
						//        parent
						//              cur
						RotateL(parent);//先左旋转
						RotateR(grandfather);//再右旋转
						//调整颜色
						cur->_col = BLACK;
						grandfather->_col = RED;
					}
					break;
				}
			}
			else//parent == grandfather->_right
			{
				Node* uncle = grandfather->_left;
				
				//         g
				//      u    p
				//             c
				//
				//情况1：uncle存在且为红色
				if (uncle != nullptr && uncle->_col == RED)
				{
					//调整颜色
					parent->_col = uncle->_col = BLACK;
					grandfather->_col = RED;

					//继续往上调整
					cur = grandfather;
					parent = cur->_parent;
				}
				else//uncle不存在或者uncle为黑色
				{
					if (cur == parent->_right)
					{
						//           g
						//              p
						//                 c
						RotateL(grandfather);
						//调整颜色
						parent->_col = BLACK;
						grandfather->_col = RED;
					}
					else
					{
						//         g
						//             p
						//           c
						RotateR(parent);//先右旋
						RotateL(grandfather);//再左旋

						//调整颜色
						cur->_col = BLACK;
						grandfather->_col = RED;

					}
					break;
				}
			}
		}
		_root->_col = BLACK;
		return true;
	}

	// 根节点->当前节点这条路径的黑色节点的数量
	bool Check(Node* root, int blacknum, const int refVal)
	{
		if (root == nullptr)//走到了一条路径的尽头
		{
			if (blacknum != refVal)
			{
				cout << "存在黑色节点数量不相等的路径" << endl;
				return false;
			}

			return true;
		}
		
		if (root->_col == RED && root->_parent->_col == RED)
		{
			cout << "有连续的红色节点" << endl;
			return false;
		}

		if (root->_col == BLACK)
		{
			++blacknum;
		}

		return Check(root->_left, blacknum, refVal)
			&& Check(root->_right, blacknum, refVal);
	}

	bool IsBalance()//判断是否平衡
	{
		if (_root == nullptr)
			return true;

		if (_root->_col == RED)//根结点如果是红色
			return false;

		int refVal = 0;
		Node* cur = _root;
		while (cur)//计算其中一条路径上的黑色节点数量作为参考值
		{
			if (cur->_col == BLACK)
			{
				++refVal;
			}

			cur = cur->_left;
		}

		int blacknum = 0;
		return Check(_root, blacknum, refVal);
	}
	void RotateL(Node* parent)//左单旋
	{
		Node* parentParent = parent->_parent;
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		parent->_right = subRL;
		subR->_left = parent;

		//更新调整结点的父指针指向
		parent->_parent = subR;
		//subRL->_parent = parent;错误，没有判断subRL是不是为空
		if (subRL != nullptr)
		{
			subRL->_parent = parent;
		}

		if (_root == parent)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			if (parentParent->_left == parent)
			{
				parentParent->_left = subR;
			}
			else
			{
				parentParent->_right = subR;
			}
			subR->_parent = parentParent;
		}

		//更新平衡因子
		//parent->_bf = subR->_bf = 0;
	}

	void RotateR(Node* parent)//右单旋
	{
		Node* parentParent = parent->_parent;
		Node* subL = parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		//更新调整结点的父指针指向
		if (subLR != nullptr)
		{
			subLR->_parent = parent;
		}

		subL->_right = parent;
		//更新调整结点的父指针指向
		parent->_parent = subL;


		if (_root == parent)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			//需要先判断subR应该链接在parentParent的哪一侧
			if (parentParent->_left == parent)
			{
				parentParent->_left = subL;
			}
			else
			{
				parentParent->_right = subL;
			}
			subL->_parent = parentParent;
		}
		//更新平衡因子
		//parent->_bf = subL->_bf = 0;
	}
	void InOrder()//中序遍历
	{
		_InOrder(_root);
		cout << endl;
	}
	void _InOrder(Node* root)//中序遍历
	{
		if (root == nullptr)
		{
			return;
		}

		_InOrder(root->_left);
		cout << root->_kv.first << " ";
		_InOrder(root->_right);
	}

	int Height()
	{
		return _Height(_root);
	}

	int _Height(Node* root)
	{
		if (root == nullptr)
			return 0;

		int leftHeight = _Height(root->_left);
		int rightHeight = _Height(root->_right);

		return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
	}

	size_t Size()
	{
		return _Size(_root);
	}

	size_t _Size(Node* root)
	{
		if (root == NULL)
			return 0;

		return _Size(root->_left)
			+ _Size(root->_right) + 1;
	}

	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 NULL;
	}
private:
	Node* _root = nullptr;
};

1. 测试用例1

#include"RBTree.h"
int main()
{
	//int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	//int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
	int a[] = { 790,760,969,270,31,424,377,24,702 };
	RBTree<int, int> t;
	for (auto e : a)
	{
		if (e == 702)
		{
			int i = 0;
		}
	
		cout << "Insert:" << e << "->";
		t.Insert(make_pair(e, e));
		cout << t.IsBalance() << endl;
	}
	t.InOrder();
	
	cout << t.IsBalance() << endl;
	
	return 0;
}

2. 测试用例2

#include"RBTree.h"

int main()
{
	const int N = 100000;
	vector<int> v;
	v.reserve(N);
	srand(time(0));

	for (size_t i = 0; i < N; i++)
	{
		v.push_back(rand() + i);
		//cout << v.back() << endl;
	}

	size_t begin2 = clock();
	RBTree<int, int> t;
	for (auto e : v)
	{
		if (e == 29365)
		{
			int i = 0;
		}

		//cout << "Insert:" << e << "->";
		t.Insert(make_pair(e, e));
		//cout << t.IsBalance() << endl;
	}
	size_t end2 = clock();

	cout << "Insert:" << end2 - begin2 << endl;

	cout << t.IsBalance() << endl;
	cout << t.Height() << endl;
	cout << t.Size() << endl;

	size_t begin1 = clock();
	for (auto e : v)
	{
		t.Find(e);
	}

	for (size_t i = 0; i < N; i++)
	{
		t.Find((rand() + i));
	}

	size_t end1 = clock();

	cout << "Find:" << end1 - begin1 << endl;

	return 0;
}

莫忘、莫念
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
红黑树-动态演示生成红黑树
09-30
红黑树算法，随机产生数字，动态生成红黑树，可用于演示。
《算法导论》红黑树详解（二）：Java实现Demo
JiangYing的博客
11-03 393
《算法导论》红黑树详解（一）：概念 使用Java简单地实现红黑树代码如下： /** * 红黑树实现demo */ public class RedBlackTree&amp;lt;Key extends Comparable&amp;lt;Key&amp;gt;&amp;gt; { private static final boolean RED = false; private static fin...
树：红黑树
——
06-23 544
红黑树（Red Black Tree） 是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。 红黑树和AVL树类似，都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。 它虽然是复杂的，但它的最坏情况运行时间也是非常良好的，并且在实践中是高效的： 它可以在O(log n)时间内做查找，插入和删除，这里的n 是
红黑树实现
魔筝炼药师
03-29 464
待更新
Java实现红黑树并绘制红黑树
qq_29648139的博客
05-05 309
步骤一：实现红黑树 定义红黑树节点类 package rbtree; import java.util.List; public class RBTreeNode<T> { private T val;//值 private boolean red;//是否为红 private RBTreeNode<T> parentNode;//父节点 private RBTreeNode<T> leftNode;//左节点 private
C语言-实现红黑树的模拟
最新发布
04-22
红黑树是一种自平衡的二叉查找树，是一种高效的查找树。它是由 Rudolf Bayer 于1978年发明，在当时被称为平衡二叉 B 树(symmetric binary B-trees)。...C语言实现红黑树的创建，包括节点的插入删除操作以及红黑树输出
控制台打印红黑树.rar
05-17
在实际编程中，红黑树常用于实现关联数组、映射、集合等数据结构，例如C++标准库中的`std::map`和`std::set`。由于其良好的平衡性能，红黑树在高效算法和数据结构设计中扮演着重要角色。 了解和掌握红黑树的原理与...
红黑树,实现,视频
12-01
利用图示实现了红黑树 视频模拟 有助于理解红黑树的算法 自己转红黑树，发现一只有问题 这才找到了这个视频 跟大家分享了
红黑树原理详解
12-07
- C++标准模板库(STL)中的`std::map`和`std::set`也使用红黑树实现。 - 数据库系统，如MySQL的InnoDB存储引擎，使用红黑树实现索引。 红黑树的概念深入且复杂，理解并实现它需要对二叉树、排序和颜色属性有透彻的...
算法（销售员问题）.rar_研究生_红黑树
09-23
可能的实现方式是使用红黑树存储城市的距离矩阵，以便快速查询和更新距离信息。 在实际解决TSP时，由于问题的复杂性，通常会使用启发式算法或近似算法，如遗传算法、模拟退火、贪心策略或者动态规划等。红黑树可能...
STL源码：红黑树
Sunshine的专栏
03-30 2816
红黑树的性质和插入操作 这部分参考文章 《红黑树操作及实现》 红黑树节点结构 typedef bool __rb_tree_color_type; const __rb_tree_color_type __rb_tree_red = false; // 红色为0 const __rb_tree_color_type __rb_tree_black = true; // 黑色为1 s
算法基础之--红黑树实现
奔波儿灞
09-13 156
package wck.sort;/** * Created on 18/9/13. */ /** * @program: demo * @description: 红黑树实现 * @author: wck * @create: 2018-09-13 11:07 **/ public class RBT &lt;K extends Comparable&lt;K&gt;, V&gt...
TreeMap底层红黑树源码浅析
qq_43304681的博客
01-06 459
分析java集合的时候，HashMap的存储优化和TreeMap的底层都使用到了红黑树 来看一看红黑树调整的具体源码。 版本：jdk1.8 //首先是一个Entry类(TreeMap的内部类) //包含，key、value、左孩子引用、右孩子引用、父节点引用、结点颜色（默认为黑色结点） static final class Entry<K,V> implements Map.Entry<K,V> { K key; V valu
数据结构与算法系列18--红黑树
Lin的博客
12-01 149
红黑树是平衡二叉查找树的一种，上一节我们已经讲过二叉查找树的定义，那什么是平衡二叉查找树呢？ 什么是平衡二叉查找树 定义： 平衡二叉查找树严格的定义是：二叉树中任意一个节点的左右子树的高度相差不能大于+1。从这个定义来看，的完全二叉树、满二叉树其实都是平衡二叉树，但是非完全二叉树也有可能是平衡二叉树。 目的： 发明平衡二叉查找树这类数据结构的初衷是，解决普通二叉查找树在频繁的插入、删除等动态更新的...
手写红黑树笔记
CBeann的博客
01-03 335
写这篇文章的目的 1）心血来潮，你信吗 2）红黑树确实很重要，并且在这个也是经常问的题。 代码下载 https://github.com/cbeann/Demooo/tree/master/java-demoo/src/main/java/myredblacktree 红黑树难点 红黑树性质 每一个节点要么是黑色，要么是红色的。 根节点是黑色。 叶子节点（Null）是黑色。 每一个红色节点的两个子节点一定都是黑色。不能有两个红色节点相连。 任意一个节点到每一个叶子节点的路径都包含相同的
史上最清晰的红黑树讲解（上）
weixin_30315435的博客
05-18 477
本文github地址 本文以Java TreeMap为例，从源代码层面，结合详细的图解，剥茧抽丝地讲解红黑树（Red-Black tree）的插入，删除以及由此产生的调整过程。 总体介绍 Java TreeMap实现了SortedMap接口，也就是说会按照key的大小顺序对Map中的元素进行排序，key大小的评判可以通过其本身的自然顺序（natural ordering），也可以通过构造时传入的比...
【数据结构】树（三）：红黑树插入与删除操作（C++实现）
快去创造奇迹
04-27 2617
红黑树性质及操作分析，包含C++代码实现
JAVA实践红黑树-小试牛刀
薛定谔的猫窝
08-24 4955
前言第一感觉是和AVL树差别不是特别大，没有很直观的感受到效率的巨大提升，作为一个小小的强迫症患者，还是AVL树更好看。不过讲道理，平衡被破坏次数相同情况下，红黑树的确少了那么一些旋转。。。因为插入节点后平衡被破坏时，红黑树的会选择旋转或变色。 AVL树则只有旋转。另外我发现其他的大神写法，跟我的有点差距。。。有心人可以帮我瞄一眼，我是不是哪里错了，在此先谢过了~~另外一个参考网站、博客、PDF：
红黑树（附完整C代码）
热门推荐
weewqrer的博客
07-09 2万+
版权声明：原创不易，转载请注明转自weewqrer 红黑树红黑树简介首先红黑树是一棵二叉搜索树，它在每个结点上增加了一个存储位来表示结点的颜色，可以是RED或者BLACK。通过对一条从根节点到NIL叶节点（指空结点或者下面说的哨兵）的简单路径上各个结点在颜色进行约束，红黑树确保没有一条路径会比其他路径长出2倍，因而是近似平衡的。 用途红黑树和AVL树一样都对插入时间、删除时间和查找时间提供了最好可
Linux环境下实现堆、栈、B+树和红黑树数据结构
"这篇实验报告主要讲述了Linux环境下的四种数据结构——堆、栈、B+树和红黑树，并提供了C语言实现的示例。作者赵彩霞在实验中详细探讨了这些数据结构的原理、操作及应用。" 在Linux操作系统中，数据结构是编程的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值