实现红黑树

最新推荐文章于 2021-12-22 17:06:28 发布
最新推荐文章于 2021-12-22 17:06:28 发布
阅读量1.2k 收藏
点赞数
分类专栏： c/c++语言 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_16836151/article/details/51911096
版权 
红黑树是一个比较常用到数据结构，是一个比AVL树有着更好的搜索能力的树形结构。

  1. 红黑树是一种自平衡二叉查找树
    典型的用途是实现关联数组。它是复杂的，但它的操作有着良好的最坏情况运行时间，并且在实践中是高效的: 它可以在O(log n)时间内做查找，插入和删除，这里的n 是树中元素的数目。

  2. 红黑树是一种很有意思的平衡检索树
    它的统计性能要好于平衡二叉树(AVL-树)，因此，红黑树在很多地方都有应用。在C++ STL中，很多部分(目前包括set, multiset, map, multimap)应用了红黑树的变体(SGI STL中的红黑树有一些变化，这些修改提供了更好的性能，以及对set操作的支持)。

红黑树的每个节点上的属性除了有一个key、3个指针：parent、lchild、rchild以外，还多了一个属性：color。它只能是两种颜色：红或黑。而红黑树除了具有二叉搜索树的所有性质之外，为了方便计算和统计节点的个数，增加了lcount和rcount。具有以下4点性质：

  1. 根节点是黑色的。
  2. 空节点是黑色的（红黑树中，根节点的parent以及所有叶节点lchild、rchild都不指向NULL，而是指向一个定义好的空节点）。
  3. 红色节点的父、左子、右子节点都是黑色。
  4. 在任何一棵子树中，每一条从根节点向下走到空节点的路径上包含的黑色节点数量都相同。

需要说明的是：红黑树并不是一个红黑交替的树型结构，第一红黑树的性质并没有保证说是不能有两个连续的黑色节点；第二在我们删除的时候是可能存在删除掉了红色节点， 是有可能有连续的两个黑色节点的可能。

#ifndef __RB_TREE_H
#define __RB_TREE_H
#include <iostream>
#include <functional>

struct key
{
    int a;
};
typedef key KeyType;

