redBlackTree

最新推荐文章于 2021-06-17 16:37:57 发布
最新推荐文章于 2021-06-17 16:37:57 发布
阅读量140 收藏
点赞数
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qingsong1001/article/details/104157460
版权


#include <stdio.h>
#include <vector>
#include <iostream>

using namespace std;

enum _CORLOR{
    BLACK = 0,
    RED,
    MAX_CORLOR
};

template<class elemType>
struct rbNode{
    rbNode<elemType> *lLink;//left child node
    rbNode<elemType> *rLink;//right child node
    rbNode<elemType> *pLink;//point to parent node
    elemType info;
    int corlor;
};

rbNode<int> nil = {NULL, NULL, NULL, 0x7fffffff, BLACK};

template<class elemType>
rbNode<elemType>* findElem(rbNode<elemType> *root, elemType info)
{
    rbNode<elemType> *pTmp = NULL;
    if(root != NULL)
    {
        if(info == root->info)
        {
            return root;
        }
        if( root->info > info && root->lLink != &nil)
        {
            return findElem(root->lLink, info);
        }
        printf(" %d\n", root->info);
        if(root->info < info && root->rLink != &nil)
        {
            return findElem(root->rLink, info);
        }
    }

    return NULL; 
}

template<class elemType>
rbNode<elemType>* successorElem(rbNode<elemType> *node)
{
    rbNode<elemType> *pTmp = node;
    rbNode<elemType> *pRes = &nil;
    if(node == &nil)
    {
        printf("error: input node is nil\n");
        return NULL;
    }
    if(pTmp != &nil && pTmp->rLink != &nil)
    {
        while(pTmp->lLink != &nil)
        {
            pTmp = pTmp->lLink;
        }
        pRes = pTmp->pLink;
        return pRes;
    }
    while(pTmp != &nil && pTmp->pLink != &nil)
    {
        if(pTmp == pTmp->pLink->rLink)//
        {
            pTmp = pTmp->pLink;
        }
        else
        {
            pRes = pTmp;
            break;
        }
    }

    return pRes; 
}


template<class elemType>
int left_rotate(rbNode<elemType> *root)
{
    if(root == &nil)
    {
        printf("error:input root is NULL\n");
        return 0;
    }
    if(root->rLink == &nil)
    {
        printf("error:right sub tree of root is NULL\n");
        return 0;
    }
    rbNode<elemType> *pTmp = root->rLink;
    root->rLink = pTmp->lLink;
    if(root->rLink != &nil)
    {
        root->rLink->pLink = root;
    }
    pTmp->pLink = root->pLink;
    if(pTmp->pLink->lLink == root)
    {
        pTmp->pLink->lLink = pTmp;
    }
    else
    {
        pTmp->pLink->rLink = pTmp;
    }
    root->pLink = pTmp;
    root->pLink = pTmp;
    pTmp->lLink = root;

    return 0;
}

template<class elemType>
int right_rotate(rbNode<elemType> *root)
{
    if(root == &nil)
    {
        printf("error:input root is NULL\n");
        return 0;
    }
    if(root->lLink == &nil)
    {
        printf("error:right sub tree of root is NULL\n");
        return 0;
    }
    rbNode<elemType> *pTmp = root->lLink;
    root->lLink = pTmp->rLink;
    if(root->lLink != &nil)
    {
        root->lLink->pLink = root;
    }
    pTmp->pLink =  root->pLink;
    if(pTmp->pLink->lLink == root)
    {
        pTmp->pLink->lLink = pTmp;
    }
    else
    {
        pTmp->pLink->rLink = pTmp;
    }
    root->pLink = pTmp;
    pTmp->rLink = root;

    return 0;
}

