C++实现红黑树基本操作

最新推荐文章于 2024-08-19 18:41:12 发布
最新推荐文章于 2024-08-19 18:41:12 发布
阅读量105 收藏
点赞数 1
文章标签： c++ 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84827689/article/details/141037075
版权

 

#include <iostream>
#include<cstdio>
#include<cstdlib>
using namespace std;
#define RED 0  //红色用数字0表示
#define BLACK 1 //黑色用数字1表示
#define COLOR(x) ((x)->color)//获取x节点颜色
#define PARENTNODE(x) ((x)->parentNode)//获取x节点的父节点
#define SET_PARENT(x,p) ((x)->parentNode=(p)) //设置x节点的父节点
#define SET_COLOR(x,c) ((x)->color=(c))//设置x节点的颜色
#define SET_BLACK(x) ((x)->color=BLACK) //将x节点的颜色置为黑色
#define SET_RED(x) ((x)->color=RED) //将x节点的颜色置为红色
#define IS_BLACK(x) ((x)->color==BLACK)//判断x节点的颜色是否为黑色
#define IS_RED(x) ((x)->color==RED) //判断x节点的颜色是否为红色


typedef struct RBTNode
{

    int color;//红黑树的节点颜色
    int key;//红黑树节点的值
    struct RBTNode* parentNode;//父节点
    struct RBTNode* lChild;//左孩子
    struct RBTNode* rChild;//右孩子

} Node; //定义红黑树结点
typedef struct RBTree
{

    Node* root;//根节点
    int treeSize;//树的大小
} RBTree;
Node* createNode(int data);//创建红黑树节点
void leftRotation(RBTree* tree,Node* x);//将x节点左旋
void rightRotation(RBTree* tree,Node* y);//将y节点右旋
void traversePreorder(Node* root);//先序遍历红黑树
void traverseInorder(Node* root);//中序遍历红黑树

RBTree* createBbtree();//创建一棵红黑树
void adjustNode(RBTree* tree,Node* node);//调整结点
void insertRbtree(RBTree* tree,Node* node);//插入节点
Node* searchNode(Node* root,int key);//查找节点
void adjustDelete(RBTree* tree,Node* node,Node* parent); //调整删除节点
void deleteNode(RBTree* tree,Node* node);//删除节点
void deleteRbtree(RBTree* tree,int key);//根据已知数值删除节点



int main()
{
    int arr[9]= {10,40,30,60,90,70,20,50,80};
    int length=9;
    RBTree* tree=createBbtree();//创建一棵红黑树
    for(int i=0; i<length; i++)
    {
        insertRbtree(tree,createNode(arr[i]));//往红黑树中插入节点

    }
    printf("先序遍历结果如下：\n");
    traversePreorder(tree->root);//先序遍历红黑树
    printf("--------------------\n");
    printf("中序遍历的结果如下：\n");
    traverseInorder(tree->root);//中序遍历红黑树
    printf("--------------------\n");

    deleteRbtree(tree,80);//删除80


    printf("先序遍历结果如下：\n");
    traversePreorder(tree->root);//先序遍历红黑树
    printf("--------------------\n");
    printf("中序遍历的结果如下：\n");
    traverseInorder(tree->root);//中序遍历红黑树
    printf("--------------------\n");




    return 0;
}


Node* createNode(int data)//创建红黑树节点
{
    Node* newNode=new Node;
    newNode->color=BLACK;//把新节点的颜色置为黑色
    newNode->key=data;
    //初始化节点
    //将父节点和左右孩子节点均置为空
    newNode->parentNode=NULL;
    newNode->lChild=NULL;
    newNode->rChild=NULL;
    return newNode;//返回新创建的节点

}

void leftRotation(RBTree* tree,Node* x)//将x节点左旋
{
    Node* y=x->rChild;
    x->rChild=y->lChild;
    if(y->lChild!=NULL)
    {
        y->lChild->parentNode=x;

    }
    y->parentNode=x->parentNode;
    if(x->parentNode==NULL)//判断x节点是否为根节点
    {

        tree->root=y;
    }
    else if(x->parentNode->lChild==x)//判断x是否为左子树
    {
        x->parentNode->lChild=y;
    }
    else
    {
        x->parentNode->rChild=y;
    }
    y->lChild=x;
    x->parentNode=y;
}
void rightRotation(RBTree* tree,Node* y)//将y节点右旋
{
    Node* x=y->lChild;
    y->lChild=x->rChild;
    if(x->rChild!=NULL)
    {
        x->rChild->parentNode=y;
    }
    x->parentNode=y->parentNode;
    if(y->parentNode==NULL)//判断y节点是否为根节点
    {
        tree->root=x;
    }
    else if(y==y->parentNode->lChild)
    {
        y->parentNode->lChild=x;
    }
    else
    {
        y->parentNode->rChild=x;
    }
    x->rChild=y;
    y->parentNode=x;
}

