C++实现完整红黑树（包括迭代器的实现）

最新推荐文章于 2022-11-09 15:33:18 发布
最新推荐文章于 2022-11-09 15:33:18 发布
阅读量324 收藏 1
点赞数
分类专栏： 常见算法实现 文章标签： 算法 c++ 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22228095/article/details/108897104
版权 
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>

using namespace std;
//定义红黑树节点颜色的类型
typedef bool RB_COLOR;
#define RB_BLACK true
#define RB_RED false
#define bro(x) (((x)->ftr->lc == (x))?((x)->ftr->rc):((x)->ftr->lc))

//定义红黑树模板类
template<typename T>
class RB_TREE {
protected:
	struct RB_Node;

	RB_Node* _root;
	RB_Node* _hot;

	int _size;

	RB_Node* LeftRotate(RB_Node*);		//左旋函数
	RB_Node* RightRotate(RB_Node*);		//右旋函数

	RB_Node* find(T);						//查找函数

	void SolveDoubleRed(RB_Node*);		//解决双红问题
	void SolveLostBlack(RB_Node*);		//解决失黑问题

	void RemoveTree(RB_Node*);			//DFS后续遍历
public:

	RB_TREE() :_root(nullptr), _hot(nullptr), _size(0) {}

	struct iterator;

	iterator begin();
	static iterator end();
	int size();
	bool empty();

	iterator insert(T);

	iterator lower_bound(T);
	iterator upper_bound(T);

	bool remove(T);
	void clear();
	iterator serach(T);
};


//定义红黑树节点模板类
template<typename T>
struct RB_TREE<T>::RB_Node {
	T val;
	RB_COLOR RBc;
	RB_Node* lc;
	RB_Node* rc;
	RB_Node* ftr;

	RB_Node(T v = T(), RB_COLOR rbc = RB_RED, RB_Node* father = nullptr, RB_Node* rchild = nullptr, RB_Node* lchild = nullptr)
		:val(v), RBc(rbc), ftr(father), lc(lchild), rc(rchild) {}

	RB_Node* LeftNode() {			//中序遍历中的前序节点
		RB_Node* ptn = nullptr;
		if (lc) {
			ptn = lc;
			if (ptn->rc) {
				ptn = ptn->rc;
			}
		}
		else {
			ptn = this;
			while (ptn->ftr && ptn->ftr->lc != ptn) {
				ptn = ptn->ftr;
			}
			ptn = ptn->ftr;
		}
		return ptn;
	}

	RB_Node* RightNode() {			//中序遍历中的后继节点
		RB_Node* ptn = nullptr;
		if (rc) {
			ptn = rc;
			while (ptn->lc) {
				ptn = ptn->lc;
			}
		}
		else {
			ptn = this;
			while (ptn->ftr && ptn->ftr->lc != ptn) {
				ptn = ptn->ftr;
			}
			ptn = ptn->ftr;
		}
		return ptn;
	}
};


//定义红黑树迭代器类
template<typename T>
struct RB_TREE<T>::iterator {
protected:
	RB_Node* _real_node;
public:

	T operator*() {
		return _real_node->val;
	}

	bool operator==(iterator const& itr) {
		return _real_node->val == itr._real_node;
	}

	bool operator!=(iterator const& itr) {
		return _real_node->val != itr._real_node;
	}

	bool operator!() {
		return (_real_node == nullptr) ? true : false;
	}

	iterator& operator=(iterator const& itr) {
		_real_node = itr._real_node;
		return this;
	}

	iterator& operator+(int n) {
		while (n--) {
			if (_real_node == _real_node->RightNode())
				_real_node = nullptr;
			else
				_real_node = _real_node->RightNode();
		}
		return *this;
	}

	iterator& operator-(int n) {
		while (n--) {
			if (_real_node == _real_node->LeftNode())
				_real_node = nullptr;
			else
				_real_node = _real_node->LeftNode();
		}
		return *this;
	}

	iterator& operator++() {
		if (_real_node == _real_node->RightNode())
			_real_node = nullptr;
		else
			_real_node = _real_node->RightNode();
		return *this;
	}

	iterator& operator--() {
		if (_real_node == _real_node->LeftNode())
			_real_node = nullptr;
		else
			_real_node = _real_node->LeftNode();
		return *this;
	}

	//构造函数
	iterator(RB_Node* rb = nullptr) : _real_node(rb) {}//指针构造
	iterator(iterator const& rb) : _real_node(rb._real_node) {}//迭代器构造
	iterator(T const& v) : _real_node(find(v)) {}//数据构造
};


