C++数据结构 之 红黑树_Red Black Tree

最新推荐文章于 2023-03-03 23:08:29 发布
最新推荐文章于 2023-03-03 23:08:29 发布
阅读量1.7k 收藏 13
点赞数
分类专栏： C++、算法与数据结构 文章标签： c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liu798675179/article/details/52261042
版权

C++数据结构 之 红黑树_Red Black Tree

源代码只包含头文件

注：需要C++11的支持

一、红黑树

之前有篇文章讲解了什么是二叉搜索树，而红 黑树是一颗二叉搜索树，它在每一个节点上增加了一个存储位来表示节点的颜色 （Red or Black）。

通过任何一条从根节点到子叶的简单路径上个点的颜色约束，红黑树确保没有一条路径会比其他路径长出2倍，因而是近似平衡。

一颗红黑树是满足下面红黑性质的二叉搜索树：
（1）每一个节点毛么事红色，要么是黑色。
（2）根节点是黑色。
（3）每一个叶节点（NIL）是黑色。
（4）如果一个节点是红色，则它的两个子节点都是黑色。
（5）对每个节点，从该节点到其所有后代叶结点的简单路径上，均包含相同数目的黑色节点。

红黑树

支持的操作：
1、insert 插入元素
2、delete 删除元素
3、search 搜索元素
4、Inorder_Tree_Walk 中序遍历；Preorder_Tree_Walk 先序遍历；Postorder_Tree_Walk 后序遍历
5、Tree_Maximum、Tree_Minimum 基于键值（key）的最大最小值
5、Tree_Successor、Tree_Predecessor基于键值（key）的前驱后继

二、源代码：

（1）常规版本：

#ifndef RED_BLACK_TREE_H
#define RED_BLACK_TREE_H

#include <iostream>
#include <stack>
#include <memory>
#include <stdexcept>

using std::shared_ptr;
using std::cout;
using std::endl;

class RBT {
private:
	enum Color { Red, Black };

	struct Node {
		Node() = default;
		Node(const Color &c) : color(c) {}
		Node(const long long &d, const Color &c, const shared_ptr<Node> &p, const shared_ptr<Node> &l, const shared_ptr<Node> &r) :
			key(d), color(c), parent(p), left(l), right(r) {}

		long long key;
		Color color;
		shared_ptr<Node> parent = nullptr;
		shared_ptr<Node> left = nullptr;
		shared_ptr<Node> right = nullptr;
	};

	shared_ptr<Node> NIL = std::make_shared<Node>(Black);
	shared_ptr<Node> Root = NIL;

public:
	RBT() = default;
	~RBT() = default;

	void Inorder_Tree_Walk(const shared_ptr<Node> &p) {
		if (p != NIL) {
			Inorder_Tree_Walk(p->left);
			cout << p->key << " ";
			if (p->color == Black)
				cout << "Black " << endl;
			else
				cout << "Red " << endl;
			Inorder_Tree_Walk(p->right);
		}
	}
	void Inorder_Tree_Walk() {
		auto p = Root;
		if (p != NIL) {
			Inorder_Tree_Walk(p->left);
			cout << p->key << " ";
			if (p->color == Black)
				cout << "Black " << endl;
			else
				cout << "Red " << endl;
			Inorder_Tree_Walk(p->right);
		}
	}
	void Preorder_Tree_Walk(const shared_ptr<Node> &p) {
		if (p != NIL) {
			cout << p->key << " ";
			if (p->color == Black)
				cout << "Black " << endl;
			else
				cout << "Red " << endl;
			Preorder_Tree_Walk(p->left);
			Preorder_Tree_Walk(p->right);
		}
	}
	void Preorder_Tree_Walk() {
		auto p = Root;
		if (p != NIL) {
			cout << p->key << " ";
			if (p->color == Black)
				cout << "Black " << endl;
			else
				cout << "Red " << endl;
			Preorder_Tree_Walk(p->left);
			Preorder_Tree_Walk(p->right);
		}
	}
	void Postorder_Tree_Walk(const shared_ptr<Node> &p) {
		if (p != NIL) {
			Postorder_Tree_Walk(p->left);
			Postorder_Tree_Walk(p->right);
			cout << p->key << " ";
			if (p->color == Black)
				cout << "Black " << endl;
			else
				cout << "Red " << endl;
		}
	}
	void Postorder_Tree_Walk() {
		auto p = Root;
		if (p != NIL) {
			Postorder_Tree_Walk(p->left);
			Postorder_Tree_Walk(p->right);
			cout << p->key << " ";
			if (p->color == Black)
				cout << "Black " << endl;
			else
				cout << "Red " << endl;
		}
	}