template<class elemType>
int rb_insert_fixup(rbNode<elemType> **root, rbNode<elemType> *newNode)
{
    rbNode<elemType> *pTmpX = newNode;
    while(pTmpX->pLink->corlor == RED)
    {
        //printf("%s(%d): cur node %d, parent node %d\n", 
    //        __FILE__, __LINE__, pTmpX->info, pTmpX->pLink->info);
        rbNode<elemType> *pTmpFather = pTmpX->pLink;

        //if this is the left child of parent
        if( pTmpFather->pLink != &nil && pTmpFather == pTmpFather->pLink->lLink)
        {
            printf("%s(%d): cur node %d, parent node %d, grand parent %d\n", 
                __FILE__, __LINE__, pTmpX->info, pTmpX->pLink->info,
                pTmpFather->pLink->info);
            rbNode<elemType> *pTmpUncle = pTmpFather->pLink->rLink;
            if(pTmpUncle != &nil && pTmpUncle->corlor == RED)
            {
                printf("enter case 1\n");
                pTmpUncle->corlor = BLACK;
                pTmpFather->corlor = BLACK;
                pTmpFather->pLink->corlor = RED;
                pTmpX = pTmpFather->pLink;//the next process node
            }
            else
            if(pTmpX == pTmpFather->rLink)
            {
                printf("enter case 2\n");
                pTmpX= pTmpFather;//the next process node
                rbNode<elemType> *pTmpY = pTmpX;
                if(*root == pTmpY)
                {
                    *root = pTmpY->rLink;
                }
                left_rotate(pTmpY);
            }
            //case 3
            else
            {
                printf("enter case 3\n");
                pTmpX->pLink->corlor = BLACK;
                if(pTmpX->pLink->pLink != &nil)
                {
                    pTmpX->pLink->pLink->corlor = RED;
                    if(*root == pTmpX->pLink->pLink)
                    {
                        *root = pTmpX->pLink;
                    }
                    right_rotate(pTmpX->pLink->pLink);
                }
            }
        }
        //if this is the right child of parent
        else if(pTmpFather == pTmpFather->pLink->rLink)
        {
            rbNode<elemType> *pTmpUncle = pTmpFather->pLink->lLink;
            if(pTmpUncle->corlor == RED)
            {
                printf("enter r case 1\n");
                pTmpUncle->corlor = BLACK;
                pTmpFather->corlor = BLACK;
                pTmpFather->pLink->corlor = RED;
                pTmpX = pTmpFather->pLink;//the next process node
            }
            else
            if(pTmpX == pTmpFather->lLink)
            {
                printf("enter r case 2\n");
                pTmpX= pTmpFather;//the next process node
                rbNode<elemType> *pTmpY = pTmpX;
                if(*root == pTmpY)
                {
                    *root = pTmpY->lLink;
                }
                right_rotate(pTmpY);
            }
            //case 3
            else
            {
                printf("enter r case 3\n");
                pTmpX->pLink->corlor = BLACK;
                if(pTmpX->pLink->pLink != &nil)
                {
                    pTmpX->pLink->pLink->corlor = RED;
                    if(*root == pTmpX->pLink->pLink)
                    {
                        *root = pTmpX->pLink;
                    }
                    left_rotate(pTmpX->pLink->pLink);
                }
            }
        }
        (*root)->corlor = BLACK;
    }
proc_over:
    return 0;
}

template<class elemType>
int insertNode(rbNode<elemType> **root, rbNode<elemType> *newNode)
{
    rbNode<elemType> *pTmpY = &nil;
    rbNode<elemType> *pTmpX = *root;
    while(pTmpX != &nil)
    {
        printf("%s(%d):pTmpX info %d\n", __FILE__, __LINE__, pTmpX->info);
        pTmpY = pTmpX;
        if( newNode->info == pTmpX->info)
        {
            printf("error:the same info %d in the tree\n", newNode->info);
            break;
        }
        else
        if( newNode->info > pTmpX->info)
        {
            pTmpX = pTmpX->rLink;
        }
        else
        {
            pTmpX = pTmpX->lLink;
        }
    }
    //have the same node in the tree
    if(pTmpX != &nil)
    {
        printf("error:the same info in the tree\n");
        goto proc_over;
    }
    //tree has no entry yet.
    if(pTmpY == &nil)
    {
        *root = newNode;
        newNode->pLink = &nil;
    }
    else
    {
        if( newNode->info > pTmpY->info)
        {
            pTmpY->rLink = newNode;
        }
        else
        {
            pTmpY->lLink = newNode;
        }
        newNode->pLink = pTmpY;
    }
    newNode->lLink = &nil;
    newNode->rLink = &nil;
    newNode->corlor = RED;
    
    printf("%s(%d):root %d\n", __FILE__, __LINE__, (*root)->info);
    traverseTree(*root);
    printf("%s(%d):\n", __FILE__, __LINE__);
    rb_insert_fixup(root, newNode);
    printf("%s(%d):\n", __FILE__, __LINE__);

proc_over:
    return 0;
}

