数据结构::浅析红黑树

最新推荐文章于 2024-08-18 17:17:53 发布
最新推荐文章于 2024-08-18 17:17:53 发布
阅读量770 收藏 1
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lalu58/article/details/55105755
版权

一、概念：

    红黑树是一棵二叉搜索树，它增加一个标志位来进行红黑颜色的表示。通过任何一条从根到叶子节点路径上的颜色来进行约束，红黑树保证最长路径是最短路径的两倍。

二、性质：

   1）每个节点不是红色的就是黑色的

   2）根节点是黑色的

   3）红色节点是不连续的

   4）从根节点到每一条叶子节点的简单路径中，黑色节点的个数是相等的。

   5）每个叶子节点是黑色的

三、节点的定义：

说明:我们根据概念知道要表示红黑颜色，因此我们利用枚举来进行红黑颜色的存储

enum Color
{
	BLACK,
	RED,
};
template<class K,class V>
struct BRTreeNode
{
	K _key;
	V _value;
	Color _col;
	BRTreeNode<K,V>* _left;
	BRTreeNode<K,V>* _right;
	BRTreeNode<K,V>* _parent;
	BRTreeNode<K,V>(const K& key,const V& value)
		:_left(NULL)
		,_right(NULL)
		,_parent(NULL)
		,_key(key)
		,_value(value)
		,_col(RED)
	{}
};

四、插入函数的实现：

1、情况分析（大体上分三种情况）：

（grandfa:祖父节点  parent:父节点  cur:插入的当前节点 uncle:叔叔节点）

（以下是以父节点是祖父的左孩子为例）

首先我们要明确一个情况：如果父节点是黑色的话，那么插入一个节点，就不用管了。

1）如果这棵树是一颗空树，那么插入一个节点的话，只要将这棵树的颜色编程黑色即可

2）父节点是红色，主要看叔叔节点

   A：u存在并且u为红色，只需变色，然后向上调整（将祖父节点作为当前节点）即可


   B：u不存在并且为黑色  ，要进行旋转

        a：如果插入的节点是父亲的左孩子，进行右旋


        b：如果插入的节点是父亲的右孩子，进行左右旋


        说明：有同学可能有疑问，如果u不存在的话，我将它的图画出来，我们很显而易见的发现这是和a的处理方法是一样的，只需进行左旋即可情况，所以上述的两种情况将这种情况包括进去了。


2、代码实现：