struct RBTNode 
{
    bool    color;
    int     lcount;
    int     rcount;
    KeyType key;
    RBTNode * leftchild;
    RBTNode * rightchild;
    RBTNode * parent;
};
class RBTree
{
public:
    RBTree(RBTNode * p = NULL)
        :m_root(NULL),
        m_null(new RBTNode)
    {
        m_null->color = BLACK;
        m_root = m_null;
    }
    ~RBTree()
    {
        clear();
        delete m_null;
    }
    bool insert(const KeyType & x)
    {
        RBTNode * node = new RBTNode;
        node->key    = x;
        node->lcount = 0;
        node->rcount = 0;
        node->leftchild = m_null;
        node->rightchild = m_null;
        //node->parent = m_null;
        node->color = RED; // new node should set red to keep 
                           //each path has the number of black node

        RBTNode * p   = m_root;
        RBTNode * leaf = m_null;

        while ( p != m_null){ // find the leaf position
            leaf = p;
            if (keycmp (node->key,p->key) < 0){
                p->lcount++;
                p = p->leftchild;
            } else if (keycmp(node->key,p->key) > 0){
                p->rcount++;
                p = p->rightchild;
            } else if(keycmp(node->key,p->key) == 0) {
                return false;
            }
        }
        node->parent = leaf; // connection the tree of the leaf
        if(leaf == m_null){
            m_root = node;
        } else if( keycmp( node->key,leaf->key) < 0){
            leaf->leftchild = node;
        } else {
            leaf->rightchild = node;
        }

        insbalance(node);

        return true;
    }
    bool del(const KeyType & x)
    {
        RBTNode *node = search(x);
        if(node == NULL) return false;
        RBTNode * toDel = node;
        if(node->leftchild != m_null && node->rightchild != m_null){
            toDel = Next(node);
        } // double branch

        RBTNode *p = toDel; // adujust the number of the child count
        while (p->parent != m_null){ 
            if(p == p->parent->leftchild){
                p->parent->lcount--;
            } else {
                p->parent->rcount--;
            }
            p = p->parent;
        } //end while adjust the number of the number

        // single branch
        RBTNode *replace = toDel->leftchild != m_null ? 
                    toDel->leftchild:
                    toDel->rightchild;

        replace->parent = toDel->parent; // find the parent node
        if(replace->parent == m_null){ //m_root
            m_root = replace;
        } else if( toDel == toDel->parent->leftchild){
            replace->parent->leftchild = replace;
        } else {
            replace->parent->rightchild = replace;
        }

        if(toDel != node ){ // replace the key value
            node->key = toDel->key;
        }

        if(toDel->color == BLACK){ // this the only case ,need to reblace the tree  
            delbalance(replace);
        }

        delete toDel;
        return true;
    }
    RBTNode *atIndex(int i)
    {
        RBTNode * result = m_root;
        if( i > result->lcount + result->rcount){
            return NULL;
        } else {
            while( i != result ->lcount){
                if(i < result->lcount){
                    result = result->leftchild;
                } else {
                    i -= result->lcount +1; // 直接掉过左分支
                    result = result->rightchild;
                }
            }
        }
    }
    void toArray(int *arr)
    {
        RBTNode * p = Min();
        int i = 0;
        while (p != m_null){
            arr[i++] = p->key.a;
            p = Next(p);
        }
    }
    RBTNode * Max() const 
    {
        RBTNode * p = m_root;
        while ( p->rightchild != m_null){
             p = p->rightchild;
        }

        return  p;
    }
    RBTNode* Min()const 
    {
        RBTNode *p = m_root;
        while (p->leftchild != NULL){
             p = p->leftchild;
        }

        return p;
    }
    int size()const 
    {
        return m_root != m_null ? 
            m_root->lcount + m_root->rcount + 1 : 0;
    }
    RBTNode * search(const KeyType & key)
    {
        RBTNode * p = m_root;
        while( p != m_null && keycmp(key,p->key) != 0){
             p = keycmp(key,p->key)<0 ? p->leftchild :p->rightchild;
        }

        return p == m_null ? NULL :p;
    }

private:
    void delbalance(RBTNode *node)
    {
        RBTNode *p = node;
        while ( p != m_root && p->color == BLACK){
            if(p == p->parent->leftchild){ // find the node of node's brother
                RBTNode *sibling = p->parent->rightchild;
                if(sibling->color == RED){ // 
                    sibling->color = BLACK;
                    p->parent->color = RED;
                    leftRotate(p->parent);
                    sibling = p->parent->rightchild;
                }
                if(sibling->leftchild->color == BLACK &&
                    sibling->rightchild->color == BLACK){
                    sibling->color = RED;
                    p = p->parent;
                } else {
                    if(sibling->rightchild->color == BLACK){
                        sibling->leftchild->color = BLACK;
                        sibling->color = RED;
                        rightRotate(sibling);
                        sibling = sibling->parent;
                    }
                    sibling->color = sibling ->parent->color;

                    sibling->parent->color = BLACK;
                    sibling->rightchild->color = BLACK;
                    leftRotate(sibling->parent);
                    p = m_root;
                }
            } else {
                RBTNode *sibling = p->parent->leftchild;
                if(sibling->color == RED){
                    sibling->color = BLACK;
                    p->parent->color = RED;
                    rightRotate(p->parent);
                    sibling = p->parent->leftchild;
                }
                if(sibling->leftchild->color == BLACK &&
                    sibling->rightchild->color == BLACK){
                    sibling->color = RED;
                    p = p->parent;
                } else {
                    if(sibling->leftchild->color == BLACK){
                        sibling->rightchild->color = BLACK;
                        sibling->color = RED;
                        leftRotate(sibling);
                        sibling = sibling->parent;
                    }
                    sibling->color = sibling->parent->color;
                    sibling->parent->color = BLACK;
                    sibling->leftchild->color = BLACK;
                    rightRotate(sibling->parent);
                    p = m_root;
                }
            }
        }
        p->color = BLACK;
    }
    inline void leftRotate(RBTNode * node )
    {
        RBTNode *newroot = node->rightchild;
        node->rightchild = newroot->leftchild;
        node->rcount = newroot->lcount;  // newroot left to node's right 
        newroot->leftchild->parent = node;
        newroot->parent = node->parent;
        if(newroot->parent == m_null){
            m_root = newroot;   
        } else if(node == node->parent->leftchild){
            node->parent->leftchild = newroot;
        } else {
            node->parent->rightchild = newroot;
        }
        newroot->leftchild = node;
        newroot->lcount += node->lcount+1;
        node->parent = newroot;

    }
    inline void rightRotate(RBTNode *node)
    {
        RBTNode * newroot = node->leftchild;
        node->leftchild   = newroot->rightchild;
        node->lcount = newroot->rcount;
        node->leftchild->parent = node;
        newroot->parent = node->parent;

        if(newroot->parent == m_null){
            m_root = newroot;
        } else if (node == node->parent->leftchild){
            node->parent->leftchild = newroot;
        } else {
            node->parent->rightchild = newroot;
        }
        newroot->rightchild = node;
        newroot->rcount += node->rcount +1;
        node->parent = newroot;
    }
    void insbalance(RBTNode *node)
    {
        RBTNode *z = node;
        while( z->parent->color == RED){
            if(z->parent == z->parent->parent->leftchild){
                RBTNode *uncle = z->parent->parent->rightchild;
                if(uncle->color == RED){  // uncle is red ,to set the color of black: p->parent and uncle , set the p->parent->parent black 
                    z->parent->color = BLACK;
                    uncle->color = BLACK;
                    z->parent->parent->color = RED;
                    z = z->parent->parent; // circle to the rebalance : z = z->parent->parent
                } else {
                    if( z == z->parent->rightchild) { // if z is the right of the parent
                        z = z->parent;
                        leftRotate(z);
                    }
                    z->parent->color = BLACK;
                    z->parent->parent->color = RED;
                    rightRotate(z->parent->parent);
                }
            } else {
                RBTNode *uncle = z->parent->parent->leftchild;
                if(uncle->color == RED){
                    z->parent->color = BLACK;
                    uncle->color = BLACK;
                    z->parent->parent->color = RED;
                    z = z->parent->parent;
                } else {
                    if( z == z->parent->leftchild){
                        z = z->parent;
                        rightRotate(z);
                    } 
                    z->parent->color = BLACK;
                    z->parent->parent->color = RED;
                    leftRotate(z->parent->parent);
                }
            }
        }

        m_root->color = BLACK;
    }
    RBTNode *left(RBTNode * node)
    {
        RBTNode * result = node;
        while (result ->leftchild != m_null){
            result = result->leftchild;
        }
        return result;
    }
    RBTNode *right(RBTNode *node)
    {
        RBTNode * result = node;
        while (result ->rightchild != m_null){
            result = result->rightchild;
        }

        return result;
    }
    RBTNode *Next(RBTNode *node)
    {
        if(node == NULL) return NULL;

        RBTNode * p = node;
        if(p->rightchild != m_null){
            p = left(p->rightchild);
        } else {
             p = node->parent;
             RBTNode * temp = node;
             while( p != m_null && temp == p->rightchild ){
                temp = p;
                p = p->parent;
             }
        }

        return p;
    }
    RBTNode *Prev(RBTNode *node)
    {
        if(node == NULL ) return NULL;
        RBTNode * result = node;    
        if(result ->leftchild != m_null){
            result = left(result->rightchild);
        } else {
            result = node->parent;
            RBTNode *temp = node;
            while (result != m_null && temp == result->leftchild){
                temp = result;
                result = result->parent;
            }
        }

        return result;
    }
    inline int keycmp(const KeyType & key1,const KeyType & key2)
    {
        return key1.a - key2.a;
    }
    void clear()
    {
        RBTNode * p = m_root;
        while(p != m_null){
            if(p->leftchild != m_null){
                p = p->leftchild;
            } else if ( p->rightchild != m_null){
                p = p->rightchild;
            } else {
                RBTNode *temp = p;
                p = p->parent;
                if(temp == p->leftchild){
                    p->leftchild  = m_null;
                } else {
                    p->rightchild = m_null;
                }
                delete temp;
            }
        }
    }
private:
    const static bool RED = true;
    const static bool BLACK = false;
    RBTNode * m_root;
    RBTNode * m_null;
};