	shared_ptr<Node> Tree_Successor(const long long &x) {
		auto p = Search(x);
		if (p->right != NIL) {
			return Tree_Successor(p->right->key);
		}

		auto y = p->parent;
		while (y != NIL && p == y->right) {
			p = y;
			y = y->parent;
		}

		return y;
	}

	shared_ptr<Node> Tree_Predecessor(const long long &x) {
		auto p = Search(x);
		if (p->left != NIL) {
			return Tree_Predecessor(p->left->key);
		}

		auto y = p->parent;
		while (y != NIL && p == y->left) {
			p = y;
			y = y->parent;
		}

		return y;
	}
	shared_ptr<Node> Tree_Maximum(const shared_ptr<Node> &Root) {
		auto p = Root;
		while (p->right != NIL) {
			p = p->right;
		}

		return p;
	}

	shared_ptr<Node> Tree_Minimum(const shared_ptr<Node> &Root) {
		auto p = Root;
		while (p->left != NIL) {
			p = p->left;
		}

		return p;
	}

	void Left_Rotate(shared_ptr<Node> Px) {
		auto Py = Px->right;
		Px->right = Py->left;

		if (Py->left != NIL) {
			Py->left->parent = Px;
		}
		Py->parent = Px->parent;
		if (Px->parent == NIL) {
			Root = Py;
		}
		else if (Px == Px->parent->left) {
			Px->parent->left = Py;
		}
		else {
			Px->parent->right = Py;
		}
		Py->left = Px;
		Px->parent = Py;
	}

	void Right_Rotate(shared_ptr<Node> Py) {
		auto Px = Py->left;
		Py->left = Px->right;

		if (Px->right != NIL) {
			Px->right->parent = Py;
		}
		Px->parent = Py->parent;
		if (Py->parent == NIL) {
			Root = Px;
		}
		else if (Py == Py->parent->left) {
			Py->parent->left = Px;
		}
		else {
			Py->parent->right = Px;
		}
		Px->right = Py;
		Py->parent = Px;
	}

	void Transplant(const shared_ptr<Node> &p1, const shared_ptr<Node> &P2) {
		if (p1->parent == NIL) {
			Root = P2;
		}
		else if (p1 == p1->parent->left) {
			p1->parent->left = P2;
		}
		else {
			p1->parent->right = P2;
		}
		P2->parent = p1->parent;
	}

	shared_ptr<Node> Search(const long long &x) {
		auto p = Root;
		while (p != NIL && x != p->key) {
			if (x < p->key) {
				p = p->left;
			}
			else {
				p = p->right;
			}
		}
		try {
			if (p == NIL) {
				throw std::runtime_error("The element was not found.");
			}
		}
		catch (std::runtime_error err) {
			cout << err.what() << endl;
		}
		return p;
	}

	void Insert(const long long &key) {
		shared_ptr<Node> New = std::make_shared<Node>(key, Red, NIL, NIL, NIL);
		auto Px = Root, Py = NIL;

		while (Px != NIL) {
			Py = Px;
			if (key < Px->key) {
				Px = Px->left;
			}
			else {
				Px = Px->right;
			}
		}

		New->parent = Py;
		if (Py == NIL) {
			Root = New;
		}
		else if (key < Py->key) {
			Py->left = New;
		}
		else {
			Py->right = New;
		}
		Rb_Insert_Fixup(New);
	}

