C++实现简单的红黑树

最新推荐文章于 2023-05-27 21:31:14 发布
最新推荐文章于 2023-05-27 21:31:14 发布
阅读量242 收藏
点赞数
分类专栏： C++ 数据结构 文章标签： 红黑树 数据结构 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kuaijg/article/details/95913964
版权

红黑树简单介绍

红黑树是带有颜色属性的自平衡二叉查找树。对红黑树的操作在最坏情形下花费O(logN)时间，红黑树的高度最多是2log(N+1)。

红黑树是具有下列着色性质的二叉查找树：
1、每一个节点或者着成红色，或者着成黑色；
2、根是黑色的；
3、如果一个节点是红色的，那么它的子节点必须是黑色的；
4、从一个节点到一个NULL指针的每一条路径必须包含相同数目的黑色节点。

作者：下午茶609 来源：CSDN 原文：https://blog.csdn.net/u013565099/article/details/77731726
版权声明：本文为博主原创文章，转载请附上博文链接！

红黑树等价于2-3树

以下C++实现添加功能。

代码由AVL修改而来。

#define _CRK_SECURE_NO_WARNINGS
#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
using namespace std;

int max(int a, int b) {
	return a > b ? a : b;
}
static bool RED = true;
static bool BLACK = false;

template<class K, class V>
class Node
{
public:
	K key;
	V value;
	int height;
	Node* left;
	Node* right;
	bool color;
	Node() {
		this->height = 0;
		this->left = NULL;
		this->right = NULL;
		color = RED;
	}
	Node(K key, V value) {
		this->key = key;
		this->value = value;
		this->height = 1;
		color = RED;
		this->left = NULL;
		this->right = NULL;
	}
};


template<class K, class V>
class RBT {
public:
	RBT() {
		root = NULL;
		size = 0;
	}
	int Size() {
		return size;
	}

	int GetHeight(Node<K, V>* node) {
		if (node == NULL) {
			return 0;
		}
		return node->height;
	}
	int Height() {
		return GetHeight(root);
	}
	int GetBalanceFactor(Node<K, V>* node) {
		if (node == NULL) {
			return 0;
		}
		return GetHeight(node->left) - GetHeight(node->right);
	}
	bool IsBST() {
		vector<K> keys;
		InOrder(root, keys);
		for (int i = 1; i < (int)keys.size(); i++) {
			if (keys[i - 1] > keys[i]) {
				return false;
			}
		}
		return true;
	}
	void InOrder(Node<K, V>* node, vector<K> keys) {
		if (node == NULL) {
			return;
		}
		InOrder(node->left, keys);
		keys.push_back(node->key);
		InOrder(node->right, keys);
	}
	bool IsBalanced() {
		return IsBalanced(root);
	}
	bool IsBalanced(Node<K, V>* node) {
		if (node == NULL) {
			return true;
		}
		int bf = GetBalanceFactor(node);
		if (abs(bf) > 1) {
			return false;
		}
		return IsBalanced(node->left) && IsBalanced(node->right);
	}

	void add(K key, V value) {
		root = add(root, key, value);
		root->color = BLACK;
	}
	bool Contains(K key) {
		return GetNode(root, key) != NULL;
	}

	Node<K, V>* GetNode(Node<K, V>* node, K key) {
		if (node == NULL) {
			return NULL;
		}
		if (key == node->key) {
			return node;
		}
		else if (key < node->key) {
			return GetNode(node->left, key);
		}
		else {
			return GetNode(node->right, key);
		}
	}
	V Get(K key) {
		Node<K, V>* node = GetNode(root, key);
		return node == NULL ? NULL : node->value;
	}
	void set(K key, V value) {
		Node<K, V>* node = GetNode(root, key);
		if (node == NULL) {
			return;
		}
		node->value = value;
	}
	Node<K, V>* minimum(Node<K, V>* node) {
		if (node->left == NULL) {
			return node;
		}
		return minimum(node->left);
	}
	K minimumKey() {
		return minimum(root)->key;
	}

	void preOrder()
	{
		preOrder(root);
	}
	void inOrder()
	{
		inOrder(root);
	}
	void postOrder()
	{
		postOrder(root);
	}

private:
	bool IsRed(Node<K, V>*node) {
		if (node == NULL) {
			return BLACK;
		}
		return node->color;
	}

	void FlipColors(Node<K, V>*node) {
		node->color = RED;
		node->left->color = BLACK;
		node->right->color = BLACK;
	}