template<class elemType>
int rb_delete_fixup(rbNode<elemType> **root, rbNode<elemType> *delNode)
{
    rbNode<elemType> *pTmpX = delNode;
    while(pTmpX != *root && pTmpX->corlor == BLACK)
    {
        //cur node is the left child of parent
        if(pTmpX == pTmpX->pLink->lLink)
        {
            //brother node
            rbNode<elemType> *pTmpY = pTmpX->pLink->rLink;
            if(pTmpY != &nil && pTmpY->corlor == RED)
            {
                printf("delete fixup left case 1\n");
                //case 1
                pTmpY->corlor = BLACK;
                pTmpY->pLink->corlor = RED;
                if(*root == pTmpY->pLink)
                {
                    *root = pTmpY;
                }
                left_rotate(pTmpY->pLink);
                pTmpY = pTmpX->pLink->rLink;
            }
            if(pTmpY != &nil && pTmpY->lLink->corlor == BLACK 
                && pTmpY->rLink->corlor == BLACK)
            {
                printf("delete fixup left case 2\n");
                //case 2
                pTmpY->corlor = RED;
                pTmpX = pTmpX->pLink;
            }
            else if(pTmpY->lLink != &nil && pTmpY->rLink->corlor == BLACK)
            {
                printf("delete fixup left case 3\n");
                //case 3
                pTmpY->lLink->corlor = BLACK;
                pTmpY->corlor = RED;
                right_rotate(pTmpY);
                pTmpY = pTmpX->pLink->rLink;
            }
            else
            {
                printf("delete fixup left case 4\n");
                //case 4
                pTmpY->corlor = pTmpX->pLink->corlor;
                pTmpX->pLink->corlor = BLACK;
                pTmpY->rLink->corlor = BLACK;
                if(pTmpX->pLink == *root)
                {
                    *root = pTmpX;
                }
                left_rotate(pTmpX->pLink);
            }
        }
        else//cur node is the right child of parent
        {
            //brother node
            rbNode<elemType> *pTmpY = pTmpX->pLink->lLink;
            if(pTmpY != &nil && pTmpY->corlor == RED)
            {
                printf("delete fixup right case 1\n");
                //case 1
                pTmpY->corlor = BLACK;
                pTmpY->pLink->corlor = RED;
                if(*root == pTmpY->pLink)
                {
                    *root = pTmpY;
                }
                right_rotate(pTmpY->pLink);
                pTmpY = pTmpX->pLink->lLink;
            }
            if(pTmpY != &nil && pTmpY->lLink->corlor == BLACK 
                && pTmpY->rLink->corlor == BLACK)
            {
                printf("delete fixup right case 2\n");
                //case 2
                pTmpY->corlor = RED;
                pTmpX = pTmpX->pLink;
            }
            else if(pTmpY->rLink != &nil && pTmpY->lLink->corlor == BLACK)
            {
                printf("delete fixup right case 3\n");
                //case 3
                pTmpY->rLink->corlor = BLACK;
                pTmpY->corlor = RED;
                left_rotate(pTmpY);
                pTmpY = pTmpX->pLink->lLink;
            }
            else
            {
                printf("delete fixup right case 4\n");
                //case 4
                pTmpY->corlor = pTmpX->pLink->corlor;
                pTmpX->pLink->corlor = BLACK;
                pTmpY->lLink->corlor = BLACK;
                if(pTmpX->pLink == *root)
                {
                    *root = pTmpX;
                }
                right_rotate(pTmpX->pLink);
            }
        }
    }

    return 0;
}

template<class elemType>
int deleteNode(rbNode<elemType> **root, rbNode<elemType> *delNode)
{
    rbNode<elemType> *pY = NULL;
    rbNode<elemType> *pX = NULL;
    if(delNode->lLink == &nil || delNode->rLink == &nil)
    {
        pY = delNode;
    }
    else
    {
        pY = successorElem(delNode);
    }
    if(pY->lLink != &nil)
    {
        pX = pY->lLink;
    }
    else
    {
        pX = pY->rLink;
    }
    pX->pLink = pY->pLink;
    if(pY->pLink == &nil)
    {
        *root = pX;
    }
    else
    {
        if(pY = pY->pLink->lLink)
        {
            pY->pLink->lLink = pX;
        }
        else
        {
            pY->pLink->rLink = pX;
        }
    }
    printf("%s(%d): %d, %d, %d\n", __FILE__, __LINE__,
        delNode->info, pY->info, pX->info);
    if(pY != delNode)
    {
        delNode->info = pY->info;
    }
    if(pY->corlor == BLACK)
    {
        printf("%s(%d):enter fixup pY %d\n", __FILE__, __LINE__, delNode->info);
        rb_delete_fixup(root, pX);
    }
    printf("%s(%d): %d, %d\n", __FILE__, __LINE__, delNode->info, pX->info);

    return 0;
}

