红黑树(RBTree)

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

RBTree

#pragma once



#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <string>
#include <algorithm>
#include <vector>
#include <list>
#include <map>
#include <fstream>
#include <filesystem>

#include <boost/format.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/filesystem.hpp>


using namespace std;

template <typename T>
struct MyRBTree
{
protected:

	enum RBColor{RED, BLACK};

	template <typename NodeDataType>  //必须声明模板
	struct TreeNode
	{
		NodeDataType	data;
		TreeNode		*pRight;
		TreeNode		*pLeft;
		TreeNode		*pParent;

		RBColor			color;
	};

protected:
	TreeNode<T>		*pRoot;
	size_t			nSize;




public:
	MyRBTree()
	{
		pRoot = nullptr;
		nSize = 0;
	}

	virtual ~MyRBTree()
	{
		//后续遍历(先释放子节点, 最后),释放空间
		if (nullptr != pRoot)
		{
			Destroy();
		}

	}

public:
	//插入
	void Insert(const T&  value)
	{
		_Insert(pRoot, value);
		pRoot->color = RBColor::BLACK;
	}


	//删除
	void Delete(const T& value)
	{
		_Remove(pRoot, value);
	}

	//查找 
	bool Find(const T& value)
	{
		return   (nullptr == _Find(pRoot, value)) ? false : true;
	}

	//前序遍历
	std::string Preorder()
	{
		std::string strOrder;
		_Preorder(pRoot, strOrder);
		return strOrder;
	}

	//中序遍历
	std::string  Inorder()
	{
		std::string strOrder;
		_Inorder(pRoot, strOrder);
		return strOrder;
	}

	//后序遍历
	std::string  Postorder()
	{
		std::string strOrder;
		_Postorder(pRoot, strOrder);
		return strOrder;
	}


	//销毁
	void Destroy()
	{
		_Destroy(pRoot);
		pRoot = nullptr;
	}


protected:


	void _Destroy(TreeNode<T> *pNode)
	{
		if (nullptr == pNode)
			return;

		_Destroy(pNode->pLeft);
		_Destroy(pNode->pRight);

		delete pNode;
		pNode = nullptr;
	}



	//这里是指针的引用
	//如果用的是指针, 再改变左右子树时, 需要解引用拷贝
	//void _Remove(TreeNode<T> * &pNode, const T& value)
	//{
	//	if (nullptr == pNode)
	//	{
	//		return;
	//	}
	//	else if (pNode->data < value)
	//	{
	//		_Remove(pNode->pRight, value);
	//	}
	//	else if (pNode->data > value)
	//	{
	//		_Remove(pNode->pLeft, value);
	//	}
	//	else // 找到了
	//	{
	//		//如果有左右子树
	//		if (nullptr != pNode->pLeft && nullptr != pNode->pRight)
	//		{
	//			//找到右子树中最小的节点
	//			TreeNode<T> *pTmp = pNode->pRight;
	//			for (; nullptr != pTmp->pLeft; pTmp = pTmp->pLeft) {};

	//			pNode->data = pTmp->data;
	//			_Remove(pNode->pRight, pTmp->data);
	//		}
	//		else if (nullptr == pNode->pLeft)
	//		{
	//			TreeNode<T> *pTmp = pNode;
	//			pNode = pNode->pRight;
	//			//*pNode = *(pNode->pRight); //如果函数参数是  指针类型, 而不是指针引用类型, 则需要进行拷贝

	//			delete pTmp;
	//			return;
	//		}
	//		else if (nullptr == pNode->pRight)
	//		{
	//			TreeNode<T> *pTmp = pNode;
	//			pNode = pNode->pLeft;
	//			*pNode = *(pNode->pLeft);
	//			delete pTmp;
	//			return;
	//		}

	//	}
	//}



	TreeNode<T>* _Find(TreeNode<T> *pNode, const T& value)
	{
		if (nullptr == pNode)
			return nullptr;

		if (value == pNode->data)
			return pNode;
		else if (value > pNode->data)
			return _Find(pNode->pRight, value);
		else
			return _Find(pNode->pLeft, value);
	}