//---------------类中函数数的实现--------------
template <typename T>
typename
RB_TREE<T>::RB_Node* RB_TREE<T>::find(T v) {
	RB_Node* ptn = _root;
	_hot = nullptr;
	while (ptn) {
		_hot = ptn;
		if (ptn->val == v) {
			break;
		}
		else if (ptn->val < v) {
			ptn = ptn->rc;
		}
		else {
			ptn = ptn->lc;
		}
	}
	return ptn;
}

template <typename T>
typename
RB_TREE<T>::RB_Node* RB_TREE<T>::LeftRotate(RB_Node* ptn) {
	RB_Node* pftr = ptn->ftr;
	RB_Node* prc = ptn->rc;
	ptn->rc = prc->lc;
	if (prc->lc) prc->lc->ftr = ptn;
	prc->lc = ptn;
	ptn->ftr = prc;
	prc->ftr = pftr;
	if (pftr) {
		if (pftr->lc == ptn)
			pftr->lc = prc;
		else
			pftr->rc = prc;
	}
	if (ptn == _root) { 	//维护根节点
		_root = prc;
	}
	return prc;
}

template <typename T>
typename
RB_TREE<T>::RB_Node* RB_TREE<T>::RightRotate(RB_Node* ptn) {
	RB_Node* pftr = ptn->ftr;
	RB_Node* plc = ptn->lc;
	ptn->lc = plc->rc;
	if (plc->rc) plc->rc->ftr = ptn;
	plc->rc = ptn;
	ptn->ftr = plc;
	plc->ftr = pftr;
	if (pftr) {
		if (pftr->lc == ptn)
			pftr->lc = plc;
		else
			pftr->rc = plc;
	}
	if (ptn == _root) {		//维护根节点	
		_root = plc;
	}
	return plc;
}

template <typename T>
void RB_TREE<T>::SolveDoubleRed(RB_Node* ptn) {
	while (ptn->ftr && ptn->ftr->RBc == RB_RED) {
		RB_Node* pftr = ptn->ftr;
		RB_Node* pgrd = pftr->ftr;
		RB_Node* uncle = bro(pftr);
		if (uncle == nullptr || uncle->RBc == RB_BLACK) {
			if (pgrd->lc == pftr) {
				if (pftr->lc == ptn) {
					RightRotate(pgrd);
					pftr->RBc = RB_BLACK;
				}
				else {
					LeftRotate(pftr);
					RightRotate(pgrd);
					ptn->RBc = RB_BLACK;
				}
			}
			else {
				if (pftr->lc == ptn) {
					RightRotate(pftr);
					LeftRotate(pgrd);
					ptn->RBc = RB_BLACK;
				}
				else {
					LeftRotate(pgrd);
					pftr->RBc = RB_BLACK;
				}
			}
			pgrd->RBc = RB_RED;
		}
		else {
			uncle->RBc = RB_BLACK;
			pftr->RBc = RB_BLACK;
			pgrd->RBc = RB_RED;
			ptn = pgrd;
		}
	}
	if (ptn == _root)
		ptn->RBc = RB_BLACK;

}

