红黑树源码

最新推荐文章于 2021-06-07 12:20:23 发布
最新推荐文章于 2021-06-07 12:20:23 发布
阅读量361 收藏
点赞数
文章标签： 红黑树 二叉树 查找 算法 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xilango/article/details/79221656
版权

Interface.h

#ifndef REDBLACKTREE_H
#define REDBLACKTREE_H
#include"DataType.h"
//红黑树
Interface IRedBlackTree
{ //插入节点
  virtual void InsertNode(int key,void*data)=0;
  //删除节点
  virtual bool RemoveNode(int key)=0;
  //查询节点
  virtual void* QueryNode(int key)=0;
};
extern "C" IRedBlackTree *GetCRedBlackTree(void);


CRedBlackTree.h

#ifndef CRDBLACKTREE_H
#define CRDBLACKTREE_H
#include"Interface.h"
 //数据节点
struct INode
{
   INode*            m_FNode;                    //父节点
   INode*            m_LNode;                    //左节点
   INode*            m_RNode;                    //右节点
   int               m_key;                      //箭值
   int               m_Coordinate;               //坐标
   bool              m_Colour;                   //颜色
   void *            m_Data;                     //数据
   INode();
};
 //红黑树                    
 class CRedBlackTree:public IRedBlackTree
{   
  private: 
    INode *                   m_RootNode;                 //根节点
    INode *                   m_TemNode;                  //临时节点
  public:
     CRedBlackTree();
    ~CRedBlackTree();
    //插入节点
    virtual void   InsertNode(int key,void*data);
    //删除节点
    virtual bool   RemoveNode(int key);
    //查询节点
    virtual void*  QueryNode(int key);
  private:
    //平衡节点
    void BalanceRedBlackTree(INode*Node);
    //平衡节点
    void RbDeleteFixup(INode*Node);    
    //左边旋转                 
    void LeftRotation(INode*Node);  
    //右边旋转                  
    void RightRotation(INode*Node);                      
};
#endif
CRedBlackTree.cpp 
#include"CRedBlackTree.h"

#define NULL           0
#define LEFT           1
#define RIGHT          2
#define ROOT           0

IRedBlackTree* GetCRedBlackTree(void)
{
 return new CRedBlackTree;
}

INode::INode()
{
    m_LNode=NULL;
    m_LNode=NULL;
    m_RNode=NULL;
    m_key=0;
    m_Coordinate=0;
    m_Colour=true;
    m_Data=NULL;
}