	void Rb_Insert_Fixup(shared_ptr<Node> &p) {
		while (p->parent->color == Red) {
			if (p->parent == p->parent->parent->left) {
				auto Py = p->parent->parent->right;
				if (Py->color == Red) {
					p->parent->color = Black;
					Py->color = Black;
					p->parent->parent->color = Red;
					p = p->parent->parent;
				}
				else {
					if (p == p->parent->right) {
						p = p->parent;
						Left_Rotate(p);
					}
					p->parent->color = Black;
					p->parent->parent->color = Red;
					Right_Rotate(p->parent->parent);
				}
			}
			else {
				auto Py = p->parent->parent->left;
				if (Py->color == Red) {
					p->parent->color = Black;
					Py->color = Black;
					p->parent->parent->color = Red;
					p = p->parent->parent;
				}
				else {
					if (p == p->parent->left) {
						p = p->parent;
						Right_Rotate(p);
					}
					p->parent->color = Black;
					p->parent->parent->color = Red;
					Left_Rotate(p->parent->parent);
				}
			}
		}
		Root->color = Black;
	}

	void Delete(const long long &key) {
		auto p = Search(key);
		auto Py = p;
		shared_ptr<Node> Px;
		Color y_original_color = Py->color;

		if (p != NIL) {
			if (p->left == NIL) {
				Px = p->right;
				Transplant(p, p->right);
			}

			else if (p->right == NIL) {
				Px = p->left;
				Transplant(p, p->left);
			}
			else {
				Py = Tree_Minimum(p->right);
				y_original_color = Py->color;
				Px = Py->right;
				if (Py->parent == p) {
					Px->parent = Py;
				}
				else {
					Transplant(Py, Py->right);
					Py->right = p->right;
					Py->right->parent = Py;
				}
				Transplant(p, Py);
				Py->left = p->left;
				Py->left->parent = Py;
				Py->color = p->color;
			}
			if (y_original_color == Black) {
				Rb_Delete_Fixup(Px);
			}
		}
	}

	void Rb_Delete_Fixup(shared_ptr<Node> &p) {
		while (p != Root && p->color == Black) {
			if (p == p->parent->left) {
				auto w = p->parent->right;
				if (w->color == Red) {
					w->color = Black;
					p->parent->color = Red;
					Left_Rotate(p->parent);
					w = p->parent->right;
				}
				if (w->left->color == Black && w->right->color == Black) {
					w->color = Red;
					p = p->parent;
				}
				else {
					if (w->right->color == Black) {
						w->left->color = Black;
						w->color = Red;
						Right_Rotate(w);
						w = p->parent->right;
					}
					w->color = p->parent->color;
					p->parent->color = Black;
					w->right->color = Black;
					Left_Rotate(p->parent);
					p = Root;
				}
			}
			else {
				auto w = p->parent->left;
				if (w->color == Red) {
					w->color = Black;
					p->parent->color = Red;
					Right_Rotate(p->parent);
					w = p->parent->left;
				}
				if (w->right->color == Black && w->left->color == Black) {
					w->color = Red;
					p = p->parent;
				}
				else {
					if (w->left->color == Black) {
						w->right->color = Black;
						w->color = Red;
						Left_Rotate(w);
						w = p->parent->right;
					}
					w->color = p->parent->color;
					p->parent->color = Black;
					w->left->color = Black;
					Right_Rotate(p->parent);
					p = Root;
				}
			}
		}
		p->color = Black;
	}

	size_t Tree_Hight(const shared_ptr<Node> &p) {
		if (p != NIL) {
			size_t left = Tree_Hight(p->left);
			size_t right = Tree_Hight(p->right);
			if (left > right) {
				return left + 1;
			}
			else {
				return right + 1;
			}
		}
		else {
			return 0;
		}
	}

	size_t Tree_Hight() {
		return Tree_Hight(Root);
	}

};

