算法导论 红黑树的C++代码实现

最新推荐文章于 2022-08-21 23:27:46 发布
最新推荐文章于 2022-08-21 23:27:46 发布
阅读量596 收藏
点赞数
分类专栏： 算法导论 文章标签： c++ 算法导论 遍历 搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_24520925/article/details/41958417
版权

红黑树为满足下列五个条件的特殊二叉树

  1. 每个结点要么是红的要么是黑的。  
  2. 根结点是黑的。  
  3. 每个叶结点（叶结点即指树尾端NIL指针或NULL结点）都是黑的。  
  4. 如果一个结点是红的，那么它的两个儿子都是黑的。  
  5.  对于任意结点而言，其到叶结点树尾端NIL指针的每条路径都包含相同数目的黑结点。

本文代码根据算法导论上的伪代码编写，按照先序、中序、后序输出。可直接运行，如有错误，欢迎大家指正~~~

black_red_tree.h:

#ifndef _RB_TREE_H_
#define _RB_TREE_H_
#include <iostream>
#include <sstream>
#include <fstream>
#include <cmath>

using namespace std;
template<class KEY>
class RB_Tree
{
private:

 RB_Tree(const RB_Tree& input){}
 const RB_Tree& operator=(const RB_Tree& input){}
private:
 enum COLOR{RED,BLACK};
 class RB_NODE
 {
 public:
  RB_NODE()
  {
   right=NULL;
   left=NULL;
   parent=NULL;
  }
  COLOR RB_COLOR;
  RB_NODE* right;
  RB_NODE* left;
  RB_NODE* parent;
  KEY key;
 };
 
public:
 RB_NODE* m_nullNode;
 RB_NODE* m_root;
 enum ORDER_MODE
 {
  ORDER_MODE_PREV = 0,
  ORDER_MODE_MID,
  ORDER_MODE_POST
 };//枚举，代表遍历树的方式（前序，中序，后序）
 /*
 1.BlackRedTree的构造，折构，以及判断树是否为空
 */
 RB_Tree()
 {
  this->m_nullNode=new RB_NODE();
  this->m_root=m_nullNode;
  this->m_nullNode->right=this->m_root;
  this->m_nullNode->left=this->m_root;
  this->m_nullNode->parent=this->m_root;
  this->m_nullNode->RB_COLOR=BLACK;
 }
 ~RB_Tree()
 {
  clear(m_root);
  delete m_nullNode;
 }
 bool Empty()
 {
  if (this->m_root==this->m_nullNode)
  {
   return true;
  }
  else
   return false;
 }
 /*
 2.BlackRedTree的搜索
 */
 RB_NODE* find(KEY key)
 {
  RB_NODE* index=m_root;
  while(index!=m_nullNode)
  {
   if (key<index->key)
   {
    index=index->left;
   }
   else if(key>index->key)
   {
    index=index->right;
   }
   else
    break;
  }
  return index;
 }
 /*
 3.BlackRedTree的插入（左旋，右旋，插入，红黑状态更新）
 */
 /*
 3.1左旋
 */
 void RotateLeft(RB_NODE* node)
 {
  if (node==m_nullNode||node->right==m_nullNode)
  {
   return ;
  }
  RB_NODE* lower_right=node->right;
  node->right=lower_right->left;
  if (lower_right->left!=m_nullNode)
  {
   lower_right->left->parent=node;
  }
  lower_right->parent=node->parent;
  if (node->parent==m_nullNode)
  {
   m_root=lower_right;
   m_nullNode->left=m_root;
   m_nullNode->right=m_root;
  }
  else if (node==node->parent->left)
  {
   node->parent->left=lower_right;
  }
  else
   node->parent->right=lower_right;
  lower_right->left=node;
  node->parent=lower_right;
 }
 /*
 3.2右旋
 */
 void RotateRight(RB_NODE* node)
 {
  if (node==m_nullNode||node->left==m_nullNode)
  {
   return ;
  }
  RB_NODE* lower_left=node->left;
  node->left=lower_left->right;
  if (lower_left->right!=m_nullNode)
  {
   lower_left->right->parent=node;
  }
  lower_left->parent=node->parent;
  if (node->parent==m_nullNode)
  {
   m_root=lower_left;
   m_nullNode->left=m_root;
   m_nullNode->right=m_root;
  }
  else if (node==node->parent->right)
  {
   node->parent->right=lower_left;
  }
  else
   node->parent->left=lower_left;
  lower_left->right=node;
  node->parent=lower_left;
 }
 /*
 3.3插入
 */
 void Insert(KEY key)
 {
  RB_NODE* insert_point=m_nullNode;
  RB_NODE* index=m_root;
  while(index!=m_nullNode)
  {
   insert_point=index;
   if (key<index->key)
   {
    index=index->left;
   }
   else if (key>index->key)
   {
    index=index->right;
   }
   else
    return;
  }
  RB_NODE* insert_node=new RB_NODE();
  insert_node->key=key;
  insert_node->RB_COLOR=RED;
  insert_node->right=m_nullNode;
  insert_node->left=m_nullNode;
  insert_node->parent=insert_point;
  if (insert_point==m_nullNode)
  {
   m_root=insert_node;
   m_root->parent=m_nullNode;
   m_nullNode->left=m_root;
   m_nullNode->right=m_root;
   m_nullNode->parent=m_root;
  }
  else if (insert_node->key<insert_point->key)
  {
   insert_point->left=insert_node;
  }
  else
   insert_point->right=insert_node;
  InsertFixUp(insert_node);
 }
 /*
 3.4红黑性质修复
 */
 void InsertFixUp(RB_NODE* node)
 {
  while(node->parent->RB_COLOR==RED)
  {
   if (node->parent==node->parent->parent->left)
   {
    RB_NODE* uncle=node->parent->parent->right;
    if (uncle->RB_COLOR==RED)
    {
     node->parent->RB_COLOR=BLACK;
     uncle->RB_COLOR=BLACK;
     node->parent->parent->RB_COLOR=RED;
     node=node->parent->parent;
    }
    else
    {
      if (node==node->parent->right)
     {
      node=node->parent;
      RotateLeft(node);
     }
       node->parent->RB_COLOR=BLACK;
       node->parent->parent->RB_COLOR=RED;
       RotateRight(node->parent->parent);
    }
   }
   else
   {
    RB_NODE* uncle=node->parent->parent->left;
    if (uncle->RB_COLOR==RED)
    {
     node->parent->RB_COLOR=BLACK;
     uncle->RB_COLOR=BLACK;
     node->parent->parent->RB_COLOR=RED;
     node=node->parent->parent;
    }
    else
    {
     if (node==node->parent->left)
     {
      node=node->parent;
      RotateRight(node);
     }
      node->parent->RB_COLOR=BLACK;
      node->parent->parent->RB_COLOR=RED;
      RotateLeft(node->parent->parent);
    }
   }
  }
  m_root->RB_COLOR=BLACK;
 }
 /*
 4.BlackRedTree的删除（转换子树,找最小值节点，找最大值，删除，红黑状态修复）
 */
 /*
 4.1 转换子树
 */
 void RB_TRANSPLANT(RB_NODE* u,RB_NODE* v)
 {
  if (u->parent==m_nullNode)
  {
   m_root=v;
   m_root->parent=m_nullNode;
   m_nullNode->left=m_root;
   m_nullNode->right=m_root;
   m_nullNode->parent=m_root;
  }
  else if (u==u->parent->left)
  {
   u->parent->left=v;
  }
  else
  {
      u->parent->right=v;
  }
  v->parent=u->parent;
 }
 /*
 4.2 找最小值
 */
    RB_NODE* RB_findMin(RB_NODE* node)
 {
  while(node->left!=m_nullNode)
  {
   node=node->left;
  }
  return node;
 }
 /*
 4.3 找最大值
 */
 RB_NODE* RB_findMax(RB_NODE* node)
 {
  while(node->right!=m_nullNode)
  {
   node=node->right;
  }
  return node;
 }
 /*
 4.4 删除
 */
 bool Delete(KEY key)
 {
  RB_NODE* delete_node=find(key);
  if (delete_node==m_nullNode)
  {
   return false;
  }
  RB_NODE* delete_point=delete_node;
  RB_NODE* delete_point_child;
  COLOR Original_color=delete_point->RB_COLOR;
  if (delete_node->left==m_nullNode)
  {
   delete_point_child=delete_node->right;
   RB_TRANSPLANT(delete_node,delete_node->right);
  }
  else if (delete_node->right==m_nullNode)
  {
   delete_point_child=delete_node->left;
   RB_TRANSPLANT(delete_node,delete_node->left);
  }
  else
  {
   delete_point=RB_findMin(delete_node->right);
   Original_color=delete_point->RB_COLOR;
   delete_point_child=delete_point->right;
   if (delete_point->parent==delete_node)
   {
    delete_point_child->parent=delete_point;
   }
   else
   {
    RB_TRANSPLANT(delete_point,delete_point->right);
    delete_point->right=delete_node->right;
    delete_point->right->parent=delete_point;
   }
   RB_TRANSPLANT(delete_node,delete_point);
   delete_point->left=delete_node->left;
   delete_point->left->parent=delete_point;
   delete_point->RB_COLOR=delete_node->RB_COLOR;
  }
  if (Original_color==BLACK)
  {
   DeleteFixUp(delete_point_child);
  }
  delete delete_node;
  return true;
 }
 /*
 4.5 红黑性质修复
 */
 void DeleteFixUp(RB_NODE* node)
 {
  while(node!=m_root&&node->RB_COLOR==BLACK)
  {
   if (node==node->parent->left)
   {
    RB_NODE* brother=node->parent->right;
    if (brother->RB_COLOR==RED)
    {
     brother->RB_COLOR=BLACK;
     node->parent->RB_COLOR=RED;
     RotateLeft(node->parent);
     brother=node->parent->right;
    }
    else
    {
     if (brother->left->RB_COLOR==BLACK&&brother->right->RB_COLOR==BLACK)
     {
      brother->RB_COLOR=RED;
      node=node->parent;
     }
     else if (brother->right->RB_COLOR==BLACK)
     {
      brother->left->RB_COLOR=BLACK;
      brother->RB_COLOR=RED;
      RotateRight(brother);
      brother=node->parent->right;
     }
     else if (brother->right->RB_COLOR==RED)
     {
      brother->RB_COLOR=node->parent->RB_COLOR;
      node->parent->RB_COLOR=BLACK;
      brother->right->RB_COLOR=BLACK;
      RotateLeft(node->parent);
      node=m_root;
     }
    }
   }
   else
   {
    RB_NODE* brother=node->parent->left;
    if (brother->RB_COLOR==RED)
    {
     brother->RB_COLOR=BLACK;
     node->parent->RB_COLOR=RED;
     RotateRight(node->parent);
     brother=node->parent->left;
    }
    else
    {
     if (brother->right->RB_COLOR==BLACK&&brother->left->RB_COLOR==BLACK)
     {
      brother->RB_COLOR=RED;
      node=node->parent;
     }
     else if (brother->left->RB_COLOR==BLACK)
     {
      brother->right->RB_COLOR=BLACK;
      brother->RB_COLOR=RED;
      RotateLeft(brother);
      brother=node->parent->left;
     }
     else if (brother->left->RB_COLOR==RED)
     {
      brother->RB_COLOR=node->parent->RB_COLOR;
      node->parent->RB_COLOR=BLACK;
      brother->left->RB_COLOR=BLACK;
      RotateRight(node->parent);
      node=m_root;
     }
    }
   }
  }
  m_nullNode->parent=m_root;
  node->RB_COLOR=BLACK;
 }