CRedBlackTree::CRedBlackTree()
{
   //初始化
   m_RootNode==NULL;
   m_TemNode=new INode;
}
CRedBlackTree::~CRedBlackTree()
{

}
void CRedBlackTree::InsertNode(int key,void*data)
{
    //插入的是第一个节点直接设置为根节点
    if(NULL==m_RootNode)
    {
        m_RootNode=new INode;
        m_RootNode->m_LNode=NULL;
        m_RootNode->m_RNode=NULL;
        m_RootNode->m_key=key;
        m_RootNode->m_Data=data;
        m_RootNode->m_Coordinate=0;
        m_RootNode->m_Colour=false;
        return ;
    }
    else
    {
        INode* TempNode=m_RootNode;
        while(NULL!=TempNode)
        {
            if(key<TempNode->m_key)
            {
                if(NULL==TempNode->m_LNode)
                {   INode*strNode=new INode;
                    TempNode->m_LNode=strNode;
                    strNode->m_FNode=TempNode;
                    strNode->m_RNode=NULL;
                    strNode->m_LNode=NULL;
                    strNode->m_Data=data;
                    strNode->m_key=key;
                    strNode->m_Coordinate=LEFT;

                    BalanceRedBlackTree(strNode);
                    return;
                }
                TempNode=TempNode->m_LNode;
            }
            else
            {
                if(NULL==TempNode->m_RNode)
                {   INode*strNode=new INode;
                    TempNode->m_RNode=strNode;
                    strNode->m_FNode=TempNode;
                    strNode->m_LNode=NULL;
                    strNode->m_RNode=NULL;
                    strNode->m_Coordinate=RIGHT;
                    strNode->m_key=key;
                    BalanceRedBlackTree(strNode);
                    return;
                }
                TempNode=TempNode->m_RNode;
            }
        }
    }
}
bool CRedBlackTree::RemoveNode(int key)
{
    INode* TempNode=m_RootNode;
    while(NULL!=TempNode)
    {
        if(key==TempNode->m_key)
        {
            INode* TempY=NULL;
            INode* TempX=NULL;
            if(NULL==TempNode->m_LNode||NULL==TempNode->m_RNode)
            {
                TempY=TempNode;
            }
            else
            {
                //记录当前节点的后继节点
                TempY=TempNode->m_RNode;
                while(TempY->m_LNode!=NULL)
                {
                    TempY=TempY->m_LNode;
                }
            }
            // 若TempY的左孩子不为空 则将Tempy的左孩子 赋值给TempX
            if(NULL!=TempY->m_LNode)
                TempX=TempY->m_LNode;
            //否则TempY的右孩子赋值给TempX
            else
                TempX=TempY->m_RNode;

            if(NULL!=TempX)
            {
                TempX->m_FNode=TempY->m_FNode;
                TempX->m_Coordinate=TempY->m_Coordinate;
            }
            else
            {
                m_TemNode->m_Colour=false;
                m_TemNode->m_FNode=TempY->m_FNode;
                m_TemNode->m_Coordinate=TempY->m_Coordinate;
            }
            if(TempY->m_Coordinate==LEFT)
                TempY->m_FNode->m_LNode=TempX;
            else if(TempY->m_Coordinate==RIGHT)
                TempY->m_FNode->m_RNode=TempX;
            else if(TempY->m_Coordinate==ROOT)
                m_RootNode=TempX;
            //
            if(TempY!=TempNode)
            {
                TempNode->m_key=TempY->m_key;
                TempNode->m_Data=TempY->m_Data;
            }

            if(TempY->m_Colour==false)
            {
                RbDeleteFixup(TempX==NULL?m_TemNode:TempX);
            }
            delete TempY;
            return true;
        }
        else if(key<TempNode->m_key)
            TempNode=TempNode->m_LNode;
        else
            TempNode=TempNode->m_RNode;
    }
   return false;
}
void* CRedBlackTree::QueryNode(int key)
{
    INode* TempNode=m_RootNode;
    while(NULL!=TempNode)
     {
        if(key==TempNode->m_key)
        {
            return TempNode->m_Data;
        }
        else if(key<TempNode->m_key)
        {
            TempNode=TempNode->m_LNode;
        }
        else
        {
            TempNode=TempNode->m_RNode;
        }
     }
     return NULL;
}
void CRedBlackTree::BalanceRedBlackTree(INode*Node)
{
    INode*TempNode=Node->m_FNode;
    //
    bool FatherColour=TempNode->m_Colour;
    while(FatherColour)
    {
        //当前节点都为红色
        if(Node->m_Colour)
        {
            //查看叔叔节点的的颜色
            bool UncleColour=(TempNode->m_Coordinate==LEFT?
            (TempNode->m_FNode->m_RNode==NULL ? false :TempNode->m_FNode->m_RNode->m_Colour):
            (TempNode->m_FNode->m_LNode==NULL ? false:TempNode->m_FNode->m_LNode->m_Colour));
            //叔叔节点是红色父节点是红色当前节点是红色
            if(UncleColour)
            {   //父节点是祖父节点的左节点
                if(TempNode->m_Coordinate==LEFT)
                  ((TempNode->m_FNode)->m_RNode)->m_Colour=false;
                else
                  ((TempNode->m_FNode)->m_LNode)->m_Colour=false;

                TempNode->m_Colour=false;
                TempNode->m_FNode->m_Colour=true;
                //将祖父节点设为当前节点
                Node=TempNode->m_FNode;
                TempNode=Node->m_FNode;
            }
            else
            {   //父节点是祖父节点的左节点
                if(TempNode->m_Coordinate==LEFT)
                {
                    //父节点的是红色叔叔节点是黑色当前节点是右孩子
                    if(Node->m_Coordinate==RIGHT)
                    {
                        LeftRotation(TempNode);
                        Node=TempNode;
                        TempNode=Node->m_FNode;
                    }
                    //父节点的是红色叔叔节点是黑色当前节点是左孩子
                    else if(Node->m_Coordinate==LEFT)
                    {
                        TempNode->m_Colour=false;
                        TempNode->m_FNode->m_Colour=true;
                        RightRotation(TempNode->m_FNode);
                    }
                }
                else
                {
                    //父节点的是红色叔叔节点是黑色当前节点是右孩子
                    if(Node->m_Coordinate==RIGHT)
                    {
                        TempNode->m_Colour=false;
                        TempNode->m_FNode->m_Colour=true;
                        LeftRotation(TempNode->m_FNode);
                    }
                    //父节点的是红色叔叔节点是黑色当前节点是左孩子
                    else if(Node->m_Coordinate==LEFT)
                    {

                        RightRotation(TempNode);
                        Node=TempNode;
                        TempNode=Node->m_FNode;
                    }
                }
            }
            FatherColour=TempNode==NULL?false:TempNode->m_Colour;
        }
       m_RootNode->m_Colour=false;
    }
    return;
}
void CRedBlackTree::RbDeleteFixup(INode*TempNode)
{
  while(TempNode!=m_RootNode&&TempNode->m_Colour==false)
   {

        if(TempNode->m_Coordinate==LEFT)
        {   INode* BrotherNode=TempNode->m_FNode->m_RNode;
            bool BrotherColour=BrotherNode==NULL ?false:BrotherNode->m_Colour;
            bool BrotherLeftColour=true;
            bool BrotherRightColour=true;
            if(BrotherColour)
            {
                BrotherNode->m_Colour=false;
                TempNode->m_FNode->m_Colour=true;
                LeftRotation(TempNode->m_FNode);
                BrotherNode=TempNode->m_FNode->m_RNode;
            }
            if(NULL!=BrotherNode)
            {
                BrotherLeftColour= BrotherNode->m_LNode!=NULL ?BrotherNode->m_LNode->m_Colour:false;
                BrotherRightColour=BrotherNode->m_RNode!=NULL ?BrotherNode->m_RNode->m_Colour:false;
            }
            //兄弟节点为黑色，兄弟节点的左右孩子都为黑色
            if(NULL!=BrotherNode&&!BrotherColour&&!BrotherLeftColour&&!BrotherRightColour)
            {
                BrotherNode->m_Colour=true;
                TempNode=TempNode->m_FNode;
            }
            else
            {
                //兄弟节点为黑色，兄弟节点左孩子红色，右孩子黑色。
                if(NULL!=BrotherNode&&!BrotherColour&&!BrotherRightColour)
                {   if(BrotherLeftColour)
                       BrotherNode->m_LNode->m_Colour=false;
                    BrotherNode->m_Colour=true;
                    RightRotation(BrotherNode);
                    BrotherNode=TempNode->m_FNode->m_RNode;
                }
                if(NULL!=BrotherNode)
                {
                    BrotherLeftColour= BrotherNode->m_LNode!=NULL ?BrotherNode->m_LNode->m_Colour:false;
                    BrotherRightColour=BrotherNode->m_RNode!=NULL ?BrotherNode->m_RNode->m_Colour:false;
                }
                //兄弟节点为黑色，右孩子为红色
                if(NULL!=BrotherNode&&!BrotherColour)
                {
                    BrotherNode->m_Colour=TempNode->m_FNode->m_Colour;
                    TempNode->m_FNode->m_Colour=false;
                    if(BrotherRightColour)
                       BrotherNode->m_RNode->m_Colour=false;

                    LeftRotation(TempNode->m_FNode);
                    TempNode=m_RootNode;
                }
            }
        }
        else
        {   INode* BrotherNode=TempNode->m_FNode->m_LNode;
            bool BrotherColour=BrotherNode==NULL ?false:BrotherNode->m_Colour;
            bool BrotherLeftColour=true;
            bool BrotherRightColour=true;
            if(BrotherColour)
            {
                BrotherNode->m_Colour=false;
                TempNode->m_FNode->m_Colour=true;
                RightRotation(TempNode->m_FNode);
                BrotherNode=TempNode->m_FNode->m_LNode;
            }
            if(NULL!=BrotherNode)
            {
                BrotherLeftColour= BrotherNode->m_LNode!=NULL ?BrotherNode->m_LNode->m_Colour:false;
                BrotherRightColour=BrotherNode->m_RNode!=NULL ?BrotherNode->m_RNode->m_Colour:false;
            }
            //兄弟节点为黑色，兄弟节点的左右孩子都为黑色
            if(NULL!=BrotherNode&&!BrotherColour&&!BrotherLeftColour&&!BrotherRightColour)
            {
                BrotherNode->m_Colour=true;
                TempNode=TempNode->m_FNode;
            }
            else
            {
                //兄弟节点为黑色，兄弟节点左孩子红色，右孩子黑色。
                if(NULL!=BrotherNode&&!BrotherColour&&!BrotherLeftColour)
                {   if(BrotherLeftColour)
                       BrotherNode->m_RNode->m_Colour=false;
                    BrotherNode->m_Colour=true;
                    LeftRotation(BrotherNode);
                    BrotherNode=TempNode->m_FNode->m_LNode;
                }
                if(NULL!=BrotherNode)
                {
                    BrotherLeftColour= BrotherNode->m_LNode!=NULL ?BrotherNode->m_LNode->m_Colour:false;
                    BrotherRightColour=BrotherNode->m_RNode!=NULL ?BrotherNode->m_RNode->m_Colour:false;
                }
                //兄弟节点为黑色，右孩子为红色
                if(NULL!=BrotherNode&&!BrotherColour)
                {
                    BrotherNode->m_Colour=TempNode->m_FNode->m_Colour;
                    TempNode->m_FNode->m_Colour=false;
                    if(BrotherLeftColour)
                       BrotherNode->m_LNode->m_Colour=false;

                    RightRotation(TempNode->m_FNode);
                    TempNode=m_RootNode;
                }
            }
        }
   }
   TempNode->m_Colour=false;
}
void CRedBlackTree::LeftRotation(INode*strNode)
{
    if(strNode->m_RNode==NULL) return;
    //记录当前节点的父节点
    INode *father=strNode->m_FNode;
    //右节点和父节点相连
    strNode->m_RNode->m_FNode=father;
    strNode->m_RNode->m_Coordinate=ROOT;
    if(NULL!=father)
    {
         if(strNode->m_Coordinate==RIGHT)
           father->m_RNode=strNode->m_RNode;
           else
           father->m_LNode=strNode->m_RNode;

         strNode->m_RNode->m_Coordinate=strNode->m_Coordinate;
    }
    //记录当前节点的右节点的左节点
    INode * Left=strNode->m_RNode->m_LNode;
    //当前与右节点相连
    strNode->m_FNode=strNode->m_RNode;
    strNode->m_RNode->m_LNode=strNode;
    strNode->m_Coordinate=LEFT;
    //当前节点与右节点的左节点相连
    strNode->m_RNode=Left;
    if(NULL!=Left)
    {
        Left->m_FNode=strNode;
        Left->m_Coordinate=RIGHT;
    }
    //如果当前节点是根节点则更新根节点记录
    if(strNode->m_FNode->m_Coordinate==ROOT)
        m_RootNode=strNode->m_FNode;
    return;
}
void CRedBlackTree::RightRotation(INode*strNode)
{
//当前节点没有左节点不能右旋转
    if(NULL==strNode->m_LNode) return ;
    //记录当前节点的祖父节点
    INode *father=strNode->m_FNode;
    //记录当前节点的左节点
    INode *m_LNode=strNode->m_LNode;
    //当前节点的左节点与当前节点的父节点连接
    m_LNode->m_FNode=father;
    m_LNode->m_Coordinate=ROOT;
    if(NULL!=father)
    {    if(strNode->m_Coordinate==LEFT)
           father->m_LNode=m_LNode;
         else
           father->m_RNode=m_LNode;
         m_LNode->m_Coordinate=strNode->m_Coordinate;
    }
    //记录当前节点的左节点的右节点
    INode * Right=strNode->m_LNode->m_RNode;
    //当前节点与左节点连接
    m_LNode->m_RNode=strNode;
    strNode->m_FNode=m_LNode;
    strNode->m_Coordinate=RIGHT;
    //当前节点的左节点与当前节点的左节点的右节点连接
    strNode->m_LNode=Right;
    if(NULL!=Right)
      {
          Right->m_FNode=strNode;
          Right->m_Coordinate=LEFT;
      }
    //如果当前节点是根节点则更新根节点记录
    if(strNode->m_FNode->m_Coordinate==ROOT)
        m_RootNode=strNode->m_FNode;
    return;
}


