C++ 红黑树

插衣袖里

已于 2024-05-24 23:09:46 修改

阅读量44

点赞数

分类专栏： C++ 文章标签： c++ 开发语言

于 2023-07-13 21:45:00 首次发布

本文链接：https://blog.csdn.net/m0_66409987/article/details/131690125

版权

C++ 专栏收录该内容

37 篇文章 0 订阅

订阅专栏

parent在 grandfather的左边的情况

情况1（uncle存在且为红）：只需要变色

情况2（uncle存在且为黑）：变色+旋转

情况3（uncle不存在）：变色+旋转

parent在 grandfather的右边的情况（省略）

插入代码实现：

红黑树的主要功能实现代码呈现

红黑树与AVL树的比较

前言

对于平衡树来说，AVL无疑是最完美的结构，但实际上AVL树由于完美的结构因此也要花费一定的代价，由于AVL树的结构很敏感，查找虽然最快，但插入节点后一旦偏离AVL结构就会进行旋转，而旋转就会花费一定的性能。因此我们提到的map和set的底层为了防止这种性能上的缺失，即便AVL是非常完美的结构，也不采用AVL。而是采用红黑树。

红黑树的概念

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

红黑树的性质

每个结点不是红色就是黑色
根节点是黑色的
如果一个节点是红色的，则它的两个孩子结点是黑色的（即没有连续红色节点）
对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点
每个叶子结点都是黑色的（此处的叶子结点指的是空结点，如上图的NIL节点）

红黑树不追求极致的平衡，AVL树则是追求极致的平衡，红黑树是近似平衡；红黑树这种近似平衡的结构大大减少了大量的旋转，红黑树的综合性能优于 AVL树

最优情况（左右平衡）：全黑或每条路径都是一黑一红相间的满二叉树，搜索高度 logN
最差情况（左右极不平衡）：每颗子树左子树全黑，右子树一黑一红，搜索高度 2*logN

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

红黑树的最短路径：全黑，一条路径上的全是黑色节点
红黑树的最长路径：一黑一红相间的路径

红黑树的定义

红黑树也是使用键值对，即KV模型，也是为了方便后序操作，红黑树的结构也是三叉链，即增加了指向父节点的 parent指针，还增加了一个成员变量，用于标识节点的颜色（red or black）

#pragma once

enum Color  // 这里使用了枚举来列举颜色
{
	BLACK,
	RED,
};

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)
		:_parent(nullptr),
		_left(nullptr),
		_right(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)
	{}
	// 左单旋
	void RotateL(Node* parent)
	{}

	// 右单旋
	void RotateR(Node* parent)
	{}

	Node* find(const K& key)
	{}

private:
	Node* _root = nullptr;
};

红黑树的插入

为什么构造红黑树结点时，默认将结点的颜色设置为红色？

插入结点如果是黑色的，一定破坏红黑树的性质4(对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点)，无论如何都必须对红黑树进行调整。

插入结点如果是红色的，可能破坏红黑树的性质3(如果一个节点是红色的，则它的两个孩子结点是黑色的（即没有连续红色节点）)，可能需要对红黑树进行调整或者不需要调整

所以将插入节点颜色默认设置为红色

红黑树的插入与AVL树的插入一样分两步只是第二步稍有不同：

首先按照二叉搜索树的方式插入新节点
根据红黑树的性质判断是否需要进行调整

插入节点

规则：

待插入结点的key值比当前结点小就插入到该结点的左子树
待插入结点的key值比当前结点大就插入到该结点的右子树
待插入结点的key值与当前结点的 key 值相等就插入失败

节点调整

判断条件：当插入节点(颜色默认是红色) 的父亲parent存在且为红色，则需要调整，反之就不需要调整。

两种情况：

parent在 grandfather(parent的父亲) 的左边

parent在 grandfather(parent的父亲) 的右边

调整的关键是uncle(插入节点的叔叔)

parent在 grandfather的左边的情况

情况1：uncle存在且为红，uncle和parent的颜色需要修改为黑，granfather 修改为红，如果满足判断条件继续往上调整
情况2：uncle存在且为黑，需要对红黑树进行旋转，再调整颜色
情况3：uncle不存在，需要对红黑树进行旋转，在调整颜色

情况2和情况3的旋转与插入节点的位置有关：

当插入的节点在parent的左边（即呈一条直线）进行右单旋

当插入的节点在parent的右边（即呈一条折线）进行左右双旋

情况1（uncle存在且为红）：只需要变色

无论cur是在parent的左边还是右边没有影响。

情况2（uncle存在且为黑）：变色+旋转

1、当插入的节点在parent的左边（即呈一条直线）进行右单旋

2、当插入的节点在parent的右边（即呈一条折线）进行左右双旋

情况3（uncle不存在）：变色+旋转

