某高人实现的红黑树模板类

最新推荐文章于 2023-02-23 16:04:23 发布
最新推荐文章于 2023-02-23 16:04:23 发布
阅读量2.2k 收藏 3
点赞数
分类专栏： C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/small_qch/article/details/17579813
版权

事先声明，这个模板类是我在网上找的（具体在哪找的就忘记了）

红黑树原理请见：http://blog.csdn.net/v_JULY_v/article/details/6105630

实现：

/** 
*  gs_rbtree.h: red-black tree implementation
*
*  a simple c++ template wrapper of linux kernel 2.6.1/rbtree.c
*  Written by Daly.  2009-11
*/

/*
*  Red-black tree reference:
*       http://www.cnblogs.com/abatei/archive/2008/12/17/1356565.html 
*       http://www.cs.princeton.edu/~rs/talks/LLRB/08Penn.pdf
*
*  usage:
*     RbTree<int, struct mytype>  rbt;
*     rbt.insert(12, mytype_object1); 
*     rbt.insert(15, mytype_object2);
*     RbNode<int, struct mytype> *iter = rbt.search(12) //search
*     if (iter != NULL) visit(iter->value);    //get value
*     rbt.erase(12);
*     //alternative: rbt.erase_node(iter); (faster but *iter will become null)
*     iter = rbt.minimum();
* 
*/



#ifndef _GS_RBTREE_H_
#define _GS_RBTREE_H_

#define RB_RED   1
#define RB_BLACK 0

template<typename _KeyType, typename _ValType>
class RbTree;

//red black tree node
template<typename _KeyType, typename _ValType>
class RbNode
{
public:
	_KeyType     key;
	_ValType   value;

private:
	friend class RbTree<_KeyType, _ValType>;
	RbNode<_KeyType, _ValType>  *rb_parent;
	RbNode<_KeyType, _ValType>  *rb_left;
	RbNode<_KeyType, _ValType>  *rb_right;
	int  rb_color;
};



//red-black tree
template<typename _KeyType, typename _ValType>
class RbTree
{
	typedef RbNode<_KeyType, _ValType> NodeLink;
public:
	RbTree() : m_root(NULL) {}
	~RbTree();

	//search node by key. 
	//be careful to use the pointer it return.
	NodeLink* search(_KeyType key) {
		NodeLink *node = m_root;
		while (node) {
			if (key < node->key) 
				node = node->rb_left;
			else if (key > node->key) 
				node = node->rb_right;
			else   //found match
				return node;
		}
		return NULL;
	}

	//insert and fix
	void insert(_KeyType key, _ValType value) {
		NodeLink *node = new NodeLink;
		//fix new leaf
		if (insert_new_node(key, value, node)) {
			insert_fix(node);
		}
	}

	void erase_node(NodeLink *node);
	void erase(_KeyType key);

	NodeLink* minimun()
	{
		NodeLink *p = m_root;
		while (p->rb_left != NULL) 
			p = p->rb_left;
		return p;
	}
	NodeLink* maximum()
	{
		NodeLink *p = m_root;
		while (p->rb_right != NULL) 
			p = p->rb_right;
		return p;
	}

protected:
	bool insert_new_node(_KeyType key, _ValType value, RbTree::NodeLink* node);
	void insert_fix(NodeLink *node);
	void rotate_left(NodeLink *node);
	void rotate_right(NodeLink *node);
	void erase_fixup(NodeLink *node, NodeLink *parent);
	

protected:
	NodeLink *m_root;  //tree root

};

template<typename _KeyType, typename _ValType>
RbTree<_KeyType, _ValType>::~RbTree() 
{
	while (m_root != NULL) 
		erase_node(m_root);
}