	void _Insert(TreeNode<T> * &pNode, const T& value)
	{
		//递归终止条件

		//空树
		if (nullptr == pNode)
		{
			pNode = new TreeNode<T>();
			pNode->data = value;
			pNode->pLeft = nullptr;
			pNode->pRight = nullptr;
			pNode->color = RBColor::RED;
			return;
		}

		//开始递归
		if (pNode->data < value)
		{
			_Insert(pNode->pRight, value);
		}
		else
		{
			_Insert(pNode->pLeft, value);
		}


		//插入完成后, 进行调整,以符合红黑树性质

		if ( _IsRed(pNode->pRight) && !_IsRed(pNode->pLeft) )
		{
			_LeftRotate(pNode);
		}

		if (_IsRed(pNode->pLeft) && _IsRed(pNode->pLeft->pLeft))
		{
			_RightRotate(pNode);
		}

		if (_IsRed(pNode->pLeft) && _IsRed(pNode->pRight))
		{
			_FlipColor(pNode);
		}
	}

	//左旋
	void _LeftRotate(TreeNode<T> * &pNode)
	{
		//旋转
		TreeNode<T> *pTmp = pNode->pRight;
		pNode->pRight = pTmp->pLeft;
		pTmp->pLeft = pNode;

		//颜色调整
		pTmp->color = pNode->color;
		pNode->color = RBColor::RED;

		pNode = pTmp;
	}

	//右旋
	void _RightRotate(TreeNode<T> * &pNode)
	{
		//旋转
		TreeNode<T> *pTmp = pNode->pLeft;
		pNode->pLeft = pTmp->pRight;
		pTmp->pRight = pNode;

		//颜色调整 
		pTmp->color = pNode->color;
		pNode->color = RBColor::RED;

		pNode = pTmp;
	}

	bool _IsRed(const TreeNode<T> * const pNode)
	{
		if (nullptr == pNode) return false;
		return  RBColor::RED == pNode->color;
	}


	/*
	 颜色翻转
	*/
#define REVERSE_COLOR(color) ((RBColor::RED == color) ? (RBColor::BLACK) : (RBColor::RED))
	void _FlipColor(TreeNode<T> * &pNode)
	{
		pNode->color = REVERSE_COLOR(pNode->color);
		pNode->pRight->color = REVERSE_COLOR(pNode->pRight->color);
		pNode->pLeft->color = REVERSE_COLOR(pNode->pLeft->color);
	}
#undef REVERSE_COLOR




	void _Preorder(const TreeNode<T>* const pNode, std::string &strOrder)
	{
		//递归终止条件
		if (nullptr == pNode)
			return;

		if (!strOrder.empty()) strOrder += " ";
		strOrder += boost::str(boost::format("%d") % pNode->data);

		_Preorder(pNode->pLeft, strOrder);
		_Preorder(pNode->pRight, strOrder);
	}

	void _Inorder(const TreeNode<T>* const pNode, std::string &strOrder)
	{
		//递归终止条件
		if (nullptr == pNode)
			return;

		_Inorder(pNode->pLeft, strOrder);

		if (!strOrder.empty()) strOrder += " ";
		strOrder += boost::str(boost::format("%d") % pNode->data);

		_Inorder(pNode->pRight, strOrder);
	}