#endif // !RED_BLACK_TREE_H

（2）带有卫星数据的版本：

然而就是这微小差别，导致了此版本只能在 x86 环境下才能良好运行。不知为何（°o°；）…

也许是hash函数的问题…

不过此版本比常规版本构建的二叉树更平衡。

#ifndef RED_BLACK_TREE_X86_H
#define RED_BLACK_TREE_X86_H

#include <iostream>
#include <memory>
#include <utility>
#include <stdexcept>
#include <functional>

using std::shared_ptr;
using std::pair;
using std::cout;
using std::endl;

template<typename T>
class RBT {
private:
	enum Color { Red, Black };

	struct Node {
		Node() = default;
		Node(const Color &c) : color(c) {}
		Node(const pair<size_t, T> &d, const Color &c, const shared_ptr<Node> &p, const shared_ptr<Node> &l, const shared_ptr<Node> &r) :
			data(d), color(c), parent(p), left(l), right(r) {}

		pair<size_t, T> data;
		Color color;
		shared_ptr<Node> parent = nullptr;
		shared_ptr<Node> left = nullptr;
		shared_ptr<Node> right = nullptr;
	};

	shared_ptr<Node> NIL = std::make_shared<Node>(Black);
	shared_ptr<Node> Root = NIL;

public:
	RBT() = default;
	~RBT() = default;

	size_t Hash_Val(const T &x) {
		return std::hash<T>()(x);
	}

	void Inorder_Tree_Walk(const shared_ptr<Node> &p) {
		if (p != NIL) {
			Inorder_Tree_Walk(p->left);
			cout << p->data.second << " ";
			if (p->color == Black)
				cout << "Black " << endl;
			else
				cout << "Red " << endl;
			Inorder_Tree_Walk(p->right);
		}
	}
	void Inorder_Tree_Walk() {
		auto p = Root;
		if (p != NIL) {
			Inorder_Tree_Walk(p->left);
			cout << p->data.second << " ";
			if (p->color == Black)
				cout << "Black " << endl;
			else
				cout << "Red " << endl;
			Inorder_Tree_Walk(p->right);
		}
	}
	void Preorder_Tree_Walk(const shared_ptr<Node> &p) {
		if (p != NIL) {
			cout << p->data.second << " ";
			if (p->color == Black)
				cout << "Black " << endl;
			else
				cout << "Red " << endl;
			Preorder_Tree_Walk(p->left);
			Preorder_Tree_Walk(p->right);
		}
	}
	void Preorder_Tree_Walk() {
		auto p = Root;
		if (p != NIL) {
			cout << p->data.second << " ";
			if (p->color == Black)
				cout << "Black " << endl;
			else
				cout << "Red " << endl;
			Preorder_Tree_Walk(p->left);
			Preorder_Tree_Walk(p->right);
		}
	}
	void Postorder_Tree_Walk(const shared_ptr<Node> &p) {
		if (p != NIL) {
			Postorder_Tree_Walk(p->left);
			Postorder_Tree_Walk(p->right);
			cout << p->data.second << " ";
			if (p->color == Black)
				cout << "Black " << endl;
			else
				cout << "Red " << endl;
		}
	}
	void Postorder_Tree_Walk() {
		auto p = Root;
		if (p != NIL) {
			Postorder_Tree_Walk(p->left);
			Postorder_Tree_Walk(p->right);
			cout << p->data.second << " ";
			if (p->color == Black)
				cout << "Black " << endl;
			else
				cout << "Red " << endl;
		}
	}

	shared_ptr<Node> Tree_Successor(const T &x) {
		auto p = Search(x);
		if (p->right != NIL) {
			return Tree_Successor(p->right->data.second);
		}

		auto y = p->parent;
		while (y != NIL && p == y->right) {
			p = y;
			y = y->parent;
		}

		return y;
	}