template<class elemType>
int traverseTree(rbNode<elemType> *root)
{
    if(root != &nil)
    {
        if(root->lLink != &nil)
        {
            traverseTree(root->lLink);
        }
        printf(" %d, parent %d, corlor %s\n", 
                root->info, root->pLink->info, root->corlor==0?"BLACK":"RED");
        if(root->rLink != &nil)
        {
            traverseTree(root->rLink);
        }
    }

    return 0;
}

int main()
{
    vector<int> A;
    A.resize(14);
    rbNode<int> *tree = &nil;
    A ={27, 17, 3, 16, 13, 10, 1, 5, 7, 12, 4, 8, 9, 0};
    for(auto entry:A)
    {
        cout << entry<<endl;
    }
    printf("**************************\n");
    for(auto entry:A)
    {
        rbNode<int> *newNode = new rbNode<int>;
        newNode->info = entry;
        newNode->lLink = &nil;
        newNode->rLink = &nil;
        newNode->pLink = &nil;
        newNode->corlor = RED;

        printf("begin**insert %d, root %d\n", newNode->info, tree->info);
        insertNode(&tree, newNode );
        printf("end**insert %d, root %d***********************\n", newNode->info, tree->info);
        traverseTree(tree);
        printf("**************************\n");
//        if(newNode->info == 3)
//            break;
    }
    traverseTree(tree);
    printf("**************************\n");
    rbNode<int> *delNode = NULL;
    delNode = findElem(tree, 3);
    if(delNode == NULL)
    {
        printf("do not find info %d\n", 3);
    }
    else
    {
        deleteNode(&tree, delNode);
    }
    printf("****** after delete 3, root %d********************\n", tree->info);
    traverseTree(tree);
    printf("**************************\n");

    return 0;
}