#endif

简单的测试：

#include "RBTree.hpp"
#include <iostream>
using namespace std;

int main()
{
    RBTree tree;
    KeyType ar[] = {2,45,56,34,54,232,56,567,33,34,56,232,23,44};
    int len = sizeof(ar)/sizeof(ar[0]);
    for(int i = 0; i< len ;i++){
        cout<<tree.insert(ar[i]);
    }

    cout<<endl;
    for(int i = 0; i <len;i++){
        cout<<tree.del(ar[i]);
    }

    return 0;
}

详细的解析请看附带的pdf文件

AdolphLua
关注
专栏目录
数据结构——红黑树(RB-Tree)
关注校招求职，微信号：job_campus
08-06 4011
红黑树本质上是一棵二叉查找树，但在二叉查找树的基础上，每个节点增加了一位存储来表示节点的颜色。有关二叉查找树的介绍在前面博文已经介绍过了，这里不再进行讲解。 红黑树的性质： 1）每个结点要么是红的，要么是黑的。 2）根结点是黑的。 3）每个叶结点（叶结点即指树尾端NIL指针或NULL结点）是黑的。 4）如果一个结点是红的，那么它的俩个儿子都是黑的。 5）对于任一结点而言，其
手把手实现红黑树
热门推荐
@Echo· 个人技术笔记
09-26 2万+
一步一步彻底实现红黑树，面试不再愁。
红黑树实现
魔筝炼药师
03-29 477
待更新
红黑树的实现
ailinyingai的博客
12-05 105
红黑树的特性: （1）每个节点或者是黑色，或者是红色。 （2）根节点是黑色。 （3）每个叶子节点（NIL）是黑色。 [注意：这里叶子节点，是指为空(NIL或NULL)的叶子节点！] （4）如果一个节点是红色的，则它的子节点必须是黑色的。 （5）从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。 from random import randint RED = 'red' BLACK ...
实现一个红黑树
Orville的博客
09-14 174
enum Color{     RED,BLACK;     } public class RedBlackTree {     static class TreeNode{         int val;         TreeNode left;         TreeNode right;         TreeNode father;         Color color;  ...
C++简单实现红黑树的插入
最新发布
06-06
在C++中实现红黑树，我们需要理解其特性并将其转化为代码。以下是关于红黑树插入操作的详细讲解。 红黑树有以下性质： 1. 每个节点要么是红色，要么是黑色。 2. 根节点是黑色。 3. 所有叶子节点（NIL或空节点）是...
java算法实现红黑树完整代码示例
08-28
"java算法实现红黑树完整代码示例" 红黑树（英语：Red–black tree）是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。红黑树的另一种定义是含有红黑链接并满足下列条件的...
通过Java实现红黑树及其可视化
12-09
通过Java实现红黑树及其可视化 对于节点的定义，包含节点的数值、节点的颜色、节点的父节点、节点的左右叶子结点 通过Java实现红黑树，包括红黑树的插入操作、删除操作、维护红黑树性质的操作以及常用的方法函数...
java中treemap和treeset实现红黑树
08-28
Java 中 TreeMap 和 TreeSet 实现红黑树 Java 中的 TreeMap 和 TreeSet 都是基于红黑树的数据结构实现的。红黑树是一种自平衡的排序二叉树，它可以保证在插入、删除和搜索操作时都能维持平衡，从而确保搜索、插入...
红黑树的实现与应用
09-03
用C语言写的基于红黑树实现的图书管理系统，数据结构课程设计，压缩包里边包括设计的程序和设计说明书。在图书管理系统中, 当图书的数量非常大时, 那么查找效率就会明显变低, 此时采用 一些优化手段就非常必要。采用红黑树这种数据结构来提高系统性能。......因为红黑树的查找效率高, 所以此方法可以提高系统性能。
实现一颗红黑树
weixin_43843724的博客
06-06 266
红黑树介绍 实现一个红黑树，记录一下，以后忘了也有这篇文章可以复习 使用的Java语言实现 红黑树的介绍 红黑树是一颗特殊的二叉查找树。它包含二叉树的所有特性。 二叉树查找树的特性： 1、每一个节点只有2个分支 2、左子树的结点值要小于或等于它的根结点的值。 3、右子树的结点值要大于或等于它的根结点的值。 红黑树的特性 1、加入了颜色（红色、黑色。非红即黑），用其他颜色也行，只要你记住颜色的作用区分就行 2、根节点是黑色、插入的新节点是红色 3、当前节点不能与父节点同为红色（如果一个节点为红
简单实现红黑树
qq_40708167的博客
04-16 154
红黑树简单实现构建插入查找删除总结 构建 红黑树是一个较平衡二叉树 具有性质： 节点是红色或黑色。 根节点是黑色。 所有叶子都是黑色。（叶子是NUIL节点） 每个红色节点的两个子节点都是黑色。（从每个叶子到根的所有路径上不能有两个连续的红色节点） 从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点 对于结点的信息有：该节点的颜色、左右儿子指针、该节点储存的数据 #define RED 1...
数据结构(十 一) ---[实现红黑树(Red Black Tree)]
从零开始的异世界JAVA学习
12-22 557
红黑树（Red Black Tree） 是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。 红黑树是在1972年由Rudolf Bayer发明的，当时被称为平衡二叉B树（symmetric binary B-trees）。后来，在1978年被 Leo J. Guibas 和 Robert Sedgewick 修改为如今的“红黑树”。 红黑树是一种特化的AVL树（平衡二叉树），都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找
红黑树
qbj071hl
01-20 100
红黑树 2011年03月28日 　　学无止境，把这几年收藏的文章都晒出来，大家共享吧! 声明：早期转载的文章未标明转载敬请原谅，以后将陆续改过来，向原创者致敬！ C++ , Direct3D, OpenGL, GPU,OGRE,OSG,STL, Lua, Python, MFC, Win32 (有问题可留言，部分网页看不到图片可网页另存为到本地再打开即可看到) 痞子龙3D编程 QQ技术交...
红黑树的快速实现
暗星涌动
09-14 1360
红黑树的概述： 红黑树本质上是一种二叉查找树，但它在二叉查找树的基础上额外添加了一个标记（颜色），同时具有一定的规则。这些规则使红黑树保证了一种平衡，插入、删除、查找的最坏时间复杂度都为 O(logn)。 红黑树的性质： 1、每个节点要么是红色，要么是黑色； 2、根节点永远是黑色的； 3、所有的叶节点都是是黑色的（注意这里说叶子节点其实是上图中的 NIL 节点）； 4、每个红色节点的两个子节...
红黑树的实现（图文详解）
AllenSquirrel
05-24 3947
红黑树的实现 红黑树的定义 红黑树的结构
实现一个完整功能的红黑树
weixin_46395757的博客
02-24 119
java语言实现红黑树 参照小码哥《恋上数据结构与算法》中实现的一颗红黑树 private static final boolean RED = false; private static final boolean BLACK = true; // 用户可自定义比较策略 private Comparator<E> comparator; public RB...
数据结构拾遗(1) --红黑树的设计与实现(上)
weixin_30835649的博客
02-17 123
红黑树是一种自平衡的二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组(C++STL中的map/set)。它是在1972年由RudolfBayer发明的，他称之为"对称二叉B树"，它现代的名字是在LeoJ.Guibas和RobertSedgewick于1978年写的一篇论文中获得的。红黑树虽然很复杂，但它的操作有着良好的最坏情况运行时间，并且在实践中...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值