	void _Postorder(const TreeNode<T>* const pNode, std::string &strOrder)
	{
		//递归终止条件
		if (nullptr == pNode)
			return;

		_Postorder(pNode->pLeft, strOrder);
		_Postorder(pNode->pRight, strOrder);

		if (!strOrder.empty()) strOrder += " ";
		strOrder += boost::str(boost::format("%d") % pNode->data);
	}



public:
	void OutputGraph(const std::string &strDotFilePath, const char *pszDotExePath = nullptr)
	{
		std::ofstream  outFile(strDotFilePath, ios::out );
		if (!outFile.is_open())
		{
			std::cout << "open file " << strDotFilePath << "  failed." << std::endl;
			return;
		}

		outFile << "digraph G {" << endl;

		_OutputGraph(outFile, pRoot);

		outFile << "}" << endl;

		outFile.close();


	}

protected:
	void _OutputGraph(std::ofstream & outFile, const TreeNode<T> * const pNode)
	{
		if (nullptr == pNode)
			return;


		std::string strNodeAttr;
		if (_IsRed(pNode)){
			strNodeAttr = "shape=record,  style=filled, fillcolor=red, fontcolor=black";
		}
		else{
			strNodeAttr = "shape=record, color=black, style=filled, fillcolor=\"#B5B5B5\"";
		}

		outFile << pNode->data << "[label = \"<f0> | <f1> " << pNode->data << " | <f2> \"," << strNodeAttr << " ];" << endl;

		if (nullptr != pNode->pLeft)
		{
			_OutputGraph(outFile, pNode->pLeft);
			outFile << pNode->data << ":f0:sw->" << pNode->pLeft->data << ":f1;" << endl;
		}
		
		if(nullptr != pNode->pRight)
		{
			_OutputGraph(outFile, pNode->pRight);
			outFile << pNode->data << ":f2:se->" << pNode->pRight->data << ":f1;" << endl;
		}
	}


};

测试用例

// RBTree.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"

/**
*@time: 2019-10-29 15:13:26
*@author: yqq
*@descriptions: 
*/

#define  BOOST_AUTO_TEST_MAIN
#include <boost/test/included/unit_test.hpp>


#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <string>
#include <algorithm>
#include <vector>
#include <list>
#include <map>
#include <iostream>


#include "RBTree.hpp"
#include "MyRBTree.hpp"
using namespace std;
//
//int main()
//{
//	int a[] = { 10, 40, 30, 60, 90, 70, 20, 50, 80 };
//	int check_insert = 0;    // "插入"动作的检测开关(0，关闭；1，打开)
//	int check_remove = 0;    // "删除"动作的检测开关(0，关闭；1，打开)
//	int i;
//	int ilen = (sizeof(a)) / (sizeof(a[0]));
//	RBTree<int>* tree = new RBTree<int>();
//
//	cout << "== 原始数据: ";
//	for (i = 0; i<ilen; i++)
//		cout << a[i] << " ";
//	cout << endl;
//
//	for (i = 0; i<ilen; i++)
//	{
//		tree->insert(a[i]);
//		// 设置check_insert=1,测试"添加函数"
//		if (check_insert)
//		{
//			cout << "== 添加节点: " << a[i] << endl;
//			cout << "== 树的详细信息: " << endl;
//			tree->print();
//			cout << endl;
//		}
//
//	}
//
//	cout << "== 前序遍历: ";
//	tree->preOrder();
//
//	cout << "\n== 中序遍历: ";
//	tree->inOrder();
//
//	cout << "\n== 后序遍历: ";
//	tree->postOrder();
//	cout << endl;
//
//	cout << "== 最小值: " << tree->minimum() << endl;
//	cout << "== 最大值: " << tree->maximum() << endl;
//	cout << "== 树的详细信息: " << endl;
//	tree->print();
//
//	// 设置check_remove=1,测试"删除函数"
//	if (check_remove)
//	{
//		for (i = 0; i<ilen; i++)
//		{
//			tree->remove(a[i]);
//
//			cout << "== 删除节点: " << a[i] << endl;
//			cout << "== 树的详细信息: " << endl;
//			tree->print();
//			cout << endl;
//		}
//	}
//
//	// 销毁红黑树
//	tree->destroy();
//
//	return 0;
//}


BOOST_AUTO_TEST_SUITE(test_rb_tree)
//
//BOOST_AUTO_TEST_CASE(test_rbtree)
//{
//	MyRBTree<int> rbt;
//	rbt.Insert(9);
//	rbt.Insert(4);
//	rbt.Insert(1);
//}
//
//