singing1001
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【二叉树进阶】红黑树（Red Black Tree） - 平衡二叉搜索树
codewinter的博客
06-21 3214
红黑树，是一种平衡二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是 Red 或 Black。通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出2倍，因而是接近平衡的。AVL树和红黑树：红黑树更多是一种折中的选择，它舍弃平衡二叉树的严格平衡，换取节点插入时尽可能少的调整。因为红黑树的旋转情况少于AVL树，使得红黑树整体性能略优于AVL树，不然map和set底层怎么会用红黑树呢，包括很多语言的库里面都用了红黑树。如果发明AVL树的人是天才的话，那么发明红
红黑树（Red Black Tree）
热门推荐
zhongjie的专栏
05-26 2万+
介绍今天我们来介绍另一种平衡二叉树：红黑树（Red Black Tree），红黑树由Rudolf Bayer于1972年发明，当时被称为平衡二叉B树（symmetric binary B-trees），1978年被Leonidas J. Guibas 和 Robert Sedgewick改成一个比较摩登的名字：红黑树。红黑树和之前所讲的AVL树类似，都是在进行插入和删除操作时通过特定操作保
javascript图解红黑树
雨的印记的博客
02-28 455
图解红黑树 目录图解红黑树一、红黑树的五条规则二、红黑树的三种变换2.1.变色2.2.左旋转2.3.右旋转三、红黑树的插入操作3.1.情况13.2.情况23.3.情况33.4.情况43.5.情况53.6.案例插入10插入9插入8插入7插入6插入5插入4插入3插入2**插入1**四、红黑树的删除操作 一、红黑树的五条规则 红黑树除了符合二叉搜索树的基本规则外，还添加了以下特性： 规则1：节点是红色或黑色的； 规则2：根节点是黑色的； 规则3：每个叶子节点都是黑色的空节点（NIL节点）； 规则4：每个红色节点
那些年，面试被虐过的红黑树
weixin_34211761的博客
03-27 497
2019独角兽企业重金招聘Python工程师标准>>> ...
RedBlackTree.zip
04-09
红黑树（Red Black Tree）是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。 红黑树是一种特化的AVL树（平衡二叉树），都是在进行插入和删除操作时通过特定操作保持二叉树的...
RedBlackTree
03-28
红黑树（Red-Black Tree）是一种自平衡二叉查找树，它是在1972年由鲁道夫·贝尔（Rudolf Bayer）首次提出的。在Java编程语言中，红黑树是`java.util.TreeMap`和`java.util.TreeSet`等数据结构的基础。红黑树的主要...
redblacktree:golang中的自平衡二叉搜索树
06-16
import ( "fmt" rbt "github.com/erriapo/redblacktree")func main () { t := rbt . NewTree () t . Put ( 7 , "payload7" ) t . Put ( 3 , "payload3" ) t . Put ( 1 , "payload1" ) fmt . Printf ( "size = %d \n...
RedBlackTree.rar
07-27
2. `RedBlackTree`类：包含树的结构和操作，如插入、删除、查找、旋转等方法。 3. `.h`文件：定义类的接口，声明成员函数和数据。 4. `.cpp`文件：实现类的成员函数，包含具体算法的逻辑。 这个项目的源代码可以...
RBT.rar_red black tree_红黑树
09-24
红黑树（Red-Black Tree）是一种自平衡二叉查找树，由计算机科学家鲁道夫·贝尔在1978年提出。它在保持二叉查找树特性的同时，通过引入颜色属性来确保树的平衡，从而提高数据操作的效率。在C++中实现红黑树，通常...
红黑树Red/Black Tree
JZ
09-30 1万+
红黑树Red/Black Tree 建立二进制搜索树，我们得到红/黑树，旨在解决BST可能变得不平衡的问题。（BST【二叉搜索树】，是对于任意的node x，如果node y是node x的左边的节点, 那么Key(y) &lt;= Key(x); 对于任意的node x， 如果node y 是node x的右边的节点， 那么key(y)&gt;=key(x).） 红色/黑色树的简短版本是它是...
Red-Black Tree
seayoung的博客
11-22 317
Red-Black Tree
红黑树(Red–black tree)
小码农想做大架构的博客
06-17 813
一、红黑树的概念: 在计算机科学中，红黑树是一种自平衡二叉搜索树。每个节点存储一个表示“颜色”（“红”或“黑”）的额外位，用于确保树在插入和删除期间保持平衡。 当树被修改时，新树被重新排列和“重新绘制”以恢复着色属性(整个树的红黑结点会重新进行绘制，以适应红黑树的颜色排列规则)，这些属性限制了树在最坏情况下的不平衡程度。属性的设计使得这种重新排列和重新排序可以有效地执行。 重新平衡不是完美的(不能像平衡二叉树一样绝对平衡，只能做到相对平衡)，但保证了搜索的时间，其中是树的节点数。插入和删除操作以及树的重新
red black tree
screaming的博客
11-12 507
Red-Black Tree | Set 1 (Introduction) Red-Black Tree is a self-balancing Binary Search Tree (BST) where every node follows following rules. 1) Every node has a color either red or black. 2)
深入浅出：红黑树（Red Black Tree）
wjc920
07-04 2882
红黑树（Red Black Tree）的五个性质 节点是红色或黑色。 根节点是黑色。 每个叶节点（NIL节点，空节点）是黑色的。 每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点) 从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。 注：红黑树本质是平衡树，所以对于每个节点，还满足左子树节点小于该节点，同时右子树节点大于该节点。 基本操作...
红黑树之歌
taowen2002的专栏
03-24 1673
--> The Red-Black Tree Song[To the tune of Paint It Black, with my utmost apologies to the Rolling Stones] I see a brand new nodeI want to paint it black. We need a balanced tree,weve go
数据结构——The Red-Black Tree Song
绿茶的专栏
01-27 1853
　　又下雪了，只是上海的温润让她过早的融化。昨天冒雪买车票了，短途车还是挺好买的，有长途乘火车的同学只能去买黄牛票，结果碰到票价涨得不厉害的，又犹豫怕是假票，唉，春运问题难呐，要彻底解决，在中国，估计只能春节不放假了^-^。今天早起，尚来得及看到一点雪后的痕迹。上一次都没见到地上积起来，后来回校时，才从残留的痕迹中想象南京那边的雪。最近手气不行，可能本命年的缘故，打牌也不顺，只有去吃烤肉串的命瓦。
红黑树之歌 (转)
csd3176的博客
12-13 325
红黑树之歌 (转)[@more@]--&gt The Red-Black Tree Song [To the tune of Paint It Black, with my utmost apologie...
public RedBlackTree.IRBNode Left { get { if (leftSibling == DirectoryEntry.NOSTREAM) return null; return dirRepository[leftSibling]; } set { leftSibling = value != null ? ((IDirectoryEntry)value).SID : DirectoryEntry.NOSTREAM; if (leftSibling != DirectoryEntry.NOSTREAM) dirRepository[leftSibling].Parent = this; } }这段代码是什么意思，c#
最新发布
06-07
这段代码是一个属性的定义，该属性名为 `Left`，返回类型为 `RedBlackTree.IRBNode` 接口类型。这个属性的作用是获取或设置当前节点的左兄弟节点。 具体实现是：如果 `leftSibling` 的值为 `DirectoryEntry....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值