『数据结构』红黑树

最新推荐文章于 2023-11-13 19:45:52 发布

爱喝可乐的炸鸡

最新推荐文章于 2023-11-13 19:45:52 发布

阅读量224

点赞数 3

分类专栏：『数据结构』文章标签：数据结构红黑树

本文链接：https://blog.csdn.net/sss_0916/article/details/97375867

版权

『数据结构』专栏收录该内容

13 篇文章 1 订阅

订阅专栏

什么是红黑树？

红黑树（Red Black Tree）是一种自平衡二叉搜索树，但在每个节点上增加了一个存储位表示结点的颜色，可以是Red或Black。通过对任意一条从根到叶子路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出两倍，因而是近似平衡的。
它是在1972年有Rudolf Bayer发明的，当时被称为平衡二叉B树（symmetric binary B-trees）。后来，在1978年被Leo.J.Guibas和Robert Sedgewick修改为如今的“红黑树”。
红黑树和AVL树类似，都是在进行插入和删除操作时通过一定的操作保持二叉搜索树的平衡，从而获得比较高的查找特性。
在这里插入图片描述

红黑树的性质

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

红黑树是如何保证最长路径不超过最短路径的两倍的？

最短路径为全黑结点。
最长路径为黑红交替。

红黑结点的定义

// 结点的颜色
enum Color{
	RED, BLACK
};

// 红黑树结点
template<class K, class V>
struct RBTreeNode{

	RBTreeNode(const pair<K, V>& kv, Color color = RED)
		: _parent(nullptr)
		, _left(nullptr)
		, _right(nullptr)
		, _kv(kv)
		, _color(color)
	{}

	// 结点的双亲
	RBTreeNode<K, V>* _parent;
	// 结点的左孩子
	RBTreeNode<K, V>* _left;
	// 结点的右孩子
	RBTreeNode<K, V>* _right;
	pair<K, V> _kv;
	// 结点的颜色
	Color _color;

};

红黑树的插入操作

红黑树是在二叉搜索树的基础上加上其平衡限制条件，因此红黑树的插入可以分为两步：
首先，按照二叉搜索树的规则插入新节点。

// 二叉搜索树的插入
bool insert(const pair<K, V>& kv){
	// 空树
	if (_root == nullptr){
		_root = new Node(kv);

		return true;
	}

	// 树不为空
	Node* cur = _root;
	// 保存双亲
	Node* parent = nullptr;

	while (cur != nullptr){
		parent = cur;

		// 比当前结点大，去右树找
		if (kv.first > cur->_kv.first){
			cur = cur->_right;
		}
		// 比当前结点小，去左树找
		else if (kv.first < cur->_kv.first){
			cur = cur->_left;
		}
		// 相等，已经存在，插入失败
		else{
			return false;
		}
	}

	// 结点创建
	cur = new Node(kv);

	// 新创建的结点指向其双亲结点
	cur->_parent = parent;

	// 比双亲大，在双亲的右树
	if (kv.first > parent->_kv.first){
		parent->_right = cur;
	}
	// 比双亲小，在双亲的左树
	else{
		parent->_left = cur;
	}

	return true;
}

其次，检测新节点插入后，红黑树的性质是否遭到破坏。
因为新节点的颜色默认是红色，因此：如果双亲结点的颜色是黑色，没有违反红黑树任何性质，则不需要调整；但当新插入结点的双亲结点颜色为红色时，就违反了性质三不能有连在一起的红色结点，此时需要对红黑树分情况来讨论：
约定：cur为当前结点，p为父结点，g为祖父结点，u为叔叔结点。

情况一：cur为红，p为红，g为黑，u存在且为红。

解决方案：将p，u改为黑，g改为红，然后把g当成cur，继续向上调整。
情况二：cur为红，p为红，g为黑，u不存在/u为黑。

解决方案：
p为g的左孩子，cur为p的左孩子，则进行右单旋；
p为g的右孩子，cur为p的右孩子，则进行左单旋；
p变黑，g变红。
情况三：cur为红，p为红，g为黑，u不存在/u为黑。

解决方案：
p为g的左孩子，cur为p的右孩子，针对p做左单旋；
p为g的右孩子，cur为p的左孩子，针对p做右单旋；
就将情况三转化成了情况二。