	shared_ptr<Node> Tree_Predecessor(const T &x) {
		auto p = Search(x);
		if (p->left != NIL) {
			return Tree_Predecessor(p->left->data.second);
		}

		auto y = p->parent;
		while (y != NIL && p == y->left) {
			p = y;
			y = y->parent;
		}

		return y;
	}

	shared_ptr<Node> Tree_Maximum(const shared_ptr<Node> &Root) {
		auto p = Root;
		while (p->right != NIL) {
			p = p->right;
		}

		return p;
	}

	shared_ptr<Node> Tree_Minimum(const shared_ptr<Node> &Root) {
		auto p = Root;
		while (p->left != NIL) {
			p = p->left;
		}

		return p;
	}

	void Left_Rotate(shared_ptr<Node> Px) {
		auto Py = Px->right;
		Px->right = Py->left;

		if (Py->left != NIL) {
			Py->left->parent = Px;
		}
		Py->parent = Px->parent;
		if (Px->parent == NIL) {
			Root = Py;
		}
		else if (Px == Px->parent->left) {
			Px->parent->left = Py;
		}
		else {
			Px->parent->right = Py;
		}
		Py->left = Px;
		Px->parent = Py;
	}

	void Right_Rotate(shared_ptr<Node> Py) {
		auto Px = Py->left;
		Py->left = Px->right;

		if (Px->right != NIL) {
			Px->right->parent = Py;
		}
		Px->parent = Py->parent;
		if (Py->parent == NIL) {
			Root = Px;
		}
		else if (Py == Py->parent->left) {
			Py->parent->left = Px;
		}
		else {
			Py->parent->right = Px;
		}
		Px->right = Py;
		Py->parent = Px;
	}

	void Transplant(const shared_ptr<Node> &p1, const shared_ptr<Node> &P2) {
		if (p1->parent == NIL) {
			Root = P2;
		}
		else if (p1 == p1->parent->left) {
			p1->parent->left = P2;
		}
		else {
			p1->parent->right = P2;
		}
		P2->parent = p1->parent;
	}

	shared_ptr<Node> Search(const T &x) {
		auto temp = Hash_Val(x);
		auto p = Root;
		while (p != NIL && temp != p->data.first) {
			if (temp < p->data.first) {
				p = p->left;
			}
			else {
				p = p->right;
			}
		}
		try {
			if (p == NIL) {
				throw std::runtime_error("The element was not found.");
			}
		}
		catch (std::runtime_error err) {
			cout << err.what() << endl;
		}
		return p;
	}

	void Insert(const T &x) {
		auto temp = Hash_Val(x);
		shared_ptr<Node> New = std::make_shared<Node>(std::make_pair(temp, x), Red, NIL, NIL, NIL);
		auto Px = Root, Py = NIL;

		while (Px != NIL) {
			Py = Px;
			if (temp < Px->data.first) {
				Px = Px->left;
			}
			else {
				Px = Px->right;
			}
		}

		New->parent = Py;
		if (Py == NIL) {
			Root = New;
		}
		else if (temp < Py->data.first) {
			Py->left = New;
		}
		else {
			Py->right = New;
		}
		Rb_Insert_Fixup(New);
	}

	void Rb_Insert_Fixup(shared_ptr<Node> &p) {
		while (p->parent->color == Red) {
			if (p->parent == p->parent->parent->left) {
				auto Py = p->parent->parent->right;
				if (Py->color == Red) {
					p->parent->color = Black;
					Py->color = Black;
					p->parent->parent->color = Red;
					p = p->parent->parent;
				}
				else {
					if (p == p->parent->right) {
						p = p->parent;
						Left_Rotate(p);
					}
					p->parent->color = Black;
					p->parent->parent->color = Red;
					Right_Rotate(p->parent->parent);
				}
			}
			else {
				auto Py = p->parent->parent->left;
				if (Py->color == Red) {
					p->parent->color = Black;
					Py->color = Black;
					p->parent->parent->color = Red;
					p = p->parent->parent;
				}
				else {
					if (p == p->parent->left) {
						p = p->parent;
						Right_Rotate(p);
					}
					p->parent->color = Black;
					p->parent->parent->color = Red;
					Left_Rotate(p->parent->parent);
				}
			}
		}
		Root->color = Black;
	}