	void preOrder(Node<K, V>*node) const
	{
		if (node != NULL)
		{
			cout << node->key << "," << node->value << ";";
			preOrder(node->left);
			preOrder(node->right);
		}
	}
	void inOrder(Node<K, V>*node) const
	{
		if (node != NULL)
		{
			inOrder(node->left);
			cout << node->key << "," << node->value << ";";
			inOrder(node->right);
		}
	}
	void postOrder(Node<K, V>*node) const
	{
		if (node != NULL)
		{
			postOrder(node->left);
			postOrder(node->right);
			cout << node->key << "," << node->value << ";";
		}
	}



	//node为根
	Node<K, V>* add(Node<K, V>* node, K e, V value) {
		if (node == NULL) {
			size++;
			return new Node<K, V>(e, value);
		}
		else if (e < node->key) {
			node->left = add(node->left, e, value);
		}
		else if (e > node->key) {
			node->right = add(node->right, e, value);
		}
		else {
			node->value = value;
		}
		if (IsRed(node->right) && !IsRed(node->left)) {
			node = LeftRotate(node);
		}
		if (IsRed(node->left) && IsRed(node->left->left)) {
			node = RightRotate(node);
		}
		if (IsRed(node->left) && IsRed(node->right)) {
			FlipColors(node);
		}
		node->height = 1 + max(GetHeight(node->left), GetHeight(node->right));
		int balancefactor = GetBalanceFactor(node);
		if (abs(balancefactor) > 1) {
			cout << balancefactor << endl;
		}
		return node;
	}
	Node<K, V>* RightRotate(Node<K, V>* node) {
		Node<K, V>* x = node->left;
		//右旋转
		node->left = x->right;
		x->right = node;
		x->color = node->color;
		node->color = RED;
		return x;
	}
	Node<K, V>* LeftRotate(Node<K, V>* node) {
		Node<K, V>* x = node->right;
		//左旋转
		node->right = x->left;
		x->left = node;
		x->color = node->color;
		node->color = RED;
		return x;
	}

private:
	Node<K, V>* root;
	int size;
};

template<class K, class V>
class AVLT {
public:
	AVLT() {
		root = NULL;
		size = 0;
	}
	int Size() {
		return size;
	}

	int GetHeight(Node<K, V>* node) {
		if (node == NULL) {
			return 0;
		}
		return node->height;
	}
	int Height() {
		return GetHeight(root);
	}
	int GetBalanceFactor(Node<K, V>* node) {
		if (node == NULL) {
			return 0;
		}
		return GetHeight(node->left) - GetHeight(node->right);
	}
	bool IsBST() {
		vector<K> keys;
		InOrder(root, keys);
		for (int i = 1; i < (int)keys.size(); i++) {
			if (keys[i - 1] > keys[i]) {
				return false;
			}
		}
		return true;
	}
	void InOrder(Node<K, V>* node, vector<K> keys) {
		if (node == NULL) {
			return;
		}
		InOrder(node->left, keys);
		keys.push_back(node->key);
		InOrder(node->right, keys);
	}
	bool IsBalanced() {
		return IsBalanced(root);
	}
	bool IsBalanced(Node<K, V>* node) {
		if (node == NULL) {
			return true;
		}
		int bf = GetBalanceFactor(node);
		if (abs(bf) > 1) {
			return false;
		}
		return IsBalanced(node->left) && IsBalanced(node->right);
	}

	void add(K key, V value) {
		root = add(root, key, value);
	}
	bool Contains(K key) {
		return GetNode(root, key) != NULL;
	}

	Node<K, V>* GetNode(Node<K, V>* node, K key) {
		if (node == NULL) {
			return NULL;
		}
		if (key == node->key) {
			return node;
		}
		else if (key < node->key) {
			return GetNode(node->left, key);
		}
		else {
			return GetNode(node->right, key);
		}
	}
	V Get(K key) {
		Node<K, V>* node = GetNode(root, key);
		return node == NULL ? NULL : node->value;
	}
	void set(K key, V value) {
		Node<K, V>* node = GetNode(root, key);
		if (node == NULL) {
			return;
		}
		node->value = value;
	}
	Node<K, V>* minimum(Node<K, V>* node) {
		if (node->left == NULL) {
			return node;
		}
		return minimum(node->left);
	}
	K minimumKey() {
		return minimum(root)->key;
	}
	V Remove(K key) {
		Node<K, V>* node = GetNode(root, key);
		if (node != NULL) {
			root = Remove(root, key);
			return node->value;
		}
		return NULL;
	}