/** 
* initialize a new node. just add to the tree's leaf
* @return  false if already exist. true if a new leaf
*/
template<typename _KeyType, typename _ValType>
bool RbTree<_KeyType, _ValType>::insert_new_node(_KeyType key, _ValType value, RbTree::NodeLink* node)
{
	RbNode<_KeyType, _ValType> **pp = &m_root;
	RbNode<_KeyType, _ValType> *parent = NULL;
	RbNode<_KeyType, _ValType> *pnode;
	
	while(*pp) {
		pnode = parent = *pp;
		if (key < pnode->key) {
			pp = &pnode->rb_left;
		}
		else if (key > (*pp)->key) {
			pp = &pnode->rb_right;
		}
		else {   //already exist
			pnode->value = value;
			return false;
		}
	}

	node->rb_parent = parent;
	node->key = key;
	node->value = value;
	node->rb_color = RB_RED;
	node->rb_left = node->rb_right = NULL;
	*pp = node;

	return true;   //a new node

}

template<typename _KeyType, typename _ValType>
void RbTree<_KeyType, _ValType>::rotate_left(RbTree::NodeLink *node)
{
	RbNode<_KeyType, _ValType> *right = node->rb_right;
	
	//update the right's left child and check whether it's null
	if ((node->rb_right = right->rb_left) != NULL) {
		right->rb_left->rb_parent = node;
	}
	right->rb_left = node ;   //become the right's left child
	
	//update parent and check whether it's root
	if ((right->rb_parent = node->rb_parent) != NULL) {
		if (node == node->rb_parent->rb_left)
			node->rb_parent->rb_left = right;
		else
			node->rb_parent->rb_right = right;
	}
	else {
		m_root = right;     //update the root
	}
	node->rb_parent = right;
}

template<typename _KeyType, typename _ValType>
void RbTree<_KeyType, _ValType>::rotate_right(RbTree::NodeLink *node)
{
	RbNode<_KeyType, _ValType> *left = node->rb_left;

	if ((node->rb_left = left->rb_right) != NULL) {
		left->rb_right->rb_parent = node;
	}
	left->rb_right = node;

	if ((left->rb_parent = node->rb_parent) != NULL) {
		if (node == node->rb_parent->rb_right)
			node->rb_parent->rb_right = left;
		else
			node->rb_parent->rb_left = left;
	}
	else {
		m_root = left;
	}
	node->rb_parent = left;
}



template<typename _KeyType, typename _ValType>
void RbTree<_KeyType, _ValType>::insert_fix(RbTree::NodeLink *node)
{
	RbNode<_KeyType, _ValType> *parent, *grandparent, *uncle, *tmp;
	
	//fix if two consecutive red node
	while ((parent = node->rb_parent) && parent->rb_color == RB_RED)
	{
		grandparent = parent->rb_parent;    //grandparent sure to be not null
		//begin left-branch case
		if (parent == grandparent->rb_left) {
			uncle = grandparent->rb_right;
			//parent and uncle are both red
			if (uncle && uncle->rb_color == RB_RED) {
				uncle->rb_color = RB_BLACK;       //color flip
				parent->rb_color = RB_BLACK;
				grandparent->rb_color = RB_RED;
				node = grandparent;
				continue;     //up to the root
			}
			//black uncle
			if (parent->rb_right == node) {
				rotate_left(parent);       //left-leaning 
				tmp = parent;     //update pointers after rotation
				parent = node;
				node = tmp;
			}
			parent->rb_color = RB_BLACK;     //color update before rotation
			grandparent->rb_color = RB_RED;
			rotate_right(grandparent);
		}
		else {  //begin right branch case
			uncle = grandparent->rb_left;
			if (uncle && uncle->rb_color == RB_RED) {
				uncle->rb_color = RB_BLACK;
				parent->rb_color = RB_BLACK;
				grandparent->rb_color = RB_RED;
				node = grandparent;
				continue;
			}

			if (parent->rb_left == node) {
				rotate_right(parent);
				tmp = parent;
				parent = node;
				node = tmp;
			}
			parent->rb_color = RB_BLACK;
			grandparent->rb_color = RB_RED;
			rotate_left(grandparent);
		}
	}

	m_root->rb_color = RB_BLACK;    //root should be black
}

template<typename _KeyType, typename _ValType>
void RbTree<_KeyType, _ValType>::erase(_KeyType key)
{
	RbNode<_KeyType, _ValType> *node = search(key);
	erase_node(node);
}