template <typename T>
void RB_TREE<T>::SolveLostBlack(RB_Node* ptn) {
	RB_Node* pftr = ptn->ftr;
	RB_Node* pbro = bro(ptn);
	if (pbro == nullptr) return;
	//【兄弟为黑色】
	if (pbro->RBc == RB_BLACK) {
		//【没有红色侄子】
		if (pbro->rc == nullptr && pbro->lc == nullptr) {
			//没有红色侄子,有红色父亲
			if (pftr->RBc == RB_RED) {
				pftr->RBc = RB_BLACK;
				pbro->RBc = RB_RED;
			}
			//没有红色侄子,有黑色父亲
			else if (pftr->RBc == RB_BLACK) {
				pbro->RBc = RB_RED;
				if (pftr != _root)
					SolveLostBlack(pftr);
			}
		}
		//【有红色侄子】
		else {
			//【兄弟在右边】
			if (pftr->lc == ptn) {
				//兄弟在右边，有红色右侄子
				if (pbro->rc && pbro->rc->RBc == RB_RED) {
					LeftRotate(pftr);
					if (pftr->RBc == RB_RED) {
						pbro->RBc = RB_RED;
						pftr->RBc = RB_BLACK;
					}
					pbro->rc->RBc = RB_BLACK;
				}
				//兄弟在右边，有红色左侄子
				else if (pbro->lc && pbro->lc->RBc == RB_RED) {
					RightRotate(pbro);
					LeftRotate(pftr);
					if (pftr->RBc == RB_BLACK) {
						pftr->ftr->RBc = RB_BLACK;
					}
					pftr->RBc = RB_BLACK;
				}
			}
			//【兄弟在左边】
			else {
				//兄弟在左边，有红色左侄子
				if (pbro->lc && pbro->lc->RBc == RB_RED) {
					RightRotate(pftr);
					if (pftr->RBc == RB_RED) {
						pbro->RBc = RB_RED;
						pftr->RBc = RB_BLACK;
					}
					pbro->lc->RBc = RB_BLACK;
				}
				//兄弟在左边，有红色右侄子
				else if (pbro->rc && pbro->rc->RBc == RB_RED) {
					LeftRotate(pbro);
					RightRotate(pftr);
					if (pftr->RBc == RB_BLACK) {
						pftr->ftr->RBc = RB_BLACK;
					}
					pftr->RBc = RB_BLACK;
				}
			}
		}
	}
	//【兄弟为红色	】
	else {
		if (pftr->lc == ptn) {
			if (pftr == _root) _root = pftr->rc;
			LeftRotate(pftr);
			pbro->RBc = RB_BLACK;
			pftr->RBc = RB_RED;
		}
		else {
			if (pftr == _root) _root = pftr->lc;
			RightRotate(pftr);
			pbro->RBc = RB_BLACK;
			pftr->RBc = RB_RED;
		}
		SolveLostBlack(ptn);
	}
}

template <typename T>
void RB_TREE<T>::RemoveTree(RB_Node* ptn) {
	if (ptn == nullptr) return;
	RemoveTree(ptn->lc);
	RemoveTree(ptn->rc);
	delete ptn;
}

template <typename T>
typename
RB_TREE<T>::iterator RB_TREE<T>::begin() {
	if (_root == nullptr) return iterator(_root);
	RB_Node* ptn = _root;
	while (ptn->lc) {
		ptn = ptn->lc;
	}
	return iterator(ptn);
}

template <typename T>
typename
RB_TREE<T>::iterator RB_TREE<T>::end() {
	return iterator(nullptr);
}

template <typename T>
int RB_TREE<T>::size() {
	return _size;
}

template <typename T>
bool RB_TREE<T>::empty() {
	return (_size == 0) ? true : false;
}

template <typename T>
typename
RB_TREE<T>::iterator RB_TREE<T>::insert(T v) {
	RB_Node* ptn = find(v);
	if (ptn) return iterator(ptn);
	if (_hot == nullptr) {
		_root = new RB_Node(v, RB_BLACK, nullptr, nullptr, nullptr);
		_size = 1;
		return iterator(_root);
	}
	ptn = new RB_Node(v, RB_RED, _hot, nullptr, nullptr);
	if (_hot->val > v) {
		_hot->lc = ptn;
	}
	else {
		_hot->rc = ptn;
	}
	SolveDoubleRed(ptn);
	_size++;
	return iterator(ptn);
}

template <typename T>
bool RB_TREE<T>::remove(T v) {
	RB_Node* ptn = find(v);
	if (ptn == nullptr) return false;
	while (ptn->lc || ptn->rc) {
		RB_Node* temp = nullptr;
		if (ptn->rc) {
			temp = ptn->RightNode();
		}
		else {
			temp = ptn->LeftNode();
		}
		ptn->val = temp->val;
		ptn = temp;
	}
	if (ptn->RBc == RB_BLACK)
		SolveLostBlack(ptn);
	delete ptn;
	_size--;
	return true;
}

template <typename T>
typename
RB_TREE<T>::iterator RB_TREE<T>::lower_bound(T v) {
	RB_Node* ptn = _root;
	_hot = nullptr;
	while (ptn) {
		_hot = ptn;
		if (ptn->val >= v) {
			ptn = ptn->lc;
		}
		else {
			ptn = ptn->rc;
		}
	}
	if (_hot->val < v) {
		ptn = _hot->RightNode();
	}
	else {
		ptn = _hot;
	}
	return ptn;
}

template <typename T>
typename
RB_TREE<T>::iterator RB_TREE<T>::upper_bound(T v) {
	RB_Node* ptn = _root;
	_hot = nullptr;
	while (ptn) {
		_hot = ptn;
		if (ptn->val > v) {
			ptn = ptn->lc;
		}
		else {
			ptn = ptn->rc;
		}
	}
	if (_hot->val <= v) {
		ptn = _hot->RightNode();
	}
	else {
		ptn = _hot;
	}
	return ptn;
}