 void PrintTree(ORDER_MODE eOrderMode)const
 {
  if (ORDER_MODE_PREV==eOrderMode)
   printTreeInPrev(m_root);
  else if (ORDER_MODE_MID==eOrderMode)
   printTreeInMid(m_root);
  else if (ORDER_MODE_POST==eOrderMode)
   printTreeInPost(m_root);
  else
   ;
 }
 void printTreeInPrev(RB_NODE*t) const
 {
  if (t!=m_nullNode)
  {
   cout<<t->key;
   if (t->RB_COLOR==BLACK)
   {
    cout<<"B  ";
   }
   else
    cout<<"R ";
   printTreeInPrev(t->left);
   printTreeInPrev(t->right);
  }
 }
 void printTreeInMid(RB_NODE*t) const
 {
  if (t!=m_nullNode)
  {
   printTreeInMid(t->left);
   cout<<t->key;
   if (t->RB_COLOR==BLACK)
   {
    cout<<"B  ";
   }
   else
    cout<<"R ";
   printTreeInMid(t->right);
  }
 }
 void printTreeInPost(RB_NODE*t) const
 {
  if (t!=m_nullNode)
  {
   printTreeInPost(t->left);
   printTreeInPost(t->right);
   cout<<t->key;
   if (t->RB_COLOR==BLACK)
   {
    cout<<"B  ";
   }
   else
    cout<<"R ";
  }
 }
    void clear(RB_NODE* node)
 {
  if (node==m_nullNode)
  {
   return;
  }
  else
  {
   clear(node->left);
   clear(node->right);
   delete node;
  }
 }
};
#endif _RB_TREE_H_

 