template<typename _KeyType, typename _ValType>
void RbTree<_KeyType,_ValType>::erase_node(RbTree::NodeLink *node)
{
	RbNode<_KeyType, _ValType> *child, *parent;
	int color;
	if (node == NULL) return;

	if (!node->rb_left)         //right single link or leaf
		child = node->rb_right;
	else if (!node->rb_right)   //left single link
		child = node->rb_left;
	else  //internal node
	{
		NodeLink *old = node, *left;
		node = node->rb_right;
		//find successor
		while ((left = node->rb_left) != NULL) {
			node = left;
		}
		child = node->rb_right;   //succesor's child
		parent = node->rb_parent;
		color = node->rb_color;
		//update link
		if (child)
			child->rb_parent = parent;
		if (parent) {
			if (parent->rb_left == node)
				parent->rb_left = child;
			else 
				parent->rb_right = child;
		}
		else {  //delete root
			m_root = child;
		}

		if (node->rb_parent == old) {
			parent = node;
		}
		//succussor replace the node to be deleted
		node->rb_parent = old->rb_parent;
		node->rb_color = old->rb_color;
		node->rb_right = old->rb_right;
		node->rb_left = old->rb_left;

		if (old->rb_parent) {
			if (old->rb_parent->rb_left == old)
				old->rb_parent->rb_left = node;
			else
				old->rb_parent->rb_right = node;
		}
		else {
			m_root = node;
		}

		old->rb_left->rb_parent = node;
		if (old->rb_right) {
			old->rb_right->rb_parent = node;
		}
		delete old;     //release memory
		goto fixup_color;   //jump to fix-up
	}

	//handle single link case or leaf
	parent = node->rb_parent;
	color = node->rb_color;

	if (child)
		child->rb_parent = parent;
	if (parent)
	{
		if (parent->rb_left == node)
			parent->rb_left = child;
		else
			parent->rb_right = child;
	}
	else {
		m_root = child;
	}
	delete node;

fixup_color:
	if (color == RB_BLACK) {
		erase_fixup(child, parent);
	}
}

template<typename _KeyType, typename _ValType>
void RbTree<_KeyType, _ValType>::erase_fixup(RbTree::NodeLink *node, RbTree::NodeLink *parent)
{
	RbNode<_KeyType, _ValType> *other;
	//only to fix black child
	while ((!node || node->rb_color == RB_BLACK) && node != m_root)
	{
		//handle left-branch case
		if (parent->rb_left == node)
		{
			other = parent->rb_right;
			if (other->rb_color == RB_RED) {   //red brother. just flip color
				other->rb_color = RB_BLACK;
				parent->rb_color = RB_RED;
			    rotate_left(parent);
				other = parent->rb_right;     //go down a level after rotation and go on fixing up
			}
			//black brother case and two black nephew
			if ((!other->rb_left ||
				other->rb_left->rb_color == RB_BLACK) &&    
				(!other->rb_right || 
				    other->rb_right->rb_color == RB_BLACK))
			{
				other->rb_color = RB_RED;
				node = parent;               //go up
				parent = node->rb_parent;
	
			}
			else  //less than two black nephew
			{
				//there's one black nephew
				if (!other->rb_right ||
					other->rb_right->rb_color == RB_BLACK)
				{
					RbNode<_KeyType, _ValType> *o_left;
					if ((o_left = other->rb_left) != NULL) {
						o_left->rb_color = RB_BLACK;
					}
					other->rb_color = RB_RED;
					rotate_right(other);
					other = parent->rb_right;
				}
				other->rb_color = parent->rb_color;
				parent->rb_color = RB_BLACK;
				if (other->rb_right)
					other->rb_right->rb_color = RB_BLACK;
				rotate_left(parent);
				node = m_root;
				break;    //finish
			}
		}
		else   //right case. symmetry code
		{
			other = parent->rb_left;
			if (other->rb_color == RB_RED)
			{
				other->rb_color = RB_BLACK;
				parent->rb_color = RB_RED;
				rotate_right(parent);
				other = parent->rb_left;
			}
			if ((!other->rb_left ||
				other->rb_left->rb_color == RB_BLACK)
				&& (!other->rb_right ||
				    other->rb_right->rb_color == RB_BLACK))
			{
				other->rb_color = RB_RED;
				node = parent;
				parent = node->rb_parent;
			}
			else
			{
				if (!other->rb_left ||
					other->rb_left->rb_color ==  RB_BLACK)
				{
					RbNode<_KeyType, _ValType> *o_right;
					if ((o_right = other->rb_right) != NULL) {
						o_right->rb_color = RB_BLACK;
					}
					other->rb_color = RB_RED;
					rotate_left(other);
					other = parent->rb_left;
				}
				other->rb_color = parent->rb_color;
				parent->rb_color = RB_BLACK;
				if (other->rb_left) {
					other->rb_left->rb_color = RB_BLACK;
				}
				rotate_right(parent);
				node = m_root;
				break;
			}
		}
	}//end loop
	
	if (node != NULL) {
		node->rb_color = RB_BLACK;
	}
}

