红黑树可运行代码C++ 使用无父指针的节点构造

最新推荐文章于 2024-11-10 22:49:00 发布
最新推荐文章于 2024-11-10 22:49:00 发布
阅读量412 收藏
点赞数
文章标签： 数据结构 c++ 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41026469/article/details/104319344
版权

C++实现仅有孩子节点的红黑树

在旋转时用栈存储叔叔父亲祖先等等。
支持基本的插删查。
使用该红黑树编写的Map通过部分OJ，未发现bug。

/* 
此版本无父指针，旋转时用栈确定祖先。
使用该红黑树编写的Map通过部分OJ，未发现bug
*/ 
#include <queue>
#include <vector>
#include <stack> 
#include <iostream>
#include <algorithm>
using namespace std;
#define RefValue -1e8
#define red 0
#define black 1
template<class K, class E>
struct RBNode {
	bool color;
	K key;
 	E data;
	RBNode<K, E> *left, *right;
	RBNode() {
		left = NULL;
		right = NULL;
		color = red;
	}
	RBNode(E d, K k, bool c = red, RBNode<K, E> *l = NULL, RBNode<K, E> *r = NULL) {
		data = d;
		left = l;
		right = r;
		key = k;
		color = c;
	}
};
template<class K, class E>
class RBTree{
public:
	RBNode<K, E> *root;
	size_t _size;
	void RotateL(RBNode<K, E> *&ptr) {
		RBNode<K, E> *subL = ptr;
		ptr = ptr->right;
		subL->right = ptr->left;
		ptr->left = subL;
	}
	void RotateR(RBNode<K, E> *&ptr) {
		RBNode<K, E> *subR = ptr;
		ptr = ptr->left;
		subR->left = ptr->right;
		ptr->right = subR;
	}
	E & Search(RBNode<K, E> *&ptr, K k, bool& found) {
		E tmp();
		RBNode<K, E> *cur = ptr;
		while (cur != NULL) {
			if (k == cur->key) {
				found = true;
				return cur->data;
			}
			else if (k < cur->key) cur = cur->left;
			else cur = cur->right;
		}
		found = false;
		return tmp;
	}
	bool Insert(RBNode<K, E> *&ptr, E d, K k) {
		RBNode<K, E> *cur = NULL, *p = NULL, *pp = NULL;
		if (ptr == NULL) {
			ptr = new RBNode<K, E>(d, k, black);
			++_size;
			return true;
		}
		stack<RBNode<K, E> *> st;
		cur = ptr;
		while (cur != NULL) {
			st.push(cur);
			pp = p;
			p = cur;
			if (k == cur->key) return false;
			else if (k < cur->key) cur = cur->left;
			else cur = cur->right;
		}
		cur = new RBNode<K, E>(d, k, red);
		++_size;
		if (k < p->key) {
			p->left = cur;
		}
		else p->right = cur;
		if (p->color == black) return true;
		while(st.top() != pp) {
			st.pop();
		}
		st.pop();
		while (true) {
			RBNode<K, E> *uncle = (pp->left == p) ? pp->right : pp->left;
			if (p->color == black) break; 
	  		else if (uncle != NULL && uncle->color == red) {
				pp->left->color = pp->right->color = black;
				if (pp == root) break;
				pp->color = red;
				cur = pp;
			} 
			else if (uncle == NULL || uncle->color == black) {
				RBNode<K, E> *orgpp = pp; //原先的pp 
				if (pp->left == p) {
					if (cur == p->right) {
						RotateL(p);
						pp->left = p;
						cur = p->left;
					}
					pp->color = red;
					p->color = black;
					RotateR(pp); 
				}
				else if (pp->right == p) {
					if (cur == p->left) {
						RotateR(p);
						pp->right = p;
						cur = p->right;	
					}
					pp->color = red;
					p->color = black;
					RotateL(pp); 
				}
				if (st.empty()) {
					root = pp;
				}
				else {
					RBNode<K, E> *ppp = st.top();
					if (ppp->left == orgpp) ppp->left = pp;
					else ppp->right = pp;
				}
				break;
			}
			p = st.top();//注意此时栈一定不空，如果空的话，前面一定break掉了，所以可以果断弹出 
			st.pop();
			if (!st.empty()) { //这时候栈空不空就要看命了，如果这时候栈空，那么p就是root，下一次循环直接break，用不到pp 
				pp = st.top();
				st.pop();
			}
		}
		return true;
	}
	bool Remove(RBNode<K, E> *&ptr, K k) {
		/*第一步是要找到删除节点*/
		RBNode<K, E> *cur = NULL, *p = NULL, *brother = NULL;
		stack<RBNode<K, E> *> st;
		cur = ptr;
		while (cur != NULL) {
			st.push(cur);
			p = cur;
			if (k == cur->key) {
				break;
			}
			else if (k < cur->key) cur = cur->left;
			else cur = cur->right;
		}
		if (cur == NULL) {
			//cout << cur << endl; 
			return false;
		}
		--_size;
		if (st.top() == root && root->left == NULL && root->right == NULL) {
			delete root;
			root = NULL;
			return true;
		}
		/*锁定替代节点，要求是叶节点或者只挂载一个孩子*/
		if (cur->left != NULL && cur->right != NULL) {
			RBNode<K, E> *subT = cur->right; //subT将是cur在中序下的后继节点，中序后继一定在右子树上
			p = cur;
			stack<RBNode<K, E> *> inOrderst;
			/*下面这个循环是迭代寻找中序后继*/
			while (subT != NULL || !inOrderst.empty()) {
				if (subT != NULL) {
					inOrderst.push(subT);
					st.push(subT); 
					subT = subT->left;
				}
				else {
					subT = inOrderst.top();		
					break;
				}
			}
			cur->data = subT->data;
			cur->key = subT->key;
			//cout << cur->key << "replace\n";
			cur = subT; 
		} 
		/*待删节点有一个孩子，待删节点肯定是黑色，而且这个孩子肯定是红色。
		处理方式是待删节点父节点接上这个孩子，这个孩子置黑 
		如果这个待删节点是通过上面找后继找出来的，如果这个待删节点有一个孩子，一定是右孩子*/
		st.pop();
		if (!st.empty()) {
			p = st.top();//将p赋值为代替节点的父节点 
			st.pop();
		}
		if (cur->left != NULL) {
			cur->left->color = black;
			if (cur != root) {
				if (p->left == cur) p->left = cur->left;
				else p->right = cur->left;
			}	
			else root = cur->left;
			delete cur;
			return true;
		}
		else if (cur->right != NULL){
			cur->right->color = black;
			if (cur != root) {
				if (p->left == cur) p->left = cur->right;
				else p->right = cur->right;
			}	
			else root = cur->right;
			delete cur;
			return true;
		}
		/*待删节点是叶节点*/
		else if (cur->color == red){
			if (p->left == cur) p->left = NULL;
			else p->right = NULL;
			delete cur;
			return true; 
		} 
		/*待删的节点是黑色的叶节点，
		注意根到待删节点的完整路径已经存在st中， 
		并且路径包含根和这个代替节点*/
			/*黑色节点，需要考虑的情况比较多。注意如果待删节点是黑色，那么他一定有兄弟，不然也不满足黑色平衡
			同时他兄弟有子节点也只可能是红色的！！！不可能有黑色子节点！！因为他自己是叶节点，这样会破坏平衡性*/
		else {
			RBNode<K, E> *pDel = cur, *ppDel = p;
			while (true) {
				//cout << "ASD" << endl;
				//cout << st.size();
				brother = (p->left == cur) ? p->right : p->left;
				RBNode<K, E> *orgp = p;
				if (cur->color == red || cur == root) {
					if (pDel == ppDel->left) ppDel->left = NULL;
					else pDel->right = NULL;
					delete pDel;
					return true;
				}
				//cout << "ASDsd" << endl;
				if (cur == p->left) {			
					if (brother->color == red) { //兄弟节点是红的，由于红黑树平衡性要求，兄弟节点必有两个黑色子节点，而且父节点是黑色 
						p->color = red;
						brother->color = black;
						brother = brother->left; //为了可以经过情况四的处理 
						RotateL(p);
						if (st.empty()) root = p;
						else {
							RBNode<K, E> *pp = st.top();
							if (pp->left == orgp) pp->left = p;
							else pp->right = p;
						}
						p = p->left;//新的双亲 
					}//再经过一次情况四的处理即可结束 
					else if (brother->color == black) {
						//cout << "brother == black" << endl;
						if (brother->right != NULL && brother->right->color == red) {
							swap(brother->color, p->color);
							brother->right->color = black;
							RotateL(p);
							if (st.empty()) root = p;
							else {
								RBNode<K, E> *pp = st.top();
								if (pp->left == orgp) pp->left = p;
								else pp->right = p;
							}
							break;
						}
						else if ((brother->right == NULL || brother->right->color == black) && 
							(brother->left != NULL && brother->left->color == red)) {
							swap(brother->color, brother->left->color);
							RotateR(brother);
							p->right = brother;
						}//再经过一次情况二处理即可 
						/*左旋一次，直接删除，结束*/

						else if ((brother->right == NULL || brother->right->color == black) && ( 
							brother->left == NULL || brother->left->color == black)) {
							//cout << "double NULL" << endl;
							if (brother->color == black) { 
								brother->color = red;
								cur = p;
							} 
							if (!st.empty()) {
								p = st.top();	
								st.pop();
							}
						}
					}
				}
				else {
					if (brother->color == red) { //兄弟节点是红的，由于红黑树平衡性要求，兄弟节点必有两个黑色子节点，而且父节点是黑色 
						p->color = red;
						brother->color = black;
						brother = brother->right; //为了可以经过情况四的处理 
						RotateR(p);
						if (st.empty()) root = p;
						else {
							RBNode<K, E> *pp = st.top();
							if (pp->left == orgp) pp->left = p;
							else pp->right = p;
						}
						p = p->right;//新的双亲 
					}//再经过一次情况四的处理即可结束 
					else if (brother->color == black) {
						//cout << "brother == black" << endl;
						if (brother->left != NULL && brother->left->color == red) {
							swap(brother->color, p->color);
							brother->left->color = black;
							RotateR(p);
							if (st.empty()) root = p;
							else {
								RBNode<K, E> *pp = st.top();
								if (pp->left == orgp) pp->left = p;
								else pp->right = p;
							}
							break;
						}
						else if ((brother->left == NULL || brother->left->color == black) && 
							(brother->right != NULL && brother->right->color == red)) {
							swap(brother->color, brother->right->color);
							RotateR(brother);
							p->left = brother;
						}//再经过一次情况二处理即可 
						/*左旋一次，直接删除，结束*/

						else if ((brother->right == NULL || brother->right->color == black) && ( 
							brother->left == NULL || brother->left->color == black)) {
							//cout << "double NULL" << endl;
							if (brother->color == black) { 
								brother->color = red;
								cur = p;
							} 
							if (!st.empty()) {
								p = st.top();	
								st.pop();
							}
						}
					}
				}
			}
			if (cur == ppDel->left) ppDel->left = NULL;
			else ppDel->right = NULL;
			cur->color = black;
			delete pDel;
			return true;
		}
	}
	void delete_tree(RBNode<K, E> *ptr) {
		if (ptr != NULL) {
			delete_tree(ptr->left);
			delete_tree(ptr->right);
			delete ptr;
		}
	}
	void preOrder(RBNode<K, E> *ptr) {
		if (ptr != NULL) {
			cout << ptr->data << " color" << ptr->color << endl;
			preOrder(ptr->left);
			preOrder(ptr->right);
		}
	}
	void inOrder(RBNode<K, E> *ptr) {
		if (ptr != NULL) {
			inOrder(ptr->left);
			cout << ptr->data << " color" << ptr->color << endl;
			inOrder(ptr->right);
		}
	}
	void testRBTree(RBNode<K, E> *ptr, int &deep) {
		if (ptr != NULL) {
			if (ptr->color == black) {
				++deep;
			}
			testRBTree(ptr->left, deep);
			testRBTree(ptr->right, deep);
			if (ptr->color == black) --deep;
		}
		else {
			cout << deep << endl;
		}
	}
	
public:
	RBTree(): root(NULL), _size(0) {}
	~RBTree() {
		delete_tree(root);
		root = NULL;
	}
	size_t size() {
		return _size;
	}
	E & Search(K k) {//这个Search实际上是为了Map写的，如果查不到，就插入该节点，这是STL map使用[]访问时的行为 ！！ 
		bool found = false;
		E &result = Search(root, k, found);
		if (found == false) {
			Insert(E(), k);
			return Search(root, k, found);
		}
		return result;
	}
	bool Contains(K k) {
		bool found = false;
		Search(root, k, found);
		return found;
	}
	bool Insert(E d, K k) {
		return Insert(root, d, k);
	}
	bool Remove(K k) {
		return Remove(root, k);
	}
	void showInOrder() {
		inOrder(root);
	}
	void showPreOrder(){
		preOrder(root);
	}
	void testRB() {
		int deep = 0;
		testRBTree(root, deep);
	}
};