void traversePreorder(Node* root)//先序遍历红黑树
{

    if(root!=NULL)//判断该树是否为空
    {
        //打印节点的值和颜色
        printf("%d---%s\n",root->key,root->color?"black":"red");
        traversePreorder(root->lChild);
        traversePreorder(root->rChild);
    }

}
void traverseInorder(Node* root)//中序遍历红黑树
{
    if(root!=NULL)
    {
        traverseInorder(root->lChild);
        printf("%d---%s\n",root->key,root->color?"black":"red");
        traverseInorder(root->rChild);
    }
}
RBTree* createBbtree()//创建一棵红黑树
{
    RBTree* tree=new RBTree;
    tree->root=NULL;//将树的根节点初始化为空
    tree->treeSize=0;//将树的大小初始化为0
    return tree;
}

void adjustNode(RBTree* tree,Node* node)//调整节点
{
    Node* parent,*Gparent;
    while((parent=PARENTNODE(node))&&IS_RED(parent))//判断父节点是否非空且颜色是否是红色
    {
        Gparent=PARENTNODE(parent);//获取祖父节点
        if(parent==Gparent->lChild)//父节点是祖父节点的左孩子
        {
            //情况一：叔叔节点是红色
            Node* uncle=Gparent->rChild;
            if(uncle && IS_RED(uncle))
            {
                SET_BLACK(uncle);//将叔叔节点设置为黑色
                SET_BLACK(parent);//将父节点设置为黑色
                SET_RED(Gparent);//将祖父节点设置为红色
                node=Gparent;
                continue;

            }
            //情况二：叔叔节点是黑色，当前节点是右孩子
            else if(parent->rChild==node)
            {
                leftRotation(tree,parent);
                Node* temp=parent;
                parent=node;
                node=temp;
            }
            else
            {
                //情况三：叔叔节点是黑色，当前节点是左孩子
                SET_BLACK(parent);//将父节点设置为黑色
                SET_RED(Gparent);//将祖父节点设置为红色
                rightRotation(tree,Gparent);

            }

        }
        else
        {

            //情况一：叔叔节点是红色
            Node* uncle=Gparent->lChild;
            if(uncle && IS_RED(uncle))
            {
                SET_BLACK(uncle);//将叔叔节点设置为黑色
                SET_BLACK(parent);//将父节点设置为黑色
                SET_RED(Gparent);//将祖父节点设置为红色
                node=Gparent;
                continue;

            }
            //情况二：叔叔节点是黑色，当前节点是右孩子
            else if(parent->lChild==node)
            {
                rightRotation(tree,parent);
                Node* temp=parent;
                parent=node;
                node=temp;
            }
            else
            {
                //情况三：叔叔节点是黑色，当前节点是左孩子
                SET_BLACK(parent);//将父节点设置为黑色
                SET_RED(Gparent);//将祖父节点设置为红色
                leftRotation(tree,Gparent);

            }
        }


    }
    SET_BLACK(tree->root);//将根节点设置为黑色

}


void insertRbtree(RBTree* tree,Node* node)//插入节点
{
    Node* preNode=NULL;//前驱节点
    Node* curNode=tree->root;//将当前节点设置为根节点
    while(curNode!=NULL)//判断当前节点是否为空
    {

        preNode=curNode;
        if(node->key<curNode->key)
        {
            curNode=curNode->lChild;//插入节点的值小于当前节点的值就往左走

        }
        else
        {
            curNode=curNode->rChild;
        }
    }
    SET_PARENT(node,preNode);//将插入节点的父节点设置为前驱节点
    if(preNode!=NULL)//判断前驱节点是否为空
    {
        if(preNode->key>node->key)
        {
            preNode->lChild=node;
        }
        else
        {
            preNode->rChild=node;
        }

    }
    else
    {
        tree->root=node;//若前驱节点为空，说明插入节点是根节点
    }
    SET_COLOR(node,RED);//将插入节点设置为红色
    tree->treeSize++;//插入节点后树的大小加1
    adjustNode(tree,node);//调整节点

}