#endif

AAA20090987
关注
专栏目录
红黑树详解及其模板类实现
Moyu的专栏
01-29 1079
一、历史 1972年，Rudolf Bayer发明了一种数据结构，这是一种特殊的4阶B树。这些树维护从根到叶的所有路径保持相同数量的节点，从而创建完美平衡的树。但是，它们不是二叉搜索树。Bayer在他的论文中将它们称为“对称二叉B树”（symmetric binary B-tree），后来它们作为2-4树（也称2-3-4树）变得流行。 在1978年的一篇论文“平衡树的二色框架”中，Leonid...
【模板】红黑树
wakawaka
12-22 489
#define BLACK 1 #define RED 0 class bst { private: struct Node { int value; bool color; Node *leftTree, *rightTree, *parent; Node() { color = RED;
C++红黑树（类模板实现）
weixin_33775572的博客
02-08 125
红黑树（Red Black Tree）是一种特殊的二叉查找树（Binary Search Tree），满则如下红黑性质的二叉树是红黑树： 1.每个节点或是红的，或是黑的 2.根节点是黑的 3.每个叶节点（NIL）是黑的 4.如果一个节点是红的，则它的两个儿子都是黑的 5.对于每个节点，从该节点到其子孙节点的所有路径上包含相同数目的黑节点。 由于以上的性质，红黑树的效率能保证在log级别...
（模板类）红黑树c++实现
10-02
红黑树的c++实现，代码注释详尽，另外在POJ上找了一个关于红黑树的题，A了，可以保证是正确的实现。 分多的小伙伴们送点分给我吧····哥另外的资源下载了500+次，但是CSDN设置每个资源分封底为100，导致现在我还是木有分可以用···十分的郁闷。
模板--红黑树（C++实现）
qq_42418728的博客
01-18 459
一、结点类与红黑树类： （一）结点类基本数据成员： 1.左右子结点指针域 2.父结点指针域，方便回访父结点 3.有序 前驱 /后继指针域，迭代访问元素，提供一种顺序存储的假象 4.结点颜色，利用红黑规则，保持树的平衡。 （二）结点类的基本成员函数： 两个重载的构造函数，构造红色的新结点 （三）红黑树类基本数据成员： 1.头结点：保存一个据点，用来维系根节点与公用空结点 2....
java算法实现红黑树完整代码示例
08-28
"java算法实现红黑树完整代码示例" 红黑树（英语：Red–black tree）是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。红黑树的另一种定义是含有红黑链接并满足下列条件的...
C++简单实现红黑树的插入
最新发布
06-06
红黑树是一种自平衡二叉查找树，它在数据结构中扮演着重要的角色，尤其在高效算法实现中。它的设计目标是确保查找、插入和删除等操作的时间复杂度都接近于O(log n)。在C++中实现红黑树，我们需要理解其特性并将其...
红黑树_ C++模板实现
11-08
详细的红黑树C++模板实现，调试后运行正确。 template class RBTree { private: static node<T> *nil;//哨兵，静态成员，被整个RBTree类所共有 node<T> *root; RBTree(const RBTree&);//禁止复制构造 RBTree ...
红黑树-基于C++实现的红黑树数据结构.zip
03-21
例如，在C++标准模板库(STL)中，`std::set`和`std::map`就是基于红黑树实现的。 在C++中实现红黑树时，通常会定义一个名为`RBTree`的类，包含私有成员变量（如根节点指针）和公共成员函数（如`insert`, `delete`, `...
红黑树(RB_Tree) 模版
12-07
这是本人写的一个红黑树的模版，只需要改一下接口就可以用了。基本操作查找，删除，修改都是O(logn).
红黑树模板
he_qingjun的博客
08-11 232
红黑树这一块的知识有点难懂，，难懂的地方就是左旋，右旋，插入调整，和删除调整，对我来说最难懂的还是删除部分，一直只得形不得意，，看着算法导论眼睛疼。。。这里有一位大佬讲的还行-》https://www.cnblogs.com/skywang12345/p/3245399.html 下面是我实现的代码，不够完善，因为我没有重复使用树根，先这样吧，回头复习时把他完善。。下面代码可以运行的哦，注意引用符号，之前有个地方就是因为我加了个引用就一直栈溢出。。。删除操作部分我注释了的那种方法也是可以的，不过我觉得麻烦。
红黑树【模板】【高性能】
ZTJ的博客
02-21 588
#include<bits/stdc++.h> #include<thread> #include<windows.h> using namespace std; #define FIN freopen("D://debug//in.txt","r",stdin); #define FOUT freopen("D://debug//out.txt","w",stdout); #define FDATA freopen("D://debug//data.txt","w",s
红黑树C++模板和仿函数实现
piaoxuelibin的专栏
12-30 711
<br />                                                               红黑树C++模板和仿函数实现1、红黑树暗地里和程序员打交道，比如set、map，这里就包括了很多语言如C++/Java/C#等OOP Language都包含实现它的代码，看了会STL源码中的红黑树，感觉要学的知识太多，很杂乱，六大组件，红黑树实现中要用到了常用的继承、迭代器等技术。<br /> <br /> <br />2、红黑树理论主要有(1)红黑树定义(2)插入算法(
红黑树数据结构的实现模板
weixin_44001521的博客
02-19 177
可以参考的学习资料： 30张图带你彻底理解红黑树–这个可以讲解思想来源 红黑树(一)之 原理和算法详细介绍–总结了算法的规则 【数据结构】带你轻松学习红黑树，菜鸟学习红黑树经验分享！ #include"pch.h" #include<iostream> #inclu...
c++模板实现红黑树
liuxiaokai_liu的博客
05-07 961
红黑树概念及构建规则请百度 #include&lt;assert.h&gt; enum Colour { RED, BLACK, }; template&lt;class K, class V&gt; struct RBTreeNode { RBTreeNode* _left; RBTreeNode* _right; RBTreeNode* _pare...
数据结构-红黑树(Red-Black Tree)的C++实现模板
weixin_34290352的博客
08-21 134
2019独角兽企业重金招聘Python工程师标准>>> ...
红黑树(RedBlackTree)实现
ssopp24的博客
04-19 830
红黑树（Red Black Tree） 是一种自平衡二叉查找树，和AVL树类似，都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。 但现实中 红黑树 的应用比 AVL 树多， 因为同时插入一个结点，AVL树旋转的时候，红黑树不一定旋转。 我们通过上滤(自底向上调整)算法用c++模板类实现了红黑树的插入操作代码， 但是，更好的实现插入操作的算法是下
红黑树的原理分析与(C++)实现: 模板类、插入算法双红修正、删除算法双黑修正 （C++）
amoscykl的博客
08-12 1683
红黑树 1.概述 定义 由红、黑两色节点组成的二叉搜索树若满足以下条件,即为红黑树 (red-black tree):    (1) 树根始终为黑色    (2) 外部节点均为黑色    (3) 其余节点若为红色,则其孩子节点必为黑色    (4) 从任一外部节点到根节点的沿途,黑节点的数目相等   从以上条件可得：红节点均为内部节点,且其父节点及左、右孩子必然存在。红节点之父必为黑色...
红黑树(三) 之 C++ STL模板实现(完整源码)
Manofletters的博客
02-23 439
使用C++模板实现红黑树
C++实现红黑树模板类
"这是一个C++实现的红黑树模板类，包含插入、删除和查找操作，以及旋转函数。" 红黑树是一种自平衡的二叉查找树（BST），它在进行插入和删除操作后能保持相对较好的平衡性，从而提供高效的查找、插入和删除性能。在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值