	void Delete(const T &x) {
		auto p = Search(x);
		auto Py = p;
		shared_ptr<Node> Px;
		Color y_original_color = Py->color;

		if (p != NIL) {
			if (p->left == NIL) {
				Px = p->right;
				Transplant(p, p->right);
			}

			else if (p->right == NIL) {
				Px = p->left;
				Transplant(p, p->left);
			}
			else {
				Py = Tree_Minimum(p->right);
				y_original_color = Py->color;
				Px = Py->right;
				if (Py->parent == p) {
					Px->parent = Py;
				}
				else {
					Transplant(Py, Py->right);
					Py->right = p->right;
					Py->right->parent = Py;
				}
				Transplant(p, Py);
				Py->left = p->left;
				Py->left->parent = Py;
				Py->color = p->color;
			}
			if (y_original_color == Black) {
				Rb_Delete_Fixup(Px);
			}
		}
	}

	void Rb_Delete_Fixup(shared_ptr<Node> &p) {
		while (p != Root && p->color == Black) {
			if (p == p->parent->left) {
				auto w = p->parent->right;
				if (w->color == Red) {
					w->color = Black;
					p->parent->color = Red;
					Left_Rotate(p->parent);
					w = p->parent->right;
				}
				if (w->left->color == Black && w->right->color == Black) {
					w->color = Red;
					p = p->parent;
				}
				else {
					if (w->right->color == Black) {
						w->left->color = Black;
						w->color = Red;
						Right_Rotate(w);
						w = p->parent->right;
					}
					w->color = p->parent->color;
					p->parent->color = Black;
					w->right->color = Black;
					Left_Rotate(p->parent);
					p = Root;
				}
			}
			else {
				auto w = p->parent->left;
				if (w->color == Red) {
					w->color = Black;
					p->parent->color = Red;
					Right_Rotate(p->parent);
					w = p->parent->left;
				}
				if (w->right->color == Black && w->left->color == Black) {
					w->color = Red;
					p = p->parent;
				}
				else {
					if (w->left->color == Black) {
						w->right->color = Black;
						w->color = Red;
						Left_Rotate(w);
						w = p->parent->right;
					}
					w->color = p->parent->color;
					p->parent->color = Black;
					w->left->color = Black;
					Right_Rotate(p->parent);
					p = Root;
				}
			}
		}
		p->color = Black;
	}

	size_t Tree_Hight(const shared_ptr<Node> &p) {
		if (p != NIL) {
			size_t left = Tree_Hight(p->left);
			size_t right = Tree_Hight(p->right);
			if (left > right) {
				return left + 1;
			}
			else {
				return right + 1;
			}
		}
		else {
			return 0;
		}
	}

	size_t Tree_Hight() {
		return Tree_Hight(Root);
	}

};