Node* searchNode(Node* root,int key)//查找节点
{
    if(root==NULL||root->key==key)
    {
        return root;
    }
    else if(key<root->key)
    {
        return searchNode(root->lChild,key);
    }
    else
    {
        return searchNode(root->rChild,key);
    }
}

void adjustDelete(RBTree* tree,Node* node,Node* parent) //调整删除节点
{
    Node* brother;//删除节点的兄弟节点
    while(!node||(IS_BLACK(node)&&node!=tree->root))//当节点非空或节点为黑色节点且不是根节点时
    {
        if(parent->lChild==node)//删除节点是左孩子
        {
            brother=parent->rChild;
            if(IS_RED(brother))
            {
                //第一种情况：兄弟节点是红色节点
                SET_BLACK(brother);//将兄弟节点设置为黑色
                SET_RED(parent);//把父节点设置为红色
                leftRotation(tree,parent);//以父节点为支点作左旋操作
                brother=parent->rChild;//将兄弟节点设置为左旋操作后的右孩子


            }
            if((!brother->lChild)&&(!brother->rChild))//判断兄弟节点是否为叶子节点
            {
                //第二种情况：兄弟节点是黑色的
                SET_RED(brother);//将兄弟节点设置为红色
                node=parent;//将当前节点设置为父节点
                parent=PARENTNODE(node);

            }
            else
            {
                if((!brother->rChild)||IS_BLACK(brother->rChild))
                {
                    //第三种情况：兄弟节点是黑色的，兄弟节点的左孩子是红色的，右孩子是黑色的
                    SET_BLACK(brother->lChild);//将兄弟节点的左孩子设置为黑色
                    SET_RED(brother);//将兄弟节点设置为红色
                    rightRotation(tree,brother);//以兄弟节点为支点进行右旋操作
                    brother=parent->rChild;//将兄弟节点设置为父节点的右孩子

                }
                else
                {
                    SET_COLOR(brother,COLOR(parent));//将兄弟节点的颜色设置为父节点的颜色
                    SET_BLACK(parent);//将父节点设置为黑色
                    SET_BLACK(brother->rChild);//将兄弟节点的右孩子设置为黑色
                    leftRotation(tree,parent);//以父节点为支点作左旋操作
                    node=tree->root;//将删除节点设置为根节点
                    break;
                }
            }

        }
        else//删除节点是右孩子
        {
            brother=parent->lChild;
            if(IS_RED(brother))
            {
                //第一种情况：兄弟节点是红色节点
                SET_BLACK(brother);//将兄弟节点设置为黑色
                SET_RED(parent);//把父节点设置为红色
                leftRotation(tree,parent);//以父节点为支点作左旋操作
                brother=parent->lChild;//将兄弟节点设置为左旋操作后的左孩子


            }
            if((!brother->lChild)&&(!brother->rChild))//判断兄弟节点是否为叶子节点
            {
                //第二种情况：兄弟节点是黑色的
                SET_RED(brother);//将兄弟节点设置为红色
                node=parent;//将当前节点设置为父节点
                parent=PARENTNODE(node);

            }
            else
            {
                if((!brother->lChild)||IS_BLACK(brother->lChild))
                {
                    //第三种情况：兄弟节点是黑色的，兄弟节点的左孩子是红色的，右孩子是黑色的
                    SET_BLACK(brother->rChild);//将兄弟节点的左孩子设置为黑色
                    SET_RED(brother);//将兄弟节点设置为红色
                    rightRotation(tree,brother);//以兄弟节点为支点进行右旋操作
                    brother=parent->lChild;//将兄弟节点设置为父节点的右孩子

                }
                else
                {
                    //第四种情况
                    SET_COLOR(brother,COLOR(parent));//将兄弟节点的颜色设置为父节点的颜色
                    SET_BLACK(parent);//将父节点设置为黑色
                    SET_BLACK(brother->lChild);//将兄弟节点的右孩子设置为黑色
                    leftRotation(tree,parent);//以父节点为支点作左旋操作
                    node=tree->root;//将删除节点设置为根节点
                    break;
                }
            }

        }
    }
    if(node)
    {
        SET_BLACK(node);//将节点颜色设置为黑色
    }

}