附简易Map代码

#include <iostream>
#include "RBTree.h"
using namespace std;

template <class K, class E>
class Map {
	RBTree<K, E> tree;
public:
	Map() {}
	size_t size() {
		return tree.size();
	}
	bool empty() {
		return tree.size() == 0;
	}
	
	E & operator[](K i) {
		return tree.Search(i);
	}
	bool contains(K k) {
		return tree.Contains(k);
	} 
};
不带父结点的红黑树实现
z84616995z的专栏
06-25 1445
红黑树不带父结点实现
C++ 中的红黑树
leigh的博客
07-17 420
标准的STL关联式容器可分为两大类set（集合）和map（映射表/字典），以及这两大类的衍生体multiset和multimap。一般而言，关联式容器的内部结构都是一个平衡二叉树，以便获得良好的搜寻效率。平衡二叉树有很多种类型，其中最被广泛运用于STL的是RB-tree（红黑树）。RB-tree也是一个独立容器，但并不开放给外界使用。 此外 SGI STL 还提供了一个不在标砖规格之外的关联式容...
算法11---红黑树不带父结点指针的插入实现
weixin_34232617的博客
09-27 296
算法11---红黑树不带父结点指针的插入实现 1 #include <iostream> 2 using namespace std; 3 #define BLACK 0 4 #define RED 1 5 #define Nil -1 6 #define LEN sizeof(struct Tree) 7 struct Tree 8...
对红黑树的认识总结
热门推荐
张彦峰的博客
05-12 171万+
当在红黑树中执行插入操作时，需要考虑两个主要方面：保持二叉搜索树性质和保持红黑性质。以下是插入操作的详细步骤，包括可能的旋转操作和颜色调整。插入操作的基本步骤：首先，将新节点插入到红黑树中，就像在普通的二叉搜索树中一样。新节点会被标记为红色，因为它可能会破坏红黑性质的第一个性质（根节点必须是黑色）。插入新节点后，可能会破坏红黑性质。需要通过一系列的操作来调整以确保所有的红黑性质得到满足。在进行旋转操作之前，需要进行颜色调整以满足红黑性质。
C++实现无父指针红黑树：高效插删查操作
"这篇资源是关于C++实现的无父指针红黑树代码，它在旋转操作中利用栈来存储节点的祖先信息，包括叔叔、父亲等。这个红黑树实现了基本的插入、删除和查找操作，并且已经过部分在线判题系统的测试，未发现错误。" ...
红黑树-基于C++实现的红黑树数据结构.zip
03-21
在C++中实现红黑树时，通常会定义一个名为`RBTree`的类，包含私有成员变量（如根节点指针）和公共成员函数（如`insert`, `delete`, `search`等）。类的构造函数初始化空树，而析构函数则负责释放所有节点。为了确保...
C++简单实现红黑树的插入
06-06
在C++中实现这些操作，需要定义红黑树节点结构体，包括颜色属性和指向子节点的指针。同时，还需要定义插入函数，该函数首先进行基础插入，然后根据插入后树的形态进行相应的颜色调整和旋转操作。最后，别忘了更新根...
红黑树的c++实现，提供完整代码
03-21
以下是关于红黑树C++实现的一些补充说明: 1. 红黑树性质 - 每个节点都是红色或黑色 - 根节点是黑色 - 所有叶节点(NIL节点)都是黑色 - 如果一个节点是红色,那么它的两个子节点都是黑色(不存在两个连续的红节点) ...
对于红黑树的一点认识，
weixin_42694291的博客
09-20 184
1.左旋 1)       创建红黑树节点指针ptrbnRight并指向当前节点的右儿子(以右节点称呼)； 2)       if (将右节点的左儿子设置为当前节点的右儿子且不为空节点) { 3)         右节点的左儿子的父亲节点指向当前节点； 4)       } 5)       将当前节点设置为右节点的左儿子； 6)       if （将当前节点的父亲节点设置为右节点的...
红黑树的旋转、查找和删除（附源代码）
airfish20000的博客
02-01 860
Red Black Tree Basic 红黑树的节点声明，其中Parent指针是指向某一节点的父节点的指针： typedef struct TreeNode *PtrRBTNode; typedef struct TreeNode RBTNode; struct TreeNode{ ElementType Key; ColorType Color;
红黑树简易C++实现
每天完成一个小目标
03-13 416
原因 这几天研究了红黑树,光说不练假把式,于是就自己手动实现一下 数据结构声明 #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...
终于搞懂红黑树！--红黑树的原理及操作
lzzw的学习之路
07-30 9523
红-黑-树 介绍： 红黑树（ Red black tree）是种自平衡二叉查找树，在计算机科学中用到的一种数据结构。 它是在1972年由 Rudolf Bayer发明的当时被称为平衡二叉B树（ symmetric binary B-trees）。后来，在1978年被 Leo. guibas和 Robert sedgewick修改为如今的红黑树R-B Tree，全称是Red- Blac...
再见！红黑树！（八大数据结构
weixin_45003809的博客
06-08 258
目录红黑树 红黑树 在二叉搜索树的基础上给节点增加了一个颜色属性，通过该属性的控制来实现平衡。 性质： 1、结点不是红色就是黑色。 2、根结点一定为黑色。 3、所有的NULL指针被认为是黑色结点。 （在红黑树中，叶子节点指的不是度为0的节点，而是度为0的节点的两个null孩子） 4、没有两个连着的红结点。 5、从任一节点到其每个叶子的所有简单路径上的黑色结点数都相同。 与AVL树相比，红黑树是一种弱平衡的搜索二叉树： AVL是保证了任意一个节点的平衡因子在[-1,0,1]之间，平衡性极高； 而红黑树的性质4
二叉树遍历/算法&数据结构
2403_86942375的博客
11-10 496
其实很简单，根据遍历的顺序摆放遍历顺序和添加元素的顺序，(root.left, result)代表左子树，(root.right, result)代表右子树，(root.val)代表中节点。其实很简单，参数就是要目前遍历节点在哪，返回值也同理，终止条件就是指遍历到null的时候回溯，逻辑不要想复杂，根据顺序移动上述上个递归函数即可。前序（要理解遍历的核心，先把中节点塞入，然后根据栈去模拟，先加入右节点然后是左节点，移动到左节点继续加入）后序（就是前序遍历的左右调换顺序，然后再倒叙结果数组）
【初阶数据结构篇】二叉树OJ题
最新发布
braveact的博客
11-10 442
根节点与左右孩子的数值进行比较，如果相等依次递归左右子树，如果为空，或者两者对应的值相等，则返回true。🚀 分享给更多人：如果你觉得这篇文章对你有帮助，欢迎分享给更多对C++感兴趣的朋友，让我们一起进步！可以将该二叉树看成两个独立的二叉树，分别将“两个二叉树”的根节点传入，判断该是否为相同的二叉树。将两个数的根节点的值依次比较，依次递归两根节点的左子树，若根节点为空，直接返回。如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。期待你的三连，你的支持就是我创作的动力！
开放寻址法、链式哈希数据结构详细解读
m0_61840987的博客
11-06 937
开放寻址法在低负载因子时效率较高，而链式哈希在高负载因子下表现更稳定。
【数据结构】B树
藓类少女的博客
11-06 880
B树通常定义为一棵平衡的多路搜索树，并用一个整数 m 表示其阶数，即每个节点最多有 m 个子节点。每个节点最多包含 m - 1 个关键字和 m 个子节点。每个非根节点至少包含 ⌈m/2⌉−1 个关键字和 ⌈m/2⌉ 个子节点。根节点至少包含 1 个关键字，特殊情况除外（当树为空时，根节点没有关键字）。所有叶子节点都在同一层，即 B 树的高度是均匀的。每个节点的关键字从小到大排序，并且遵循左小右大的原则。每个关键字 k 的左子树的所有关键字都小于 k，右子树的所有关键字都大于 k。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值