IT小狼狗
关注
红黑树实现源码
07-22
关于红黑树的功能实现
红黑树源码实现
最帅惋红曲
08-24 1163
继上一篇《思考红黑树》 自己亲自动手把红黑树实现一遍，发现理论成功了要转换为实际代码还是有点难度的，困难点主要在于一些边界点的确定。还是需要进一步提高自己的C功力。 直接贴代码吧，有需要的拿去用，我自己也留着以后拿来玩玩。 这份代码肯定是需要根据实际环境进行修改的，前两天大概扫了一下 《Linux内核中的红黑树》里面的代码，发现自己写的代码水平跟大神写的还是有些差距啊...加油吧。
红黑树源码（含注释）
暗星涌动
11-05 265
红黑树源码（含注释） #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;string.h&gt; #include &lt;time.h&gt; typedef int key_t; typedef enum color_t { RED = 0, BLACK = 1 }color_t; typede...
第十四章 红黑树——C++代码实现
weixin_33691817的博客
11-05 318
红黑树的介绍 红黑树(Red-Black Tree，简称R-B Tree)，它一种特殊的二叉查找树。红黑树是特殊的二叉查找树，意味着它满足二叉查找树的特征：任意一个节点所包含的键值，大于等于左孩子的键值，小于等于右孩子的键值。除了具备该特性之外，红黑树还包括许多额外的信息。 红黑树的每个节点上都有存储位表示节点的颜色，颜色是红(Red)或黑(Black)。红黑树的特性:(1) 每个节点或者是黑...
红黑树源代码
07-24
算法导论红黑树的相关实现代码，经过测试，完美运行
Linux源码红黑树源码案例
06-14
在提供的"RbTree"文件中，包含了修改过的Linux源码中的红黑树实现和调用案例。你可以通过阅读代码了解红黑树的插入、删除和查找等操作的具体实现，以及如何在实际项目中应用这些操作。此外，这个案例还提供了可执行...
拆解改写的独立版红黑树源码
03-16
在这个“拆解改写的独立版红黑树源码”中，我们可以深入理解红黑树的实现原理和优化策略。 红黑树的特性： 1. 每个节点要么是红色，要么是黑色。 2. 根节点是黑色。 3. 所有叶子节点（NIL或空节点）是黑色。 4. ...
红黑树实现源码(C++)
freeland008的专栏
07-10 965
本文展示红黑树的源码，源码是作者由linux内核代码封装成C++类，然后再次封装成API函数的方式。 RBTree.h和RBTree.cpp是用c++类的方式实现了红黑树的封装，RbtAPI.h、RbtAPI.cpp实现了二次封装，更方便开发人员直接使用。 1、RBTree.h #ifndef RBTREE_H #define RBTREE_H #include "RbtAPI.h" #define RB_RED 0 #define RB_BLACK 1 typedef struct r..
红黑树源代码+说明文档+可执行程序
11-15
一、编程环境 VS2005. 二、程序功能 允许用户输入一串数字，模拟建立红黑树的过程； 也可以不输入数字，直接点击“开始”按钮，系统自动10个随机数 能以图形的方式，显示红黑树的建树过程。 红黑树用GDI方式画在屏幕上，非常的漂亮
STL源码：红黑树
Sunshine的专栏
03-30 2840
红黑树的性质和插入操作 这部分参考文章 《红黑树操作及实现》 红黑树节点结构 typedef bool __rb_tree_color_type; const __rb_tree_color_type __rb_tree_red = false; // 红色为0 const __rb_tree_color_type __rb_tree_black = true; // 黑色为1 s
红黑树算法源代码（摘自linux内核代码）
fanxiushu的专栏
01-14 1894
在应用层开发中，STL标准库的map容器内部实现就是红黑树算法， 既然有现成的，可能大部分人都不会写红黑树算法来管理复杂的数据结构， 不过基于许多的考虑，有时很需要自己实现原始的红黑树数据结构。 比如做嵌入式开发，需要效率高的执行代码； 比如在做庞大的服务器，需要高效的处理各种复杂的数据结构， 比如在驱动开发中，需要管理复杂的数据结构，这种情况除了自己实现红黑树之外没别的办法。
TreeMap红黑树源码详解
数据结构和算法
08-22 3961
尊重原创，转载请标明出处   http://blog.csdn.net/abcdef314159 在分析源代码之前，最好要标注出处，因为在Java中和Android中同一个类可能代码就会不一样，甚至在Android中不同版本之间代码也可能会有很大的差别，下面分析的是红黑树TreeMap，在\sources\android-25中。 红黑树的几个性质要先说一下， 1. 每个节点是红色或者黑色的
红黑树源代码C/C++，有注释，操作齐全，自己写的
weixin_52642313的博客
06-07 250
#include<stdio.h> #include<stdlib.h> #include<malloc.h> #include<stdbool.h> typedef struct RBTNode { int data; int color;//1代表红色，0代表黑色 struct RBTNode* left; struct RBTNode* right; struct RBTNode* parent; } RBT,*PRBT; void In_travers
红黑树源码分析
Zyong139064359的博客
06-26 516
所谓的红黑树（RB_tree）不仅是一个二叉搜索树，而且必须满足一下规则： 1）：每个节点不是红色就是黑色 2）：根节点是黑色 3）：如果节点是红色,那么它的子节点必须是黑色 4）：任一结点至NULL(树尾端)的任何路径，所含的黑节点数必须相同 根据规则4）：那么新增结点必须是红色节点，根据规则3）：新增结点的父结点必须是黑色![ 插入结点 当我们插入一些点的时候，可能会违反红黑树的规则,那么我们...
红黑树 ----红黑树的C++完整实现源码
JK198310的专栏
08-13 1555
红黑树的C++完整实现源码 前言：     本人的原创作品红黑树系列文章，至此，已经写到第5篇了。虽然第三篇文章：红黑树的c源码实现与剖析，用c语言完整实现过红黑树，但个人感觉，代码还是不够清晰。特此，再奉献出一份c++的完整实现源码，以飨读者。     此份c++实现源码，代码紧凑了许多，也清晰了不少，同时采取c++类实现的方式，代码也更容易维护以及重用。ok，有任何问题，欢迎指正。
JDK源码解析：红黑树TreeMap深度剖析
"这份资源是关于JDK源码分析的PPT，重点讲解了红黑树（Red-Black Tree，RBT）在TreeMap中的应用。内容包括红黑树的基本概念、性质、删除操作的几种情况，以及与其他数据结构如AVL树的对比。课程还涉及了源码剖析、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值