#endif // !RED_BLACK_TREE_X86_H
_MICHAEL_LIU_
关注
专栏目录
【C++】红黑树（Red Black Tree）
knous
08-04 511
红黑树的一些操作
【数据结构】红黑树（Red Black Tree）
HaYa
02-28 599
前言 以前在了解HashMap时得知JDK8的HashMap是用红黑树实现的，而且网上还流传着手写红黑树的梗，数据结构课上也没交过这个，于是就学学吧。 一、为什么要用红黑树 因为相较于普通的二叉搜索树，红黑树具有平衡性。这与AVL树相似，在增加或删除元素后可能会出现旋转的操作。 但是相较于AVL树严格的约束（左右子树的高度之差的绝对值最多为1），红黑树的平衡约束更为宽松，其旋转操作的时间复杂度为O...
C++构建红黑树
weixin_33733810的博客
06-13 180
#include "iostream" using namespace std; class Node { public: int data; bool red; Node *parent = NULL; Node *lchild = NULL; Node *rchild = NULL; Node(int data, bool red = true)...
【C++研发面试笔记】11. 基本数据结构-红黑树RBT
tostq的专栏
10-03 2618
【C++研发面试笔记】11. 基本数据结构-红黑树RBT上一节，我们提到了为了解决二叉查找树不平衡问题，我们引入了AVL树，AVL是严格平衡树，但在增加或删除节点时，需要非常多的旋转操作。因此这一节我们介绍红黑树，红黑是弱平衡的，用非严格的平衡来换取增删节点时候旋转次数的降低，其在在增加或删除节点时，旋转操作要比AVL树更少；因此当搜索的次数远远大于插入和删除，则选择AVL树，如果搜索，插入删除次数
C++ 实现红黑树结构
枫铃树
01-23 1392
C++ 面向对象实现红黑树结构。
C++数据结构与算法（红黑树）
鄠邑原野的博客
08-15 399
前情回顾：一棵高度为h的二叉搜索树，它可以支持任何一种基本动态几何操作，如查找、插入、删除等，其时间复杂度为O(h)。因此，如果搜索树的高度较低时，这些集合操作会执行得较快。然而，如果树的高度较高，这些集合操作可能比链表慢。红黑树（red-black tree）是许多“平衡”搜索树中的一种，可以保证在最坏情况下基本动态集合操作的时间复杂度为O(logn)。 Q1：什么是红黑树？ ...
RBT.rar_red black tree_红黑树
09-24
红黑树（Red-Black Tree）是一种自平衡二叉查找树，由计算机科学家鲁道夫·贝尔在1978年提出。它在保持二叉查找树特性的同时，通过引入颜色属性来确保树的平衡，从而提高数据操作的效率。在C++中实现红黑树，通常...
rbt.rar_rbt_red black tree_动态演示_红黑树
09-14
红黑树（Red-Black Tree）是一种自平衡二叉查找树，由计算机科学家Rudolf Bayer于1972年提出。它在保持了二叉查找树基本特性的同时，通过额外的颜色属性实现了高效的插入、删除和查找操作。红黑树的名字来源于它的...
数据结构之红黑树（Red/Black Tree）
于琦海
12-30 379
1、前言 我们知道java8中hashmap的数据结构为数组+链表+红黑树，看到很多资料里面写的红黑树的内容有点不对，所以结合我给出的GIF图来熟悉下红黑树的数据结构 2、红黑树的性质 结点是红色或黑色 根节点必须是黑色 每个叶子结点都是黑色（注意：每个叶子结点都是Null） 红色结点不能够连接在一起,也就是所有路径都不能有两个连续的红色结点 任意一个结点到每个叶子结点的所有路径中所包含的黑色结点数量是相等的 3、构建红黑树 根结点为黑色，也就是说第一个元素插入的时候是黑色的，后续的都为红色。原
红黑树（Red Black Tree）
02-13
红黑树（Red Black Tree）是一种自平衡二叉查找树，由计算机科学家Rudolf Bayer在1972年提出。这种数据结构在现代计算机科学中广泛应用，特别是在各种需要高效查找、插入和删除操作的场景中。红黑树的主要特点是通过...
C++/数据结构——红黑树的基本操作
Wz_still_shuai的博客
10-19 313
红黑树 一.概念： 本质上还是一棵二叉搜索树，每个节点又多了一个属性——结点的颜色，每个节点不是红色就是黑色。 二.性质： 1.根节点是黑色 2.对于每个节点而言，从该节点到其后代叶节点路径上的黑色结点数目都是相同的 3.不能有连续的红色结点出现。 三.实现 主要是旋转的情况： 1.叔叔节点存在且为红色 只需修改将父节点、叔叔节点、祖父节点的颜色即可 2.叔叔节点不存在...
构建红黑树--C++版
u013005150的专栏
07-24 325
根据《普林斯顿算法》实现了红黑树的C++版本 红黑树的树形修整基于三个基本操作，即左旋，右旋和镜像 左旋示意图： 右旋示意图 镜像示意图： 树形结构调整示意图 C++ 版 code: //红黑树 enum Color { RED, BLACK }; struct RBNode { int key; int value; RBNode *pleft; RBNode *pright; int count; Color ...
红黑树头文件C语言
让阳光照进心里
03-14 1567
<br />  红黑树,记得刚买那本书的时候我就发现有这个东西,觉得很神秘,终于接触到了,并且,我已经写出来了.很高兴.<br />  插入的例程是书上自带的,我给代码实现了.细节部分,我并不是很清楚.删除例程,是自己写的,全下来写了大概15小时,很辛苦.昨天晚上到家就开始写,今天到家也是立刻就开始写,写完了.<br />  我想说的是,关于删除例程, 算法部分的自己构建我很满意,旋转部分的细节实现以及细节,也是自己发现并总结的,而且是对的.很辛苦的过程啊,坚持过来了,哈哈.<br />  并没有模块化删除
数据结构-红黑树(Red-Black Tree)的C++实现模板
weixin_34290352的博客
08-21 143
2019独角兽企业重金招聘Python工程师标准>>> ...
数据结构学习笔记------红黑树（附c++代码）
Andy123321aa的博客
11-21 447
目录： 1、 红黑树简介 2、 左旋和右旋操作 3、 添加节点操作 4、 删除节点操作 1、红黑树简介 红黑树是二叉查找树的一种，其增删改查的统计性能要优于AVL树，查找、插入、删除算法的复杂度都为O(log(n))。先附上红黑树这种数据结构的性质： 性质1、节点是红色或黑色。 性质2、根节点是黑色。 性质3、每个叶节点（是指的空节点，nil节点）是黑色的。 性质4、每个红色节点的两个子节点都是黑...
数据结构——红黑树（red-black tree）
02-29 1756
红黑树在改变元素数量和元素搜索方面都很出色，它保证节点安插时最多只会做两个重新链接（relink）的动作，而且到达某一元素的最长路径的深度，至多只是最短路径的深度的两倍。STL 中的重要容器——set/multiset 通常以红黑树（red-black tree）实现。
红黑树
青青的专栏--C/C++ OOA/D Design Pattern
10-15 570
红黑树一棵红黑树是指一棵满足下述性质的二叉搜索树（BST, binary search tree）：1. 每个结点或者为黑色或者为红色。2. 根结点为黑色。3. 每个叶结点(NIL)都是黑色的。4. 如果一个结点是红色的，那么它的两个子节点都是黑色的（也就是说，不能有两个相邻的红色结点）。5. 对于每个结点，从该结点到其所有子孙叶结点的路径中所包含的黑色结点数量必须相同。
C++数据结构 —— 红黑树
最新发布
weixin_59913110的博客
03-03 4864
enum Corlor //枚举颜色RED,BLACKtemplate //为了方便，使用K模型K _key;{}
C++实现红黑树
Amber的博客
01-27 1468
一、概念 红黑树是一棵二叉搜索树，它和AVL树的区别就是，红黑树没有平衡因子，而是在每个结点上增加了一个存储位来表示结点的颜色，可以是red或者black，通过对任何一条从根节点到叶子结点简单路径上的颜色来约束，红黑树保证最长路径不超过最短路径的两倍，因而近似平衡，而且在实际应用中发现红黑树性能比AVL树性能要高。 二、性质 每个结点不是红色就是黑色 树的根节点是黑色的 如果一个节
c++11实现红黑树
changke的博客
12-15 419
红黑树实现过程难度主要集中在删除节点上，考虑的情况比较多！下面是删除节点的再次总结！上次的总结了一部分，现在我将它补充完整！ 删除节点的后继节点是父亲节点的左子树：总共四种情况 当删除节点的后继节点是父亲的右子树： 下面是实现的运行的运行截图： 插入的多组测试用例并打印层次遍历的红黑树插入后结果： 删除节点测试： 源代码 欢迎star和fork哦～～～ ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值