1、当插入的节点在parent的左边（即呈一条直线）进行右单旋

2、当插入的节点在parent的右边（即呈一条折线）进行左右双旋

parent在 grandfather的右边的情况（省略）

与在左边的情况只有在旋转不同

情况1：uncle存在且为红，uncle和parent的颜色需要修改为黑，granfather 修改为红，如果满足判断条件继续往上调整
情况2：uncle存在且为黑，需要对红黑树进行旋转，再调整颜色
情况3：uncle不存在，需要对红黑树进行旋转，在调整颜色

情况2和情况3的旋转与插入节点的位置有关：

当插入的节点在parent的左边（即呈一条折线）进行右左双旋

当插入的节点在parent的右边（即呈一条直线）进行左单旋

插入代码实现：

	bool Insert(const pair<K, V>& kv)
	{
		// 1.按搜索树的规则进行插入
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}

		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (kv.first < cur->_kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (kv.first > cur->_kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false; // 这里不能写break
			}
		}

		cur = new Node(kv);

		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
		}
		else if (parent->_kv.first > kv.first)
		{
			parent->_left = cur;
		}
		cur->_parent = parent;

		// 新增红的结点
		cur->_col = RED;

		while (parent && parent -> _col == RED)
		{
			// 红黑色的条件关键看叔叔
			Node* grandfather = parent->_parent;
			if (grandfather->_left == parent)
			{
				Node* uncle = grandfather->_right;

				// 情况1：uncle存在，且为红
				// 情况2 or 情况3：uncle不存在 or uncle存在,且为黑
				if (uncle && uncle->_col == RED)
				{
					uncle->_col = BLACK;
					parent->_col = BLACK;
					grandfather->_col = RED;

					// 继续往上处理
					cur = grandfather;
					parent = cur->_parent; // 如果parent为空，即cur为_root,直接在最后将根变黑
				}
				else
				{
					// 情况三：双旋 -> 单旋
					if (cur == parent->_right)
					{
						RotateL(parent);
						swap(parent, cur);// 交换的两个结点的指针
					}

					// 第二种情况（ps：有可能是第三种变过来的）
					RotateR(grandfather);
					grandfather->_col = RED;
					parent->_col = BLACK;
					break;

				}

			}
			else if (grandfather->_right == parent)
			{
				Node* uncle = grandfather->_left;

				// 情况1：uncle存在，且为红
				// 情况2 or 情况3：uncle不存在 or uncle存在,且为黑
				if (uncle && uncle->_col == RED)
				{
					uncle->_col = BLACK;
					parent->_col = BLACK;
					grandfather->_col = RED;

					// 继续往上处理
					cur = grandfather;
					parent = cur->_parent; // 如果parent为空，即cur为_root,直接在最后将根变黑
				}
				else
				{
					// 情况三：双旋 -> 单旋
					if (cur == parent->_left)
					{
						RotateR(parent);
						swap(parent, cur); // 交换的两个结点的指针
					}
					// 第二种情况（ps：有可能是第三种变过来的）
					RotateL(grandfather);
					grandfather->_col = RED;
					parent->_col = BLACK;
					break;
				}

			}

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

红黑树的主要功能实现代码呈现

RBTree.h

#pragma once

enum Color
{
	BLACK,
	RED,
};

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)
		:_parent(nullptr),
		_left(nullptr),
		_right(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)
	{
		// 1.按搜索树的规则进行插入
		if (_root == nullptr)
		{
			_root = new Node(kv);
			_root->_col = BLACK;
			return true;
		}

		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (kv.first < cur->_kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (kv.first > cur->_kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false; // 这里不能写break
			}
		}

		cur = new Node(kv);

		if (parent->_kv.first < kv.first)
		{
			parent->_right = cur;
		}
		else if (parent->_kv.first > kv.first)
		{
			parent->_left = cur;
		}
		cur->_parent = parent;

		// 新增红的结点
		cur->_col = RED;

		while (parent && parent -> _col == RED)
		{
			// 红黑色的条件关键看叔叔
			Node* grandfather = parent->_parent;
			if (grandfather->_left == parent)
			{
				Node* uncle = grandfather->_right;

				// 情况1：uncle存在，且为红
				// 情况2 or 情况3：uncle不存在 or uncle存在,且为黑
				if (uncle && uncle->_col == RED)
				{
					uncle->_col = BLACK;
					parent->_col = BLACK;
					grandfather->_col = RED;

					// 继续往上处理
					cur = grandfather;
					parent = cur->_parent; // 如果parent为空，即cur为_root,直接在最后将根变黑
				}
				else
				{
					// 情况三：双旋 -> 单旋
					if (cur == parent->_right)
					{
						RotateL(parent);
						swap(parent, cur);
					}

					// 第二种情况（ps：有可能是第三种变过来的）
					RotateR(grandfather);
					grandfather->_col = RED;
					parent->_col = BLACK;
					break;

				}

			}
			else if (grandfather->_right == parent)
			{
				Node* uncle = grandfather->_left;

				// 情况1：uncle存在，且为红
				// 情况2 or 情况3：uncle不存在 or uncle存在,且为黑
				if (uncle && uncle->_col == RED)
				{
					uncle->_col = BLACK;
					parent->_col = BLACK;
					grandfather->_col = RED;

					// 继续往上处理
					cur = grandfather;
					parent = cur->_parent; // 如果parent为空，即cur为_root,直接在最后将根变黑
				}
				else
				{
					// 情况三：双旋 -> 单旋
					if (cur == parent->_left)
					{
						RotateR(parent);
						swap(parent, cur); // 交换的两个结点的指针
					}
					// 第二种情况（ps：有可能是第三种变过来的）
					RotateL(grandfather);
					grandfather->_col = RED;
					parent->_col = BLACK;
					break;

				}

			}

		}

		_root->_col = BLACK;
		return true;

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

		parent->_right = subRLeft;
		if (subRLeft)
		{
			subRLeft->_parent = parent;
		}
		Node* pparent = parent->_parent;

		subR->_left = parent;//
		parent->_parent = subR;

		// parent 是根
		// parent 不是根
		if (_root == parent)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			if (pparent->_left == parent)
			{
				pparent->_left = subR;
			}
			else
			{
				pparent->_right = subR;
			}
			subR->_parent = pparent;
		}

	}

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

		parent->_left = subLRight;
		if (subLRight)
		{
			subLRight->_parent = parent;
		}
		Node* pparent = parent->_parent;
		subL->_right = parent; // 
		parent->_parent = subL;

		// parent 是根
		// parent 不是根
		if (_root == parent)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (pparent->_left == parent)
			{
				pparent->_left = subL;
			}
			else
			{
				pparent->_right = subL;
			}
			subL->_parent = pparent;
		}
		
	}

	Node* find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key > key)
				cur = cur->left;
			else if (cur->_key < key)
				cur = cur->right;
			else
				return cur;
		}
		return nullptr;
	}


	void _InOrder(Node* root) // 注意是Node* 类型的
	{
		if (root == nullptr) return;

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

	}

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

	bool IsBalance()//检查是否为红黑树结构
	{
		if (_root == nullptr)
		{
			return true;
		}

		if (_root->_col != BLACK)
		{
			return false;
		}

		int ref = 0;
		Node* left = _root;
		while (left)
		{
			if (left->_col == BLACK)
			{
				++ref;
			}

			left = left->_left;
		} 
		//遍历这棵树，就好了，检查是否存在连续的红结点。
		//检查父亲，因为孩子不一定有，但是一定有父亲
		return Check(_root, 0, ref);
	}