void deleteNode(RBTree* tree,Node* node)//删除节点
{
    Node* child,*parent;
    int color;
    if((node->lChild!=NULL)&&(node->rChild!=NULL))//判断左右子树是否均非空
    {
        Node* reNode=node;//reNode为替换节点
        reNode=reNode->rChild;//右边找最左边替换
        while(reNode->lChild!=NULL)
        {
            reNode=reNode->lChild;

        }
        if(PARENTNODE(node))//判断删除节点是否为根部
        {
            if(PARENTNODE(node)->lChild==node)//判断删除节点是否为左孩子
            {
                PARENTNODE(node)->lChild=reNode;//用替换节点替换删除节点的位置

            }
            else
            {
                PARENTNODE(node)->rChild=reNode;
            }
        }
        else
        {
            tree->root=reNode;//将根节点设置为替换掉节点
        }
        child=reNode->rChild;
        parent=PARENTNODE(reNode);
        color=COLOR(reNode);
        if(parent==node)
        {
            parent=reNode;
        }
        else
        {
            if(child)
            {
                SET_PARENT(child,parent);
            }
            parent->lChild=child;
            reNode->rChild=node->rChild;
            SET_PARENT(node->rChild,reNode);
        }
        //调整替换节点的父节点
        reNode->parentNode=node->parentNode;
        reNode->color=node->color;
        reNode->lChild=node->lChild;
        //调整删除节点的父节点
        node->lChild->parentNode=reNode;
        if(color==BLACK)//如果删除节点为黑色节点，则需要调整节点
        {
            adjustDelete(tree,child,parent);
        }
        free(node);//释放删除节点
        node=NULL;
        return ;


    }
    //考虑只有单边的情况
    if(node->lChild!=NULL)//如果只有左孩子
    {
        child=node->lChild;
    }
    else//如果只有右孩子
    {
        child=node->rChild;
    }
    parent=node->parentNode;
    color=node->color;
    if(parent)//判断删除节点的父节点是否为空
    {
        if(parent->lChild==node)
        {
            parent->lChild=child;
        }
        else
        {
            parent->rChild=child;
        }
    }
    else
    {

        tree->root=child;
    }
    if(color==BLACK)//如果删除节点颜色为黑色，需要进行调整
    {
        adjustDelete(tree,child,parent);
    }
    free(node);
    node=NULL;
}
void deleteRbtree(RBTree* tree,int key)//根据已知数值删除节点
{
    Node* result=searchNode(tree->root,key);//先查找要删除的节点
    if(result!=NULL)
    {
        deleteNode(tree,result);
    }
}