template <typename T>
void RB_TREE<T>::clear() {
	if (_root) {
		RB_Node* ptn = _root;
		_root = nullptr;
		_hot = nullptr;
		_size = 0;
		RemoveTree(_root);
	}
}

template <typename T>
typename
RB_TREE<T>::iterator RB_TREE<T>::serach(T v) {
	return iterator(find(v));
}

//---------------------测试-------------------------
int main(void)
{
	RB_TREE<double> tree;

	for (int i = 10; i >= 0; i--) {
		tree.insert(i);
	}
	tree.insert(8.5);
	cout << tree.size() << endl;
	tree.remove(10);
	cout << tree.size() << endl;

	int aa = 0;

	return 0;
}

 

qq_22228095
关注
专栏目录
红黑树底层迭代器的实现
贵在坚持,我相信只要我努力,未来肯定是美好的!
05-26 330
红黑树实现迭代器目录:一. 封装迭代器二.红黑树部分改变三.map的实现四.set的实现 目录: 这篇博客是对于红黑树内部迭代器实现, 点击红黑树的具体代码 . 一. 封装迭代器 对于红黑树迭代器的实现,我们就是要利用二叉树的指向来依次的遍历对应的节点来实现红黑树的迭代器,所存在的_header节点就是方便迭代器的实现 template<class V> struct RBTreeIterator{ //泛型创建对应的结构 typede
C++红黑树的插入实现+红黑树迭代器实现+map/set封装红黑树
qq_53413129的博客
06-01 568
红黑树的基本编写 红黑树的概念 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的 红黑树的性质 每个节点不是红色就是黑色 根节点是黑色的 没有连续的红色节点，但是可以有连续的黑色节点 每条路径黑色节点数量相等 每个叶子节点都是黑色的（此处的叶子节点值得是空节点--NIL节点，不是以前真正意义上理解的叶子节点）。 假设每条路径
C++实现红黑树
痴心不改的博客
08-30 554
#pragma once #include&lt;iostream&gt; using namespace std; enum COLOR{BLACK,RED}; template&lt;class K,class V&gt; struct RBTreeNode { RBTreeNode&lt;K, V&gt;* _left; RBTreeNode&lt;K, V&gt;* _...
红黑树的插入删除及迭代器的实现(c++实现)
belongHWL的博客
03-04 435
实现：直接上代码，有注释
数据结构--迭代器实现红黑树
sayhello_world的博客
05-18 1167
这次总结如何使用自己写的迭代器实现红黑树 一．什么是迭代器？ 迭代器是连接容器和算法的纽带，为数据提供了抽象，使写算法的人不必关心各种数据结构的细节。迭代器提供了数据访问的标准模型——对象序列，使对容器更广泛的访问操作成为可能。 泛型编程的关键所在，就是如何找到一种通用的方法，来访问具有不同结构的各种容器中的每个元素，而这正是迭代器的功能。 迭代器是一种广义的指针，是指向序列元素指
红黑树与迭代器的实现
Dakuan_chen的博客
06-03 1070
红黑树是一棵二叉搜索树，它在每个结点上增加了一个存储位来表示结点的颜色，可以是red或者black，通过对任何一条从根节点到叶子结点上的简单路径来约束，红黑树保证最长路径不超过最短路径的两倍，因而近似平衡。红黑树具有一下性质 1、每个节点不是红的就是黑的 2、根节点一定是黑的 3、没有连在一起的红色节点 4、从根节点到每个叶子的路径上的黑色节点数目相等#pragma once #includ
基于C++红黑树与哈希表的实现
最新发布
05-08
`Red_black_tree-code`可能是包含红黑树实现的源代码文件，可以参考其中的实现细节，学习如何在C++中构建和操作自定义数据结构。 总的来说，掌握红黑树和哈希表的原理和C++实现对于提升编程技能和解决复杂问题具有...
关于红黑树的迭代器原理及实现
liuming
11-11 522
首先介绍什么是迭代器： 迭代器是一种设计模式，设计一种结构依次序去遍历容器中的数据，而又无需暴露容器的底层设计细节，在我看来，迭代器的出现最重要的目的就是为了简单方便；同一种方式可以遍历不同的容器，不管底层结构是是顺序表，链表还是树。虽然使用方式相同，但是不同的容器中迭代器的实现方式是不同的，本文介绍红黑树的迭代器的实现方式。 迭代器的本质： 本质上是指针或者对指针的封装。 如何设计容器中的迭代器： 首先要明白容器的底层数据结构，按照什么规则进行遍历，其实使用一个类进行迭...
C++红黑树
zhao19971014的博客
11-09 607
红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的
【C++】红黑树详解并封装实现map和set
love_guanghui的博客
03-18 3171
红黑树详解
c语言实现泛型红黑树(含迭代器) 见说明
10-07
泛型纯C语法实现的底层容器 能想到的接口 都已实现 并单独提供一个正向迭代器与反向迭代器 也提供了3种遍历方式 前中后序 参见测试用例 其维护红黑树性质的相关代码 几乎是句句含带注释 使用面向对象编程思想构建代码 并可在windows和linux下 c89标准编译通过
二叉树之红黑树迭代器
dong18292000671的博客
05-29 525
红黑事的性质： 1.每个节点不是红色就是黑色。 2.根节点一定是黑色。 3.没有两个连续的红色节点。 4.每个叶子结点道根的路径上，黑色结点的个数都相等。 5.每个叶子结点的空指针域都是黑色的。 通过这些条件的设定，可以保证最长路径上结点的个数不会超过最短路径上节点个数的两倍。 这是一种极限情况，但是这种情况不可能出现，因为正在插入每个节点时都需要调整。 红黑树插入时要考虑的几种
【C++】红黑树详解（附迭代器以及插入实现），适合初学者
jhao的博客
07-13 2488
红黑树的简单实现附有迭代器实现，代码都有详细解释，适合于初学者和想要理解STL map/set原理的朋友观看。
C++实现一个简单的红黑树（RB_TREE）
github_33736971的博客
05-10 1959
红黑树遵守的规则：一头（根）一脚（叶子节点）黑（黑色），黑同（从任意节点开始至根结点的黑色节点的个数相等）红不连（红色节点不能相连）以下是红黑树的插入和旋转函数的简易实现：#include <iostream> #include <assert.h> #include <string.h>using namespace std;typedef int Type; typedef enum{RED=0
C++ 实现红黑树结构
枫铃树
01-23 1358
C++ 面向对象实现红黑树结构。
【数据结构】带迭代器的红黑树
Cheng_913的博客
01-27 204
在上一篇博客中，我们简单的介绍了红黑树及其插入操作，下面我们将给红黑树封装一个迭代器。为方便操作，我们需要添加一个头结点，并设置其颜色为红色，以便于根结点区分开；这个根结点的左指向最小的结点，右指向树中值最大的结点，其双亲结点指向根结点，根结点的双亲域也指向头，如下图所示： #pragma once #include using namespace std; enum COLOR
红黑树的实现 以及加迭代器
jhcconan614的博客
06-03 1335
在说红黑树之前，我们先来认识一下它：首先强调一点：红黑树也是二叉搜索树。那么它就满足二叉搜索树的性质，除此之外，他还有几个比较特殊的性质，了解这些，有助于我们后面的分析性质：1、红黑树所有的节点都有颜色（红或黑）2、红黑树的根结点是黑色的3、红黑树的两个红色节点不能相连4、红黑树的每一条链的黑节点的个数相同5、所有空的节点都是黑色的知道了这些之后开始进入红黑树的创建：显然这就是红黑树的插入操作的编写
Cpp || 红黑树迭代器
Template Code
04-17 549
红黑树迭代器 迭代器的好处是可以方便遍历,是数据结构的底层实现与用户透明,如果想要给红黑树增加迭代器,需要考虑以前的问题: begin()与end() STL明确规定，begin()与end()代表的是一段前闭后开的区间，而对红黑树进行中序遍历后，可以得到一个有序的序列，因此：begin()可以放在红黑树中最小节点(即最左侧节点)的位置，end()放在最大节点(最右侧节点)的下一个...
Java左倾红黑树的完整实现
qq_44968886的博客
02-13 331
左红黑树准备知识 一、定义： 1.红链接均为左连接 2.没有任何一个节点同时和两条红链接相连 3.该树是完美黑色平衡的，即任意空连接到根结点的路径上的黑链接数量相等。 二、颜色表示： 示例代码中说一个节点是红色的，指的是指向该链接的颜色是红色的。 代码说明 实现类让参数K继承了Comparable接口，主要原因是红黑树要维持树的平衡就要依赖于两个键的大小关系，而Comparable接口中的comp...
C++ STL集合：红黑树实现的有序无重复容器详解
3. 数据结构实现：set内部采用红黑树（Red-Black Tree）作为底层数据结构。这种树是一种自平衡的二叉查找树，通过维护红黑树的性质（如每个节点的颜色、子树高度差等），确保了查找、插入和删除操作的时间复杂度接近...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值