bool Insert(const K& key,const V& value)
	{
		Node* cur = _root;
		Node* parent = NULL;
		if(_root == NULL)
		{
			_root = new Node(key,value);
			_root->_col = BLACK;
			return true;
		}
		while(cur)
		{
			if(cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if(cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;
			}
		}
		cur = new Node(key,value);
		if(parent->_key > key)
		{
			parent->_left = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		while((parent) && (parent->_col == RED))
		{
			Node* grandfa = parent->_parent;
			if(grandfa->_left == parent)
			{
				Node* uncle = grandfa->_right;
				//只需变色
				if((uncle) && (uncle->_col == RED))
				{
					parent->_col = uncle->_col = BLACK;
					grandfa->_col = RED;
					cur = grandfa;
					parent = cur->_parent;
				}
				//进行旋转
				else
				{
					if(parent->_left == cur)
					{
						RotateR(grandfa);
						//swap(parent,cur);
						parent->_col = BLACK;
						grandfa->_col = RED;
					}
					else
					{
						RotateL(parent);
						RotateR(grandfa);
						cur->_col = BLACK;
						grandfa->_col = RED;
						break;
					}
				}
			}
			else
			{
				Node* uncle = grandfa->_left;
				if((uncle) && (uncle->_col == RED))
				{
					parent->_col = uncle->_col = BLACK;
					grandfa->_col = RED;
					cur = grandfa;
					parent = cur->_parent;
				}
				else
				{
					if(parent->_right == cur)
					{
						RotateL(grandfa);
						parent->_col = BLACK;
						grandfa->_col = RED;
						//swap(cur,parent);
					}
					else
					{
						RotateR(parent);
						RotateL(grandfa);
						cur->_col = BLACK;
						grandfa->_col = RED;
						break;
					}
				}
			}
		}
		_root->_col = BLACK;
		return true;
	}

3、有关插入函数的相关函数实现

1）左旋：

void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		parent->_right = subRL;
		if(subRL)
			subRL->_parent = parent;

		Node* ppNode = parent->_parent;
		subR->_left = parent;
		parent->_parent = subR;

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

2）右旋：

void RotateR(Node* parent)
	{
		Node* subL= parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		if(subLR)
			subLR->_parent = parent;

		Node* ppNode = parent->_parent;
		subL->_right= parent;
		parent->_parent = subL;

		if(ppNode == NULL)
		{
			_root = subL;
		}
		else
		{
			if(ppNode->_left == parent)
				ppNode->_left = subL;
			else
				ppNode->_right = subL;
		}
			subL->_parent = ppNode;		
	}

五、判断一颗树是否是红黑树：

思路分析：

我们由红黑树的性质出发，可以知道有以下几种情况：

1）当是空树一棵的时候，它也是红黑树

2）当它的根存在并且它的根是黑色，因此我们就让根存在，根为红色作为判断条件，因为如果是这个条件的话，我们就不用往下再进行判断了

3）红色节点的不连续性：我们可能只管想到的第一种方法就是遍历这棵树，然后记录黑色和红色节点的位置，但是这种方法时间复杂度很高，并且不易实现，因此我们想到：如果当前节点是红色的，判断它的父节点颜色是否也是红色的，如果是的话，那么就不是红黑树，否则就是。

4）判断从根节点到叶子节点的每一条简单路径中黑色节点的个数，我们肯定是采用递归了，但是有一个问题我们需要注意：树的叶子节点不都在同一水平线上的，那么计算另一分支上的上面的或者下面的黑色节点的个数的时候，就要将上次的个数减去或者增加你退回的需要拿掉的个数，所以我们在这里的变量就不使用引用了，因为上一次的变量的值的改变不能影响下一层。

要实现的两个函数：

1）判断红色节点的个数不连续

bool CheckCol(Node* root)
	{
		if(root == NULL)
			return true;
		if(root->_col == RED && root->_parent->_col == RED)
			return false;
		return CheckCol(root->_left)
			&& CheckCol(root->_right);
	}

2）判断从根节点到叶子节点的简单路径中黑色节点的个数

bool CheckBlackNum(Node* root,const size_t k,size_t num)
	{
		if(root == NULL)
			return true;
		if(root->_col == BLACK)
			num++;
		if((root->_left == NULL) && (root->_right == NULL) 
			&& (k != num))
			return false;
		return CheckBlackNum(root->_left,k,num)
		      && CheckBlackNum(root->_right,k,num);
	}
说明：我们最终要进行每一路的黑色节点的比较，那么我先计算最左或者最右一路的根节点到叶子节点的黑色节点的个数，就是这里的k

3）判断是否是红黑树的代码实现：

	bool IsBRTree()
	{	
		size_t k = 0;
		size_t num = 0;
		Node* cur = _root;
		if(_root == NULL)
			return true;
		if(_root && _root->_col == RED)
			return false;
		while(cur)
		{
			if(cur->_col == BLACK)
				k++;
			cur = cur->_left;
		}
		
		return CheckCol(_root) && CheckBlackNum(_root,k,num);
	}

六、红黑树和平衡二叉树的比较：

1）红黑树都是和AVL树最高效的二叉搜索树，增删查改的时间复杂度都是O（lgN）

2）红黑树不追求完全平衡，保证最长路径是最短路径的两倍，相对而言，降低了旋转的要求，所以性能优于AVL树，所以在实际应用中，红黑树的应用更多。

举个例子：如果在这个图中进行插入一个节点，如果是AVL树的话，就要进行旋转，但是如果是红黑树的话，只需要进行变色。（当然只是只管的说，还会要看具体情况）


七、附源代码:

#include<iostream>
using namespace std; 
enum Color
{
	BLACK,
	RED,
};
template<class K,class V>
struct BRTreeNode
{
	K _key;
	V _value;
	Color _col;
	BRTreeNode<K,V>* _left;
	BRTreeNode<K,V>* _right;
	BRTreeNode<K,V>* _parent;
	BRTreeNode<K,V>(const K& key,const V& value)
		:_left(NULL)
		,_right(NULL)
		,_parent(NULL)
		,_key(key)
		,_value(value)
		,_col(RED)
	{}
};
template<class K,class V>
class BRTree
{
	typedef BRTreeNode<K,V> Node;
public:
	BRTree()
		:_root(NULL)
	{}
	bool Insert(const K& key,const V& value)
	{
		Node* cur = _root;
		Node* parent = NULL;
		if(_root == NULL)
		{
			_root = new Node(key,value);
			_root->_col = BLACK;
			return true;
		}
		while(cur)
		{
			if(cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if(cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;
			}
		}
		cur = new Node(key,value);
		if(parent->_key > key)
		{
			parent->_left = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_right = cur;
			cur->_parent = parent;
		}
		
		while((parent) && (parent->_col == RED))
		{
			Node* grandfa = parent->_parent;
			if(grandfa->_left == parent)
			{
				Node* uncle = grandfa->_right;
				//只需变色
				if((uncle) && (uncle->_col == RED))
				{
					parent->_col = uncle->_col = BLACK;
					grandfa->_col = RED;
					cur = grandfa;
					parent = cur->_parent;
				}
				//进行旋转
				else
				{
					if(parent->_left == cur)
					{
						RotateR(grandfa);
						//swap(parent,cur);
						parent->_col = BLACK;
						grandfa->_col = RED;
					}
					else
					{
						RotateL(parent);
						RotateR(grandfa);
						cur->_col = BLACK;
						grandfa->_col = RED;
						break;
					}
				}
			}
			else
			{
				Node* uncle = grandfa->_left;
				if((uncle) && (uncle->_col == RED))
				{
					parent->_col = uncle->_col = BLACK;
					grandfa->_col = RED;
					cur = grandfa;
					parent = cur->_parent;
				}
				else
				{
					if(parent->_right == cur)
					{
						RotateL(grandfa);
						parent->_col = BLACK;
						grandfa->_col = RED;
						//swap(cur,parent);
					}
					else
					{
						RotateR(parent);
						RotateL(grandfa);
						cur->_col = BLACK;
						grandfa->_col = RED;
						break;
					}
				}
			}
		}
		_root->_col = BLACK;
		return true;
	}
	//中序打印
	void InOrder()
	{
		_InOrder(_root);
		cout<<endl;
	}
	void _InOrder(Node* root)
	{
		if(root == NULL)
			return;

		_InOrder(root->_left);
		cout<<root->_key<<" ";
		_InOrder(root->_right);
	}

	//判断是否是红黑树
	//说明：1、检查树的颜色是否是正确的
	//	2、检查树中每一条路经的黑色节点个数是否是相同的

	bool IsBRTree()
	{	
		size_t k = 0;
		size_t num = 0;
		Node* cur = _root;
		if(_root == NULL)
			return true;
		if(_root && _root->_col == RED)
			return false;
		while(cur)
		{
			if(cur->_col == BLACK)
				k++;
			cur = cur->_left;
		}
		
		return CheckCol(_root) && CheckBlackNum(_root,k,num);
	}

	//检查颜色
	bool CheckCol(Node* root)
	{
		if(root == NULL)
			return true;
		if(root->_col == RED && root->_parent->_col == RED)
			return false;
		return CheckCol(root->_left)
			&& CheckCol(root->_right);
	}

	//检查每条路经中黑节点的个数
	bool CheckBlackNum(Node* root,const size_t k,size_t num)
	{
		if(root == NULL)
			return true;
		if(root->_col == BLACK)
			num++;
		if((root->_left == NULL) && (root->_right == NULL) 
			&& (k != num))
			return false;
		return CheckBlackNum(root->_left,k,num)
		      && CheckBlackNum(root->_right,k,num);

	}
	//左旋
	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		parent->_right = subRL;
		if(subRL)
			subRL->_parent = parent;

		Node* ppNode = parent->_parent;
		subR->_left = parent;
		parent->_parent = subR;

		if(ppNode == NULL)
		{
			_root = subR;
		}
		else
		{
			if(ppNode->_left == parent)
				ppNode->_left = subR;
			else
				ppNode->_right = subR;
		}
			subR->_parent = ppNode;
	}
	//右旋
	void RotateR(Node* parent)
	{
		Node* subL= parent->_left;
		Node* subLR = subL->_right;

		parent->_left = subLR;
		if(subLR)
			subLR->_parent = parent;

		Node* ppNode = parent->_parent;
		subL->_right= parent;
		parent->_parent = subL;

		if(ppNode == NULL)
		{
			_root = subL;
		}
		else
		{
			if(ppNode->_left == parent)
				ppNode->_left = subL;
			else
				ppNode->_right = subL;
		}
			subL->_parent = ppNode;		
	}
protected:
	Node* _root;
};
测试代码： 

#include"BRTree.h"
int main()
{
	int i = 0;
	BRTree<int,int> brt1;
	//int a[8] = {5,1,2,3,7,0,9,4};
	int a[12] = {5,1,2,12,11,10,4,9,7,8,15,0};
	for(i = 0; i <sizeof(a)/sizeof(a[0]); i++)
	{
		brt1.Insert(a[i],i);
		cout<<a[i];
		cout<<"IsBRTree?"<<brt1.IsBRTree()<<endl;
	}
	brt1.InOrder();
	return 0;
}


//小结：
出现问题的地方
1）单旋之后的颜色更改问题
2）双旋之后的颜色更改问题



海绵宝宝的欧尼
关注
专栏目录
大聪明教你学Java | 浅析红黑树
不肯过江东丶
06-13 282
红黑树作为一种数据结构，它被应用得非常多，可能很多人不认识它，但其实它已经在默默为我们的代码在发光发热。就比如JDK 8中的HashMap就用到了红黑树（当hash值相同时，会转换为链表，链表长度超过8时，就转化成红黑树），那么正好借此机会，和大家分享一下大聪明在学习红黑树时的一些经验与心得。...
数据结构之二叉树、AVL树、红黑树、Trie树、B树、B+树、B*树浅析
hestyle的博客
04-07 1244
  树，作为五大经典数据结构之一，有许多运用场景，比如MySQL数据库的B+树（数据结构的重要性不用强调了吧）。下面将对二叉树、红黑树、B树、B+树等树结构进行一些概念区分与总结，此篇博客适合新手、有一定数据结构基础的小伙伴。 一、树的划分   根据子节点的个数可以划分成N叉树（一般N ≥ 2），N叉树拥有的特征是每个节点至多有N个子节点。 比如，N = 2时，称为二叉树，每个节点至多只有2个节点...
红黑树
深耕技术
03-03 289
面试：你懂什么是分布式系统吗？Redis分布式锁都不会？>>> 1. 简介 红黑树是一种自平衡二叉查找树。它的统计性能要好于平衡二叉树（AVL树），因此，红黑树在很多地方都有应用。在C++ STL中，很多部分(目前包括set, multiset, map, multimap)应用了红黑树的变体(SGI STL中的红黑树有一些变化，这些修改提供了更好的性能，以及对set操...
『数据结构』红黑树(red-black tree)
mbinary
07-14 470
1. 定义与性质 红黑树是一种平衡的二叉查找树 1.1. 数据域 每个结点有 5 个数据域 * color: red or black * key: keyword * left: pointer to left child * right:pointer to right child * p: pointer to nil leaf 1.2. 红黑性质 满足下面的 ...
【数据结构】红黑树
最新发布
weixin_69380220的博客
08-18 1384
红黑树的模拟实现
数据结构---红黑树
MEANSWER的博客
06-09 254
红黑树1. 红黑树的概念2. 红黑树的性质3. 红黑树节点的定义4. 红黑树的插入操作5. 红黑树的验证6. 红黑树与AVL树的比较 1. 红黑树的概念 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。 2. 红黑树的性质 每个结点不是红色就是黑色 根节点是黑色的 如果一个节点是红色的，则它的两个孩子结点是黑色的 （不能有
数据结构：红黑树（Red Black Tree）
Gabriel.Tian的博客
07-29 514
概念 红黑树（Red Black Tree） 是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。红黑树和AVL树类似，都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。它可以在O(log n)时间内（它的查找最坏时间复杂度为O(2lgn)）做查找，插入和删除，这里的n 是树中元素的数目。 性质 节点是红色或黑色。 根节点是黑色...
数据结构--红黑树
杀神lwz的博客
03-20 560
一、红黑树 R-B Tree，全称是Red-Black Tree，又称为“红黑树”，它一种特殊的二叉查找树。红黑树的每个节点上都有存储位表示节点的颜色，可以是红(Red)或黑(Black)。 1、红黑树的特性 （1）每个节点或者是黑色，或者是红色。 （2）根节点是黑色。 （3）每个叶子节点（NIL）是黑色。 [注意：这里叶子节点，是指为空(NIL 或NULL)的叶子节点！] （4）如果一个节点是红色的，则它的子节点必须是黑色的。 （5）从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节
数据结构：红黑树原理与TreeMap、TreeSet
Sakura_lht
02-19 292
简单分析红黑树的概念与性质，重点关注红黑树的旋转、插入、删除等核心操作原理以及实现。浅析插入及删除操作循环内部的状态转换。全文参考自《算法导论》
浅析 AVL 树，红黑树，B 树，B+ 树
HU1656的博客
04-05 632
一. AVL 树 1.出现的原因 二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序，二叉搜索树将有可能退化为单支树，此时查找元素相当于在顺序表中查找元素，效率低下，相当于O(n)。 例如：对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树： 最优情况下，二叉搜索树为完全二叉树。 最差情况下，二叉搜索树退化为单支树。 2.定义 AVL 树是一种二叉平衡搜索树，...
Python数据结构之栈、队列及二叉树定义与用法浅析
09-19
### Python数据结构之栈、队列及二叉树定义与用法浅析 #### 栈 **栈**是一种特殊的线性表，它只能允许在一端进行插入和删除操作，这一端被称为栈顶(top)，另一端被称为栈底(bottom)。遵循先进后出（First In Last ...
数据结构 -- 红黑树
qq_40337206的博客
05-22 142
2-3 树 2-3 树是最简单的 B 树，2-3 树一颗绝对平衡的树，2-3 树满足二分搜索树的基本性质，在2-3 树中有两种节点，一种存放一个元素，另外一种存在两个元素。 2-3 树添加元素 红黑树 红黑树（Red Black Tree） 是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。 它是在1972年由Rudolf Bayer发明的，当时被称为平衡...
数据结构之红黑树
tangyongzhe的专栏
01-02 852
上一节我们自己简单实现了一棵二叉查找树（数据结构之二叉查找树），虽然理论上二叉查找树的搜索时间是Olngn和树高成正比，但是实际上二叉查找树的平衡性并不理想，因此后面又出来了平衡二叉树，红黑树就是一种平衡的二叉查找树，先来看下什么是二叉查找树，对应我们熟悉的二分法查找，二叉查找树非常类似，二叉查找树的定义如下： （1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值；  （2）
数据结构浅析：树与二叉树的概念与特性
"数据结构-树和二叉树" 在计算机科学中，数据结构是组织和存储数据的方式，以便于高效地访问和修改。树作为一种非线性数据结构，被广泛用于表示元素或节点间的一对多关系，如文件系统、网页链接、家族关系等。在本...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值