神舟之光
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++实现红黑树
weixin_42381791的博客
02-01 196
代码中还涉及到红黑树的前中后序遍历的递归算法和非递归算法，并打印出来，不过红黑树的删除在代码中没有体现，删除节点操作相对于增加节点操作更加复杂，等以后再补上。总结：红黑树是一种自平衡二叉查找树，特点：查找速度快且中序遍历是顺序的，应用于任务调度（CFS），内存管理等等。
红-黑树——C++实现
Mind_V的博客
05-27 724
一、红-黑树基本概念红-黑树(Red-Black tree)是一种特殊的二叉查找树，因此具有二叉查找树的特征：任意一个节点所包含的关键字，大于左孩子的关键字，小于右孩子的关键字。树中每一个节点的颜色或者是黑色或者是红色，和AVL树一样具有平衡性。每一个空指针用一个外部结点来替代，红-黑树的性质可以描述为：RB1：根节点和外部节点都是黑色。 RB2：在根至外部节点路径上，没有连续两个节点是红色。
【C++进阶06】红黑树图文详解及C++模拟实现红黑树
2302_76421042的博客
01-12 3493
红黑树详解、模拟实现
红黑树（C++实现）
2202_75331338的博客
07-22 997
◉ 如果u节点存在，则其一定是黑色的，那么cur节点原来的颜色一定是黑色的，现在看到红色的原因是因为cur的子树在调整的过程中将cur节点的颜色由黑色改成红色。◉ 如果u节点不存在，则cur一定是新插入节点，因为如果cur不是新插入节点，则cur和p一定有一个节点的颜色是黑色，就不满足性质4：每条路径黑色节点个数相同。p为g的左孩子，cur为p的右孩子，则对p先进行左单旋，回到情况二 再对g进行右单旋。p为g的右孩子，cur为p的左孩子，则对p先进行右单旋，回到情况二 再对g进行左单旋。
C++简单实现红黑树的插入
06-06
总的来说，C++实现红黑树的插入操作涉及到对红黑树特性的深入理解、节点结构体的设计、颜色调整规则的编码以及旋转操作的实现。这是一项既挑战性又富有成就感的任务，能帮助开发者更好地掌握数据结构和算法。
C++红黑树实现过程
09-15
它的设计目标是在保持二叉查找树基本性质的同时，通过引入颜色属性来保证树的平衡，从而使得插入、删除和查找操作的时间复杂度都能保持在O(log n)。在C++中实现红黑树，需要理解并遵循红黑树的五个性质： 1. 每个...
红黑树-基于C++实现的红黑树数据结构.zip
03-21
在C++中实现红黑树时，通常会定义一个名为`RBTree`的类，包含私有成员变量（如根节点指针）和公共成员函数（如`insert`, `delete`, `search`等）。类的构造函数初始化空树，而析构函数则负责释放所有节点。为了确保...
C++数据结构 红黑树 实现全部功能
12-29
红黑树是一种自平衡二叉查找树，由Rudolf Bayer在1972年提出。它的设计目标是在保持查询...在C++中实现红黑树需要理解其基本概念，设计合适的类结构，并正确实现各种操作，包括插入、删除和查找，以及相关的平衡调整。
红黑树的C++实现
01-24
它的设计目标是在保持二叉查找树基本属性的同时，通过引入颜色（红色或黑色）来保证树的平衡，从而在插入和删除操作后能够快速恢复平衡状态，达到高效的查找性能。以下是关于红黑树的一些关键知识点： 1. **红黑树...
C语言 | Leetcode C语言题解之第337题打家劫舍III
m0_59237910的博客
08-15 387
C语言 | Leetcode C语言题解之第337题打家劫舍III
C++匿名函数lamba简介
yao_tao11的博客
08-18 585
Lambda 表达式是 C++11 引入的一个功能，允许你在代码中定义匿名函数（即没有名字的函数）。这种表达式可以用于简化函数对象的定义，并使得代码更简洁。Lambda 表达式特别适用于局部的、一次性的函数对象，如用于 STL 算法中。捕获方式含义[ ]空捕获列表，Lambda不能使用所在函数中的变量.[names]names是一个逗号分隔的名字列表，这些名字都是Lambda所在函数的局部变量。默认情况下，这些变量会被拷贝，然后按值传递，名字前面如果使用了&，则按引用传递[&]
c++编程（22）——STL（6）set
2301_77239666的博客
08-16 1084
欢迎来到博主的专栏——c++编程博主ID：代码小豪。
C++ IO流
最新发布
weixin_64099089的博客
08-19 507
C++标准IO流，文件IO流，序列化和反序列化
C++ | Leetcode C++题解之第337题打家劫舍III
Ddddddd_158的博客
08-15 387
C++ | Leetcode C++题解之第337题打家劫舍III
C语言典型例题43
2302_77517102的博客
08-18 352
有一个函数：y={x,x
洛谷 CF295D Greg and Caves
xiebohang的博客
08-19 83
解题思路：将整个洞分成两半，一半递增，一半递减。我们分别 DP 求值，最后合并。状态转移方程为：dpi,j​=k=2∑j​(j−k+1)dpi−1,k​+1。枚举极大最长行区间来代替最长行。题目本质：动态规划dp，枚举。
C++_基本语法笔记_模板
qq_45629864的博客
08-14 461
思想是Java里的泛型（不确定用什么类型的数据）这里template这一句，意思是声明T是泛型，后面写用到泛型T的函数。建议都用应用场景：不同数据类型的交换函数。
每天一道C语言精选编程题之自幂数
huc_error的博客
08-15 362
我们可以使⽤⼀个循环遍历 1~100000 并检查每个数是否为⾃幂数。写⼀个代码打印1~100000之间的所有的⾃幂数，中间⽤空格分隔。3. 判断 sum 与 i 是否相等，相等则 i 是⾃幂数。2. 计算 i 的每⼀位的 n 次⽅之和 sum；注：可以使⽤ pow 函数求得某个数的次⽅数。幂数，因为 1^3+5^3+3^3=153。1. 计算 i 的位数 n；⾃幂数是指⼀个数的位数的n次。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值