// 红黑树的插入
bool insert(const pair<K, V>& kv){
	// 空树
	if (_root == nullptr){
		_root = new Node(kv);

		return true;
	}

	// 树不为空
	Node* cur = _root;
	// 保存双亲
	Node* parent = nullptr;

	while (cur != nullptr){
		parent = cur;

		// 比当前结点大，去右树找
		if (kv.first > cur->_kv.first){
			cur = cur->_right;
		}
		// 比当前结点小，去左树找
		else if (kv.first < cur->_kv.first){
			cur = cur->_left;
		}
		// 相等，已经存在，插入失败
		else{
			return false;
		}
	}

	// 结点创建
	cur = new Node(kv);

	// 新创建的结点指向其双亲结点
	cur->_parent = parent;

	// 比双亲大，在双亲的右树
	if (kv.first > parent->_kv.first){
		parent->_right = cur;
	}
	// 比双亲小，在双亲的左树
	else{
		parent->_left = cur;
	}

	// 父亲为黑色不违反规则，不需要调整
	// 父亲存在并且为红色
	while (parent && parent->_color == RED){
		// 祖父结点
		Node* grandparent = parent->_parent;
		// 如果父亲是祖父的左
		if (parent == grandparent->_left){
			// 叔叔结点
			Node* uncle = grandparent->_right;

			// 情况一：叔叔存在且为红
			if (uncle != nullptr && uncle->_color == RED){
				// 父亲和叔叔涂成黑，祖父涂成红
				parent->_color = BLACK;
				uncle->_color = BLACK;
				grandparent->_color = RED;

				// 祖父赋给cur，继续向上调整
				cur = grandparent;
				parent = parent->_parent;
			}
			// 情况二/三：叔叔不存在或者存在且为黑
			else{
				// 先处理情况三，将情况三转化为情况二
				if (cur = parent->_right){
					// 左单旋
					leftRotate(parent);

					// 交换parent和cur
					swap(parent, cur);
				}

				// 情况二：叔叔不存在或者存在且为黑
				// 右单旋
				rightRotate(grandparent);

				parent->_color = BLACK;
				grandparent->_color = RED;

				break;
			}
		}
		// 父亲是祖父的右
		else{
			// 叔叔结点是祖父结点的左
			Node* uncle = grandparent->_left;

			// 情况一：叔叔存在且为红
			if (uncle != nullptr && uncle->_color == RED){
				// 父亲，叔叔涂成黑色，祖父涂成红色
				parent->_color = BLACK;
				uncle->_color = BLACK;
				grandparent->_color = RED;

				// 将祖父赋给cur，继续向上调整
				cur = grandparent;
				parent = cur->_parent;
			}
			// 情况二/三：叔叔不存在/叔叔存在且为黑
			else{
				// 先处理情况三，将情况三转化为情况二
				if (cur = parent->_left){
					// 右单旋
					rightRotate(parent);

					// 交换parent和cur
					swap(parent, cur);
				}

				// 情况二：叔叔不存在/叔叔存在且为黑
				leftRotate(grandparent);

				// 父亲涂黑，祖父涂红
				parent->_color = BLACK;
				grandparent->_color = RED;

				break;
			}
		}
	}

	// 根节点涂黑
	_root->_color = BLACK;

	return true;
}

中间用到的树的旋转可以参考AVL树中的讲解。
AVL树

红黑树的验证

红黑树的验证分为两步：
首先，检测其是否满足二叉搜索树（中序遍历是否为有序序列）。

// 中序
void _inorder(Node* root){
	_inorder(root->_left);
	cout << root->_kv.first << " ";
	_inorder(root->_right);
}

// 中序遍历
void inorder(){
	_inOrder(_root);
	cout << endl;
}

其次，检测其是否满足红黑树的性质：

// 是不是红黑树
bool _isRBTree(Node* root, size_t cnt, size_t black_cnt){
	// 走到一条路径的尽头
	if (root == nullptr){
		// 判断黑色结点数是否相同
		if (cnt != black_cnt){
			cout << "违反性质四：每条路径中黑色结点的个数必须相同！" << endl;

			return false;
		}

		return true;
	}

	// 统计当前路径黑色结点数量
	if (root->_color == BLACK){
		++cnt;
	}

	// 检测当前结点与其双亲结点是否都是红色
	Node* parent = root->_parent;
	if (parent != nullptr && parent->_color == RED && root->_color == RED){
		cout << "违反性质三：没有连在一起的红色结点！" << endl;

		return false;
	}

	return _isRBTree(root->_left, cnt, black_cnt) &&
		_isRBTree(root->_right, cnt, black_cnt);
}

// 是不是红黑树
bool isRBTree(){
	Node* root = getRoot();

	// 空树是红黑树
	if (root == nullptr){
		return true;
	}

	// 检测根节点是否为黑色
	if (root->_color == BLACK){
		cout << "违反性质二：根结点必须为黑色！" << endl;

		return false;
	}

	// 获取任意一条路径的黑结点数量，这里选择最左路径
	size_t black_cnt = 0;
	Node* cur = root;
	while (cur != nullptr){
		if (cur->_color == BLACK){
			++black_cnt;
		}

		cur = cur->_left;
	}

	// 检测是否满足红黑树的性质，cnt用来记录路径中黑色结点的数量
	size_t cnt = 0;

	return _isRBTree(root, cnt, black_cnt);
}

红黑树和AVL树的比较

红黑树不追求“完全平衡”，即不像AVL那样要求结点的|bf| <= 1，它只要求部分达到平衡，但是提出了为结点增加颜色，红黑是用非严格的平衡来换取增删结点时候旋转次数的降低，任何不平衡都会在三次旋转之内解决，而AVL是严格平衡树，因此在增加或者删除结点的时候，根据不同情况，旋转的次数比红黑树更多。
就插入结点导致树失衡的情况，AVL和RBTree都是最多两次旋转来实现复衡，旋转的量级为O(1)；删除结点导致失衡，AVL树需要维护从被删除结点到根节点这条路径上所有结点的平衡，旋转的量级为O(log2(N))，而RBTree最多只需要旋转三次实现复衡，只需要O(1)，所以说RBTree删除结点后复衡的效率更高，开销更小。
AVL结构相较于RBTree更为平衡，插入和删除引起失衡，RBTree复衡效率更高；当然，由于AVL高度平衡，因此AVL的搜索效率更高。
针对插入和结点导致失衡后的复衡操作，红黑树能够提供一个比较便宜的解决方案，降低开销，是对查找、插入以及删除效率的折中，总体来说，RBTree的统计性能高于AVL。
实际应用中，若搜索的次数远远大于插入和删除，那么选择AVL，如果搜索，插入删除次数几乎差不多，应该选择RB。