main.cpp:

#include "black_red_tree.h"
#include <vector>
using namespace std;
void main()
{
	RB_Tree<int> tree;
	int a[20]={4,19, 0 ,17 ,10 ,12 ,8 ,11, 18, 1 ,6, 16,7, 14 ,9 ,3 ,13, 2 ,5 ,15};
	vector<int> v(a,a+20);
	for(int i=0;i<v.size();i++)
	{
		cout<<v[i]<<"  ";
	}
	cout<<endl;
	for (int i=0;i<v.size();i++)
	{
		tree.Insert(v[i]);
		cout<<"insert: "<<v[i]<<endl;
		tree.printTreeInMid(tree.m_root);
		cout<<endl;
	}
	cout<<"root: "<<tree.m_root->key<<endl;
	tree.printTreeInPrev(tree.m_root);
		cout<<endl;
	tree.printTreeInMid(tree.m_root);
		cout<<endl;
	tree.printTreeInPost(tree.m_root);
		cout<<endl;
	for (int i=0;i<v.size();i++)
	{
		cout<<"delete: "<<v[i]<<endl;
		tree.Delete(v[i]);
		tree.printTreeInMid(tree.m_root);
	}
	tree.clear(tree.m_root);
	return;
}

运行部分结果如下：

 

 

LJDaisy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法导论的红黑树的C++实现源码
03-29
算法导论的红黑树的C++实现源码,并附加测试验证代码
算法导论：c++实现红黑树
imcy的博客
12-21 359
数据结构性质 这里定义一个结构体保存颜色enum colorRB { black = 0, red, }; struct TreeNode_RB { int val; colorRB color; TreeNode_RB *left; TreeNode_RB *right; TreeNode_RB *parent; TreeNod
算法导论-红黑树C++实现
爱冒险的技术宅
11-10 3729
红黑树的定义： 一棵二叉查找树如果满足下面的红黑性质，则为一棵红黑树： 1）每个节点或是红的，或是黑的。 2）根节点是黑的。 3）每个叶节点（NIL）是黑节点。 4）如果一个节点是红的，则它的两个儿子都是黑的。 5）对每个节点，从该节点到其子孙节点的所有路径上包含相同节点数目的黑节点。 C++代码实现： BRTreeNode.h #ifndef BRTREENODE_
C++实现红黑树
hdsHDS6的博客
06-28 1461
C++实现红黑树，插入和删除思路
C++实现红黑树（含完整代码+图）
weixin_44628585的博客
08-09 2075
此文主要记录红黑树的操作，即节点的添加删除操作，并且有完整代码可供学习。欢迎大家阅读，如有问题，麻烦大家指出。
算法导论红黑树C++代码实现
05-15
红黑树C++代码实现
红黑树与区间树算法实现
04-08
算法导论实验：使用c++实现红黑树的建立，插入，旋转，删除，查找全操作以及区间树的全操作。并带有红黑树的可视化展示，采用graphviz工具，需要自行安装graphviz以实现树的可视化功能。
红黑树算法C++实现
07-07
该程序详细实现了红黑树算法,带有注释,能正确运行出结果
红黑树_ C++模板实现
11-08
详细的红黑树C++模板实现，调试后运行正确。 template class RBTree { private: static node<T> *nil;//哨兵，静态成员，被整个RBTree类所共有 node<T> *root; RBTree(const RBTree&);//禁止复制构造 RBTree ...
红黑树C++代码实现
01-21
描述： 实现红黑树、二叉搜索树相关算法：插入（红黑树涉及树的调整：左旋右旋等），删除，搜索（指定Key值节点）。 另外，红黑树实现计算树黑高的算法。 1).插入测试，输入 8，11，17，15，6，1，22，25，27，建立红黑树，按照 红黑树信息输出方式 输出整棵红黑树以及黑高。 2).删除测试，删除1）中红黑树中Key=15的节点，按照 红黑树信息输出方式 输出调整后的整棵红黑树以及黑高。 3).随机产生300,000个不同自然数Key值（1－300,000），建立红黑树，查找Key=15000的节点，输出查找花费时间。 随机产生300,000个不同自然数Key值（1－300,000），建立二叉搜索树，查找Key=15000的节点，输出查找花费时间。 4). 重复3－5次3）中操作，求各自平均时间。 5). 在1)－4)的红黑树算法基础上修改完成P307 14.1-4算法 OS_Key_Rank(T,k). 输入 1,2,3,4,5,6,7,8 建树， k=6, 输出OS_Key_Rank的返回值。 详细信息看readme!
算法导论——所有算法和数据结构的C++实现
01-09
所有代码都是在我学习这本书时亲手敲出来的，并且调试正确了，包括：第三部分到第六部分（即10-26章），外加第七部分31和32章所有的算法和数据结构以及编程习题还有思考题的C++实现源代码； 第一、二部分学习的较早，代码已丢失； 如果程序有问题，欢迎在我的博客留言或者发邮件[email protected] 某些章内容可以参考我的博客（http://blog.csdn.net/zilingxiyue），由于时间关系，而且写一篇博客要花费很多精力，所有并没有写完（只有32篇），抱歉。
红黑树精短C++代码
04-13
红黑树实现前去后继排名的查询，代码经过精心简短，题目测试参考洛谷
算法导论C++实现代码
09-18
算法导论C++和C的实现源代码,很有参考价值
红黑树C++实现
01-27
红黑树的C++完整实现代码
C++:红黑树
zhang_si_hang的博客
08-21 1477
1.红黑树的概念红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。（最长的路径不超过最短路径的2倍，近似平衡）2.红黑树的性质1.每个结点不是红色就是黑色2.根节点是黑色的3. 如果一个节点是红色的，则它的两个孩子结点是黑色的(没有连续的红色节点)
红黑树的C++代码实现
yantingtao_sunny的博客
04-24 1057
#include #include using namespace std; #define BLACK 0 #define RED 1 template class my_rbtree;//前置声明 /* 类名:my_rbnode(红黑树节点) */ template class my_rbnode { friend class my_rbtree;//友元 public:
红黑树 C++源代码实现
老衣的专栏
04-15 1508
<br /> 今天看了csdn博主july写的红黑树系列，觉得他写的非常好，研究了很长时间的红黑树 ，终于觉得明白些了。july写的C++源代码实现，已经非常好了，我只是在他的基础上  稍微做了一下修改，能够知道每个节点是个红  还是黑色的。<br />july的博客地址：http://blog.csdn.net/v_JULY_v/archive/2011/03/29/6285620.aspx，可以去他那看看他的系列！<br />直接上代码：<br />RB_tree.h<br />//file RBTre
C++ 写一颗红黑树 代码
qq_24447809的博客
12-25 383
红黑树代码 #pragma once const bool rb_red = false; const bool rb_black = true; class node { public: node(int n, bool color_type = true) :val(n), color(color_type), left(nullptr), right(nullptr), parent(nullptr) {}; int val; node* left; node* right; node
动态规划--最优二叉树问题
热门推荐
sinat_24520925的专栏
01-19 1万+
1、问题描速：        设 S={x1, x2, ···, xn}  是一个有序集合，且x1, x2, ···, xn表示有序集合的二叉搜索树利用二叉树的顶点存储有序集中的元素，而且具有性质：存储于每个顶点中的元素x 大于其左子树中任一个顶点中存储的元素，小于其右子树中任意顶点中存储的元素。二叉树中的叶顶点是形如(xi, xi+1) 的开区间。在表示S的二叉搜索树中搜索一个元素x，
用C++实现红黑树的算法代码
最新发布
05-23
以下是C++实现红黑树的算法代码： ```cpp #include using namespace std; enum Color { RED, BLACK }; struct Node { int data; bool color; Node *left, *right, *parent; Node(int data) { this->data =...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值