	void preOrder()
	{
		preOrder(root);
	}
	void inOrder()
	{
		inOrder(root);
	}
	void postOrder()
	{
		postOrder(root);
	}

private:
	void preOrder(Node<K, V>*node) const
	{
		if (node != NULL)
		{
			cout << node->key << "," << node->value << ";";
			preOrder(node->left);
			preOrder(node->right);
		}
	}
	void inOrder(Node<K, V>*node) const
	{
		if (node != NULL)
		{
			inOrder(node->left);
			cout << node->key << "," << node->value << ";";
			inOrder(node->right);
		}
	}
	void postOrder(Node<K, V>*node) const
	{
		if (node != NULL)
		{
			postOrder(node->left);
			postOrder(node->right);
			cout << node->key << "," << node->value << ";";
		}
	}
	Node<K, V>* Remove(Node<K, V>* node, K key) {
		if (node == NULL) {
			return NULL;
		}
		Node<K, V>* ret;
		if (key < node->key) {
			node->left = Remove(node->left, key);
			ret = node;
		}
		else if (key > node->key) {
			node->right = Remove(node->right, key);
			ret = node;
		}
		else {
			if (node->left == NULL) {
				Node<K, V>* rn = node->right;
				node->right = NULL;
				size--;
				ret = rn;
			}
			else if (node->right == NULL) {
				Node<K, V>* ln = node->left;
				node->left = NULL;
				size--;
				ret = ln;
			}
			else
			{
				Node<K, V>* newroot = minimum(node->right);
				newroot->right = Remove(node->right, newroot->key);
				newroot->left = node->left;
				node->left = node->right = NULL;
				ret = newroot;
			}
		}
		if (ret == NULL) {
			return NULL;
		}
		ret->height = 1 + max(GetHeight(ret->left), GetHeight(ret->right));
		int balancefactor = GetBalanceFactor(ret);

		//左边较大，LL右旋转
		if (balancefactor > 1 && GetBalanceFactor(ret->left) >= 0) {
			return RightRotate(ret);
		}
		//左边较大，RR右旋转
		if (balancefactor < -1 && GetBalanceFactor(ret->right) <= 0) {
			return LeftRotate(ret);
		}
		//右边较大，LR左旋转，右旋转
		if (balancefactor > 1 && GetBalanceFactor(ret->left) < 0) {
			ret->left = LeftRotate(ret->left);
			return RightRotate(ret);
		}
		//右边较大，RL右旋转，左旋转
		if (balancefactor < -1 && GetBalanceFactor(ret->right) > 0) {
			ret->right = RightRotate(ret->right);
			return LeftRotate(ret);
		}
		if (abs(balancefactor) > 1) {
			cout << balancefactor << endl;
		}
		return ret;
	}


	//node为根
	Node<K, V>* add(Node<K, V>* node, K e, V value) {
		if (node == NULL) {
			size++;
			return new Node<K, V>(e, value);
		}
		else if (e < node->key) {
			node->left = add(node->left, e, value);
		}
		else if (e > node->key) {
			node->right = add(node->right, e, value);
		}
		else {
			node->value = value;
		}
		node->height = 1 + max(GetHeight(node->left), GetHeight(node->right));
		int balancefactor = GetBalanceFactor(node);

		//左边较大，LL右旋转
		if (balancefactor > 1 && GetBalanceFactor(node->left) >= 0) {
			return RightRotate(node);
		}
		//左边较大，RR右旋转
		if (balancefactor < -1 && GetBalanceFactor(node->right) <= 0) {
			return LeftRotate(node);
		}
		//右边较大，LR左旋转，右旋转
		if (balancefactor > 1 && GetBalanceFactor(node->left) < 0) {
			node->left = LeftRotate(node->left);
			return RightRotate(node);
		}
		//右边较大，RL右旋转，左旋转
		if (balancefactor < -1 && GetBalanceFactor(node->right) > 0) {
			node->right = RightRotate(node->right);
			return LeftRotate(node);
		}
		int balancefactor = GetBalanceFactor(node);
		if (abs(balancefactor) > 1) {
			cout << balancefactor << endl;
		}
		return node;
	}
	Node<K, V>* RightRotate(Node<K, V>* y) {
		Node<K, V>* x = y->left;
		//右旋转
		y->left = x->right;
		x->right = y;
		//更新高度
		y->height = 1 + max(GetHeight(y->left), GetHeight(y->right));
		x->height = 1 + max(GetHeight(x->left), y->height);
		return x;
	}
	Node<K, V>* LeftRotate(Node<K, V>* y) {
		Node<K, V>* x = y->right;
		//左旋转
		y->right = x->left;
		x->left = y;

		//更新高度
		y->height = 1 + max(GetHeight(y->left), GetHeight(y->right));
		x->height = 1 + max(y->height, GetHeight(x->right));
		return x;
	}

private:
	Node<K, V>* root;
	int size;
};