//
//BOOST_AUTO_TEST_CASE(test_rbtree_2)
//{
//	MyRBTree<double> rbt;
//	rbt.Insert(10);
//	rbt.Insert(7);
//	rbt.Insert(8);
//	rbt.Insert(15);
//	rbt.Insert(5);
//	rbt.Insert(6);
//	rbt.Insert(11);
//	rbt.Insert(13);
//	rbt.Insert(12);
//	rbt.Insert(19);
//
//
//	std::cout << rbt.Inorder() << std::endl;
//
//	//生成dot文件
//	rbt.OutputGraph("test.dot", "D:\\Program Files (x86)\\Graphviz2.38\\bin");
//
//	//将dot文件转为 png文件
//	const char *pszCmd = "\"D:\\Program Files (x86)\\Graphviz2.38\\bin\\dot.exe\"   -Tpng -o test.png  test.dot   ";
//	std::cout << pszCmd << std::endl;
//	system(pszCmd);
//
//	//打开图片
//	system( "test.png" );
//
//}



#include <time.h>

//
//BOOST_AUTO_TEST_CASE(test_rbtree_3)
//{
//	MyRBTree<double> rbt;
//
//	//srand(time(NULL));
//	srand(1573788896);
//	clock_t timeBegin = clock();
//
//	for (int i = 0; i < 5000000; i++ )
//	{
//		int nRand = rand() % 4000000000;
//		if( !rbt.Find(nRand ))
//			rbt.Insert( nRand );
//	}
//	clock_t timeEnd = clock();
//
//	//std::cout << rbt.Inorder() << std::endl;
//
//	std::cout << "共耗时: " << timeEnd - timeBegin << endl;
//
//
//	//生成dot文件
//	rbt.OutputGraph("test_rbtree_random_insert.dot", "D:\\Program Files (x86)\\Graphviz2.38\\bin");
//
//	//将dot文件转为 png文件
//	const char *pszCmd = "\"D:\\Program Files (x86)\\Graphviz2.38\\bin\\dot.exe\"   -Tsvg -o test_rbtree_random_insert.svg test_rbtree_random_insert.dot   ";
//	std::cout << pszCmd << std::endl;
//	system(pszCmd);
//
//	//打开图片
//	//system("test2.svg");
//
//}



#include <ctime>
BOOST_AUTO_TEST_CASE(test_random_2)
{
	clock_t timeBegin = clock();
	const int nMaxtimes = 10;
	MyRBTree<double> tst;

	for (int nTesttimes = 0; nTesttimes < nMaxtimes; nTesttimes++)
	{
		srand(1573788896 + nTesttimes * 100);

		for (int i = 0; i < 5000000; i++)
		{
			int nRand = rand() % 4000000000;
			if (!tst.Find(nRand))
				tst.Insert(nRand);
		}
	}
	clock_t timeEnd = clock();
	std::cout << "共耗时: " << (double)(timeEnd - timeBegin) / nMaxtimes << endl;  //3216



	timeBegin = clock();
	for (int nTesttimes = 0; nTesttimes < nMaxtimes * 100000; nTesttimes++)
	{
		srand(1573788896 + nTesttimes * 200);
		int nRand = rand() % 4000000000;
		if (tst.Find(nRand))
		{
			//std::cout << "found :" << nRand << std::endl;
		}

	}
	timeEnd = clock();
	std::cout << "共耗时: " << timeEnd - timeBegin  << endl;  //

	/*
	共耗时: 3218.8
	共耗时: 716
	*/

}