private:
	Node* _root = nullptr;

	bool Check(Node* root, int blackNum, int ref)
	{
		if (root == nullptr)
		{
			if (blackNum != ref)
			{
				cout << "违反规则：一条路径上的黑色节点数量不同" << endl;
				return false;
			}
			return true;
		}

		if (root->_col == RED && root->_parent->_col == RED)
		{
			cout << "违反规则，出现连续红色结点" << endl;
		}
		if (root->_col == BLACK)
		{
			++blackNum;
		}
		return Check(root->_left, blackNum, ref)
			&& Check(root->_right, blackNum, ref);
	}
};

Test.cpp

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
#include"RBTree1.h"

void test_RBTree()
{
	//int a[] = { 16,3,7,11,9,26,18,14,15 };
	int a[] = { 4,2,6,1,3,5,15,7,16,14 };
	RBTree<int, int> t;
	for (auto& e : a)
	{
		t.Insert(make_pair(e, e));

	}
	t.InOrder();
	cout<<t.IsBalance();
}

int main()
{
	//test_RBTree();
	return 0;
}

红黑树与AVL树的比较

红黑树和 AVL树都是高效的平衡二叉树，增删改查的时间复杂度都是O(logN)，红黑树不追求绝对平衡，其只需保证最长路径不超过最短路径的2倍，相对而言，降低了插入和旋转的次数，所以在经常进行增删的结构中性能比 AVL树更优，而且红黑树实现比较简单，所以实际运用中红黑树更多

插衣袖里

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
C++ 红黑树

对于平衡树来说，AVL无疑是最完美的结构，但实际上AVL树由于完美的结构因此也要花费一定的代价，由于AVL树的结构很敏感，查找虽然最快，但插入节点后一旦偏离AVL结构就会进行旋转，而旋转就会花费一定的性能。因此我们提到的map和set的底层为了防止这种性能上的缺失，即便AVL是非常完美的结构，也不采用AVL。而是采用红黑树。
复制链接

扫一扫