int main(void)
{
	ifstream infile("D:\\Desktop\\Clianxi\\C++\\trie\\testfile\\1.Harry Potter and the Sorcerer's Stone.txt");
	if (!infile.is_open()) {
		return -1;
	}
	vector<string> words;
	RBT<string, int> rbt;
	AVLT<string, int> avlt;
	while (!infile.eof())
	{
		string line, tmp;
		while (infile >> tmp) {
			tmp.erase(0, tmp.find_first_not_of(" "));
			words.push_back(tmp);
			if (avlt.Contains(tmp)) {
				avlt.set(tmp, avlt.Get(tmp) + 1);
			}
			else
				avlt.add(tmp, 1);
			if (rbt.Contains(tmp)) {
				rbt.set(tmp, rbt.Get(tmp) + 1);
			}
			else
				rbt.add(tmp, 1);

		}
	}
	infile.close();
	cout << "不同单词" << avlt.Size() << endl;
	cout << "___________" << endl;
	cout << "不同单词" << rbt.Size() << endl;
	cout << "___________" << endl;
	cout << "isBST  " << avlt.IsBST() << endl;
	cout << "isBST  " << rbt.IsBST() << endl;
	cout << "isBanlanced  " << avlt.IsBalanced() << endl;
	cout << "isBanlanced  " << rbt.IsBalanced() << endl;
	system("pause");
	return 0;
}
没事多喝白开水
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
红黑树的理解与编写（c++实现）
yy的学习blog
04-17 8168
红黑树的理解与c++编写 基础性质 红黑树是一种二叉搜索树，并且相对于二叉搜索树做了一定的改进。 红黑树具有下列五种性质： 根节点黑色。 每个节点为红色/黑色。 红色节点下两个节点必为黑色。 每一条从根至叶的路径上的黑节点数量相同。 每个叶节点都是黑的。 从五个性质可以得出的结论是，红黑树树内节点数n≥2h/2−1n≥2h/2−1n\ge2^{h/2}-1 证明省略，可以看C...
红黑树（C++实现）
热门推荐
2021dragon的博客
12-06 1万+
红黑树（C++实现）
C++实现红黑树
hdsHDS6的博客
06-28 1589
C++实现红黑树，插入和删除思路
C++实现一个简单的红黑树（RB_TREE）
github_33736971的博客
05-10 1902
红黑树遵守的规则：一头（根）一脚（叶子节点）黑（黑色），黑同（从任意节点开始至根结点的黑色节点的个数相等）红不连（红色节点不能相连）以下是红黑树的插入和旋转函数的简易实现：#include <iostream> #include <assert.h> #include <string.h>using namespace std;typedef int Type; typedef enum{RED=0
C++简单实现红黑树的插入
最新发布
06-06
总的来说，C++实现红黑树的插入操作涉及到对红黑树特性的深入理解、节点结构体的设计、颜色调整规则的编码以及旋转操作的实现。这是一项既挑战性又富有成就感的任务，能帮助开发者更好地掌握数据结构和算法。
红黑树-基于C++实现的红黑树数据结构.zip
03-21
在C++中实现红黑树时，通常会定义一个名为`RBTree`的类，包含私有成员变量（如根节点指针）和公共成员函数（如`insert`, `delete`, `search`等）。类的构造函数初始化空树，而析构函数则负责释放所有节点。为了确保...
使用C++实现的rbtree红黑树.zip
03-21
C++代码实现红黑树时，需要定义一个节点结构体，包含键值、颜色、左子节点、右子节点和父节点等成员。同时，需要实现插入、删除、搜索、旋转和颜色翻转等方法。为了便于操作，可以使用模板类实现，这样红黑树可以...
C++数据结构 红黑树 实现全部功能
12-29
在C++中实现红黑树，通常会涉及到面向对象编程的概念，如类的设计和继承。 在C++中，红黑树的实现通常包含以下几个关键部分： 1. **节点定义**：首先，我们需要定义一个红黑树节点类，它包含了键值、颜色（红色或...
C++红黑树实现过程
09-15
在C++中实现红黑树，需要理解并遵循红黑树的五个性质： 1. 每个节点要么是红色，要么是黑色。 2. 根节点是黑色。 3. 所有叶子节点（NIL或空节点）是黑色。 4. 如果一个节点是红色，则它的两个子节点都是黑色。 5. ...
【C++】红黑树
大三小白C++进阶之路
05-27 1103
红黑树的模拟实现
C++之红黑树
cls的博客
05-23 1679
红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。 4.2.2 红黑树的性质 1. 每个结点不是红色就是黑色 2. 根节点是黑色的 3. 如果一个节点是红色的，则它的两个孩子结点是黑色的，但是没有连续的红节点 4. 对于每个结点，从该结点到其所有后代叶结点的简单路径...
红黑树（C++代码实现+原理简介）
玩遍每座城
04-04 3416
Red-Black Tree 说明 本文根据<<Introduction to algorithm>>一书的第13章 Red-Black Tree以及MIT OCW课程6.046J对红黑树的教学内容（网易公开课上面有这个课的中文翻译版本），使用C++语言，对书中的红黑树数据结构进行了实现。只是个人的学习笔记记录，除了代码之外，其他部分对红黑树原理的解释比较粗陋，暂不具有太大...
手写红黑树
chenmi123321的博客
05-26 902
该程序实现了红黑树的插入和中序遍历操作。在每次插入节点时，都会通过左旋、右旋和颜色翻转等操作来维持红黑树的性质。
红黑树的详细实现(C++)
code_peak
10-08 6030
红黑树概念(concept) 树型结构主要用于搜索，一直是科学领域的重要演算法，当中探讨了树可能遇到的问题：树的成长可能偏向于一边，也就是不平衡现象。 二叉树是常见且广泛使用的一种树，面临其可能退化成链表的潜藏缺点，在使用上难免让人担心其效率。此外，在一些应用上，可能不希望这样的不平衡的可能性发生。所以具有自动平衡左右数量分布效果的演算算法早在 1962 年被提出，称为 AVL 树。这种平衡成长的二叉搜索树被称为自平衡二叉搜索树。 接下来，介绍同为自平衡二叉搜索树的红黑树对平衡性的要求比 AVL 树还要宽松
红黑树(C++实现)
weixin_45599288的博客
01-16 4952
红黑树红黑树的概念红黑树的性质红黑树的结点定义红黑树的插入情况一情况二情况三红黑树的查找红黑树的验证红黑树的和AVL树的比较 红黑树的概念 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是红色或黑色。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。如下图： 红黑树的性质 每个结点不是红色就是黑色 根节点是黑色的 如果一个节点是红色的，则它的两个孩子结点是黑色的 对于每个结点，从该结点到其所有后代叶结点的简
手写一棵红黑树
zstu_cc的专栏
10-30 1万+
笔者博客地址：https://charpty.com 我记得面试的时候，经常问问别人hashmap实现，说着说着就免不了讲讲红黑树，平常都是用现成的，考察别人红黑树也只是看下是否喜欢专研、有学习劲。 有一次有个同学告诉我他讲不清楚但是可以写一下，很惭愧，全忘了，一下子让我写一个，伪代码都够呛了，跑起来更不行。 我给自己想了个简单的记法，父红叔红就变色，父红叔黑靠旋转，删黑两孩很麻烦，叔黑孩最很...
红黑树简易C++实现
每天完成一个小目标
03-13 390
原因 这几天研究了红黑树,光说不练假把式,于是就自己手动实现一下 数据结构声明 #include &lt;bits/stdc++.h&gt; using namespace std; enum Color{ RED = 0, BLACK }; // 红黑树节点RB_Node struct RB_Node{ int val; Color color; RB_Node *left; RB...
C++实现的红黑树详解及应用
"这篇资源主要介绍了红黑树的实现，以C++语言为载体，讨论了红黑树作为自平衡二叉查找树的特性和应用。文中提到了红黑树与二叉排序树、平衡二叉树（如AVL树）的关系，并详细阐述了红黑树的5大性质，以及在插入和删除...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值