BOOST_AUTO_TEST_SUITE_END()
youngqqcn
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
红黑树RBTree原理(超易懂)
yhc166188的博客
04-25 2083
红黑树脑图 目录 文章目录红黑树的定义四点特征为什么红黑树是近似平衡的(1)首先，我们来看，如果我们将红色节点从红黑树中去掉，那单纯包含黑色节点的红黑树的高度是多少呢？(2)现在把红色节点加回去，高度会变成多少呢？基本思想旋转插入删除应用 二叉查找树由于在频繁的动态更新过程中，可能会出现树的高度远大于 log2n的情况，所以就会导致各个操作效率下降，最坏的情况下就会退化为链表，变为O(n)．很明...
红黑树 rbtree
02-10
非常好用的红黑树，下载直接使用，每次获取树最左边节点从而得到，最小node节点。
数据结构之＜RBTree ＞
gangaue的博客
08-15 897
本篇文章进行数据结构中RBTree（红黑树）的学习！！！// 红黑树的颜色 enum Color {// RBTree的节点 template < typename K , typename V > struct RBTreeNode {// 节点的左孩子 RBTreeNode < K , V > * right;// 节点的右孩子 RBTreeNode < K , V > * parent;// 节点双亲 pair < K , V > kv;// 数值 Color col;// 颜色 }.........
正则表达式在线测试工具
北极熊在南极_whl的博客
04-13 2285
非常好用的正则表达式在线测试工具
程序员各种学习网站，持续更新
qq1366710226的博客
05-10 971
xxx
RBTree（红黑树）
wangpengcsdn1的博客
06-05 963
红黑树 红黑树（Red Black Tree）和AVL树类似，都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡。 红黑树是一颗二叉搜索树，它的每一个节点增加了一个存储位用来表示颜色，可以是Red也可以是Black，通过对任意一条根到叶子节点的颜色来约束，红黑树保证最长路径是最短路径的两倍，因此近似平衡； 红黑树的性质： 1：每个节点不是红色就是黑色 2：根节点是黑色 3：
红黑树rbTree.c
05-12
红黑树的遍历，查找过程，以及插入时对红黑树进行位置修复，修复包括左旋右旋，还有就是红黑树节点的删除，删除之后还要对节点修复
使用C语言实现的rbtree红黑树.zip
03-21
红黑树 使用C语言实现的rbtree红黑树
使用C++实现的rbtree红黑树.zip
03-21
红黑树 使用C++实现的rbtree红黑树
使用Java语言实现的rbtree红黑树.zip
最新发布
03-21
红黑树 使用Java语言实现的rbtree红黑树
rbtree
03-08
rbtree java
红黑树(RBtree)实现代码
02-17
一个基于C++的红黑树实现, RedBlackTree, C++, 二叉树, 平衡二叉树
SQL SERVER索引优化
mangkata的专栏
06-15 316
--索引缺失 SELECT user_seeks * avg_total_user_cost * ( avg_user_impact * 0.01 ) AS [index_advantage] , dbmigs.last_user_seek , dbmid.[statement] AS [Database.Schema.Table] , dbmi
boost的property_tree组件
热门推荐
oowgsoo的专栏
12-29 1万+
stl中对线性表有充分的实现，无论是vector还是list都是典型的线性表，即便是set和map，尽管实现上采用了诸如红黑树之类的树形结构，但那仅仅是为了快速检索的需要，从语义上来说它们依旧是线性表，无法表达目录树这种树形结构。boost中的property_tree可以看做是对树形结构实现的补充，我们大可把它扩展应用到各种需要树形结构的地方。
深入剖析STL中的RB-tree(红黑树)，并封装set和map
m0_61227789的博客
10-10 641
红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。每个节点不是红色就是黑色根节点为黑色不存在两个连续的红色节点任一节点至NULL(树尾端)的任何路径，所含之黑节点数必须相同。
WorkFlow学习分享:rbtree(红黑树)
qq_60328455的博客
10-02 426
红黑树，内核写法
rbtree 红黑树的 C 语言实现
jhkwei的专栏
01-18 1238
rbtree 红黑树的 C 语言实现，主要是照搬了《算法导论》，红黑树是一种比较有实用意义的平衡树，不过也挻复杂，主要是利用其它兄弟节点再加以旋转来实现平衡，不过在并发上增删操作不太方便，这时用 skip list 跳跃表有一定的优势。不过用来实现key-->value 数据结构 map , dictation, set 还是不错，现在把源码和测试表如下：/* * rbtree.h * *
【C++】用手搓的红黑树手搓set和map
学了就忘是正常现象
03-19 2737
C++map和set的底层原理。
侵入式容器 Boost.Intrusive
一面之媛
09-13 2332
Boost.Intrusive 是一个很有意思的实现，里面实现了很多侵入式容器，在特定环境下，可以大大提升性能。 首先我们得理解什么是侵入式，什么是非侵入式。普遍，我们认为std的容器，比如std::list都是非侵入式的。这是因为对于任何一个（支持复制或者移动的）类型T，我们都可以定义std::list<T>。当往std::list里插入一个元素时，它会分配一个节点，这个节点的结构类似于下面这个： struct Node { T data; Node* prev;

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值