红黑树（红黑树研究记录-代码实现）

最新推荐文章于 2023-08-31 20:32:35 发布
最新推荐文章于 2023-08-31 20:32:35 发布
阅读量676 收藏
点赞数
分类专栏： 算法 数据结构 文章标签： 红黑树

代码可以根据《红黑树研究记录-实例》那篇文章的图来验证

main.cpp

复制代码 
#include <iostream.h>
#include "RBTree.h"

using namespace std;

int main(int argc, char *argv[])
{
    int arr[20] = {12, 1, 9, 2, 0, 11, 7, 19, 4, 15, 18, 5, 14, 13, 10, 16, 6, 3, 8, 17};
    RBTree *tree = new RBTree();
    for(int i = 0; i < 20; i++)
        tree->InsertNode(arr[i]);
    
    
    std::cout<<"PreOrder:"<<std::endl;
    tree->PreOrder();
    std::cout<<"InOrder:"<<std::endl;
    tree->InOrder();
    std::cout<<"PostOrder:"<<std::endl;
    tree->PostOrder();
    
    std::cout<<std::endl<<"Delete Node:"<<std::endl;
    cout<<"Delete 12:"<<endl;
    tree->DeleteNode(12);
    tree->PreOrder();
    cout<<"Delete 1:"<<endl;
    tree->DeleteNode(1);
    tree->PreOrder();
    cout<<"Delete 9:"<<endl;
    tree->DeleteNode(9);
    tree->PreOrder();
    cout<<"Delete 2:"<<endl;
    tree->DeleteNode(2);
    tree->PreOrder();    
    cout<<"Delete 0:"<<endl;
    tree->DeleteNode(0);
    tree->PreOrder();
    cout<<"Delete 11:"<<endl;
    tree->DeleteNode(11);
    tree->PreOrder();
    cout<<"Delete 7:"<<endl;
    tree->DeleteNode(7);
    tree->PreOrder();
    cout<<"Delete 19:"<<endl;
    tree->DeleteNode(19);
    tree->PreOrder();
    cout<<"Delete 4:"<<endl;
    tree->DeleteNode(4);
    tree->PreOrder();
    cout<<"Delete 15:"<<endl;
    tree->DeleteNode(15);
    tree->PreOrder();    
    cout<<"Delete 18:"<<endl;
    tree->DeleteNode(18);
    tree->PreOrder();
    cout<<"Delete 5:"<<endl;
    tree->DeleteNode(5);
    tree->PreOrder();
    cout<<"Delete 14:"<<endl;
    tree->DeleteNode(14);
    tree->PreOrder();
    cout<<"Delete 13:"<<endl;
    tree->DeleteNode(13);
    tree->PreOrder();
    cout<<"Delete 10:"<<endl;
    tree->DeleteNode(10);
    tree->PreOrder();    
    cout<<"Delete 6:"<<endl;
    tree->DeleteNode(6);
    tree->PreOrder();
    cout<<"Delete 16:"<<endl;
    tree->DeleteNode(16);
    tree->PreOrder();
    cout<<"Delete 3:"<<endl;
    tree->DeleteNode(3);
    tree->PreOrder();
    cout<<"Delete 8:"<<endl;
    tree->DeleteNode(8);
    tree->PreOrder();
    cout<<"Delete 17:"<<endl;
    tree->DeleteNode(17);
    tree->PreOrder();
    return  0;
}
复制代码

RBTree.h

复制代码 
#ifndef _RBTREE_HEADER_
#define _RBTREE_HEADER_

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

enum NodeColor{
    RED,
    BLACK
};

struct RBNode
{
    int value;
    NodeColor color;
    RBNode *pParent;
    RBNode *pLeft;
    RBNode *pRight;
};

class RBTree
{
public:
    RBTree();
    ~RBTree();
    
    int InsertNode(int);
    int DeleteNode(int);
    RBNode *FindNode(int value);
    
    void PreOrder();
    void InOrder();
    void PostOrder();
private:
    void DeleteAll();
    void TurnLeft(RBNode *pNode);
    void TurnRight(RBNode *pNode);
    int DeleteNode(RBNode *);
    RBNode *GetSuccessor(RBNode *);
    int InsertNode(RBNode *);
    void DeleteFixup(RBNode *);
    void InsertFixup(RBNode *);
private:
    RBNode *m_root;
};

#endif
复制代码

RBTree.cpp

复制代码 
#include "RBTree.h"
#include <deque>
#include <queue>

using namespace std;

RBTree::RBTree()
{
    m_root = NULL;
}

RBTree::~RBTree()
{
    DeleteAll();
}

void RBTree::TurnLeft(RBNode *pNode)
{
    if(!pNode || !pNode->pParent)
        return;
    RBNode *pp = pNode->pParent->pParent;
    if(pp)
        if(pp->pLeft == pNode->pParent)
            pp->pLeft = pNode;
        else
            pp->pRight = pNode;
    pNode->pParent->pParent = pNode;
    pNode->pParent->pRight = pNode->pLeft;
    if(pNode->pLeft)
        pNode->pLeft->pParent = pNode->pParent;
    pNode->pLeft = pNode->pParent;    
    pNode->pParent = pp;    
}

void RBTree::TurnRight(RBNode *pNode)
{
    if(!pNode || !pNode->pParent)
        return;
    RBNode *pp = pNode->pParent->pParent;
    if(pp)
        if(pp->pLeft == pNode->pParent)
            pp->pLeft = pNode;
        else
            pp->pRight = pNode;
    pNode->pParent->pParent = pNode;
    pNode->pParent->pLeft = pNode->pRight;
    if(pNode->pRight)
        pNode->pRight->pParent = pNode->pParent;
    pNode->pRight = pNode->pParent;    
    pNode->pParent = pp;
}

void RBTree::DeleteAll()
{
    if(!m_root)
        std::cout<<"The tree is null"<<std::endl;
    queue<RBNode*> qu;
    qu.push(m_root);
    while(qu.size() > 0)
    {
        RBNode *pCur = qu.front();
        qu.pop();
        std::cout<<"Delete:"<<pCur->value<<"("<<pCur->color<<"), "<<std::endl;
        if(pCur->pLeft)
            qu.push(pCur->pLeft);
        if(pCur->pRight)
            qu.push(pCur->pRight);
        delete pCur;
        pCur = NULL;
    }
}

int RBTree::InsertNode(int value)
{
    if(FindNode(value))
        return -1;
    RBNode *pNew = new RBNode();
    pNew->value = value;
    pNew->pParent = NULL;
    pNew->color = RED;
    pNew->pLeft = NULL;
    pNew->pRight = NULL;
    
    return InsertNode(pNew);
}

int RBTree::InsertNode(RBNode* pNode)
{
    if(!pNode)
        return -1;
    if(!m_root)
    {
        m_root = pNode;
        m_root->color = BLACK;
        return 0;
    }
    RBNode *tmp = m_root;
    RBNode *tmpParent = NULL;
    while(tmp)
    {
        tmpParent = tmp;
        if(tmp->value > pNode->value)
            tmp = tmp->pLeft;
        else
            tmp = tmp->pRight;
    }
    if(tmpParent->value > pNode->value)
        tmpParent->pLeft = pNode;
    else
        tmpParent->pRight = pNode;
    pNode->pParent = tmpParent;
    
    InsertFixup(pNode);
}

void RBTree::InsertFixup(RBNode *pNode)
{
    if(!pNode)
        return;
    RBNode *pUncle = NULL;
    while(pNode->pParent && pNode->pParent->color == RED)
    {
        if(pNode->pParent == pNode->pParent->pParent->pLeft)
        {
            pUncle = pNode->pParent->pParent->pRight;
            if(pUncle && pUncle->color == RED)            //case 1
            {
                pNode->pParent->color = BLACK;
                pUncle->color = BLACK;
                pNode->pParent->pParent->color = RED;
                pNode = pNode->pParent->pParent;
            }
            else
            {
                if(pNode == pNode->pParent->pRight)        //case 2
                {
                    TurnLeft(pNode);
                    pNode = pNode->pLeft;
                }
                pNode->pParent->color = BLACK;            //case 3
                pNode->pParent->pParent->color = RED;
                TurnRight(pNode->pParent);
                if(!pNode->pParent->pParent)
                    m_root = pNode->pParent;
            }
        }
        else
        {
            pUncle = pNode->pParent->pParent->pLeft;
            if(pUncle && pUncle->color == RED)                    //case 1
            {
                pNode->pParent->color = BLACK;
                pUncle->color = BLACK;
                pNode->pParent->pParent->color = RED;
                pNode = pNode->pParent->pParent;
            }
            else
            {
                if(pNode == pNode->pParent->pLeft)        //case 2
                {
                    TurnRight(pNode);
                    pNode = pNode->pRight;
                }
                pNode->pParent->color = BLACK;            //case 3
                pNode->pParent->pParent->color = RED;
                TurnLeft(pNode->pParent);
                if(!pNode->pParent->pParent)
                    m_root = pNode->pParent;
            }
        }
    }
    m_root->color = BLACK;
}

int RBTree::DeleteNode(int value)
{
    RBNode *pNode = NULL;
    if(!(pNode = FindNode(value)))
        return -1;
    return DeleteNode(pNode);
}

RBNode *RBTree::GetSuccessor(RBNode *pNode)
{
    RBNode *pThis = pNode->pRight;
    while(pThis->pLeft)
        pThis = pThis->pLeft;
    return pThis;
}

int RBTree::DeleteNode(RBNode *pNode)
{
    if(!pNode)
        return -1;
    RBNode *pDel = NULL;
    RBNode *pThis = NULL;
    //search the Node
    if(!pNode->pLeft && !pNode->pRight)
    {
        pThis = pNode;
        pDel = pNode;
    }
    else if(!pNode->pLeft || !pNode->pRight)
        pDel = pNode;
    else
        pDel = GetSuccessor(pNode);
    
    //delete the Node
    if(pDel->pLeft)
        pThis = pDel->pLeft;
    else if(pDel->pRight)
        pThis = pDel->pRight;
    else
        pThis = pDel;
    
    if(pThis != pDel)
    {
        pThis->pParent = pDel->pParent;
        
        if(!pDel->pParent)
            m_root = pThis;
        else if(pDel == pDel->pParent->pLeft)
            pDel->pParent->pLeft = pThis;
        else
            pDel->pParent->pRight = pThis;
    }
    if(pDel != pNode)
        pNode->value = pDel->value;
    if(pDel->color == BLACK)
        DeleteFixup(pThis);
        
    if(pThis == pDel)
        if(pDel == pDel->pParent->pLeft)
            pDel->pParent->pLeft = NULL;
        else
            pDel->pParent->pRight = NULL;
    if(pDel == m_root)
        m_root = NULL;
    delete pDel;
    pDel = NULL;
}

void RBTree::DeleteFixup(RBNode *pNode)
{
    RBNode *pBrother = NULL;
    while(pNode != m_root && pNode->color == BLACK)
    {
        if(pNode == pNode->pParent->pLeft)
        {
            pBrother = pNode->pParent->pRight;
            if(pBrother->color == RED)        //case 1
            {
                pBrother->color = BLACK;
                pNode->pParent->color = RED;
                TurnLeft(pBrother);
                pBrother = pNode->pParent->pRight;    
            }
            if((!pBrother->pLeft || pBrother->pLeft->color == BLACK) 
                && (!pBrother->pRight || pBrother->pRight->color == BLACK))        //case 2
            {
                pBrother->color = RED;
                pNode = pNode->pParent;
            }
            else
            {
                if(!pBrother->pRight || pBrother->pRight->color == BLACK)        //case 3
                {
                    pBrother->pLeft->color = BLACK;
                    pBrother->color = RED;
                    TurnRight(pBrother->pLeft);
                    pBrother = pNode->pParent->pRight;
                }
                pBrother->color = pNode->pParent->color;    //case 4
                pNode->pParent->color = BLACK;
                pBrother->pRight->color = BLACK;
                TurnLeft(pBrother);
                pNode = m_root;
            }
        }
        else
        {
            pBrother = pNode->pParent->pLeft;
            if(pBrother->color == RED)        //case 1
            {
                pBrother->color = BLACK;
                pNode->pParent->color = RED;
                TurnRight(pBrother);
                pBrother = pNode->pParent->pLeft;
            }
            if((!pBrother->pLeft || pBrother->pLeft->color == BLACK) 
                && (!pBrother->pRight || pBrother->pRight->color == BLACK))    //case 2
            {
                pBrother->color = RED;
                pNode = pNode->pParent;
            }
            else
            {
                if(!pBrother->pLeft || pBrother->pLeft->color == BLACK)        //case 3
                {
                    pBrother->pRight->color = BLACK;
                    pBrother->color = RED;
                    TurnLeft(pBrother->pRight);
                    pBrother = pNode->pParent->pLeft;
                }
                pBrother->color = pNode->pParent->color;
                pNode->pParent->color = BLACK;
                pBrother->pLeft->color = BLACK;
                TurnRight(pBrother);
                pNode = m_root;
            }
        }
    }
    pNode->color = BLACK;
}

RBNode *RBTree::FindNode(int value)
{
    if(!m_root)
        return NULL;
    RBNode *tmp = m_root;
    while(tmp)
    {
        if(value > tmp->value)
            tmp = tmp->pRight;
        else if(value < tmp->value)
            tmp = tmp->pLeft;
        else
            break;
    }
    return tmp;
}

void RBTree::PreOrder()
{
    if(!m_root)
    {
        std::cout<<"The tree is null"<<std::endl;
        return;
    }
    queue<RBNode*> qu;
    qu.push(m_root);
    while(qu.size() > 0)
    {
        RBNode *pCur = qu.front();
        qu.pop();
        std::cout<<pCur->value<<"("<<pCur->color<<"), ";
        if(pCur->pLeft)
            qu.push(pCur->pLeft);
        if(pCur->pRight)
            qu.push(pCur->pRight);
    }
    std::cout<<std::endl;
}

void RBTree::InOrder()
{
    if(!m_root)
    {
        std::cout<<"The tree is null"<<std::endl;
        return;
    }
    
    deque<RBNode*> de;
    RBNode *pCur = m_root;
    bool bPush = false;
    
    while(pCur)
    {
        if(pCur->pLeft && !bPush)
        {
            de.push_back(pCur);
            pCur = pCur->pLeft;
            continue;
        }
        std::cout<<pCur->value<<"("<<pCur->color<<"), ";
        
        if(pCur->pRight)
        {
            pCur = pCur->pRight;
            bPush = false;
        }
        else
        {
            if(de.size() == 0)
                break;
            pCur = de.back();
            de.pop_back();
            bPush = true;
        }
    }
    std::cout<<std::endl;
}

void RBTree::PostOrder()
{
    if(!m_root)
    {
        std::cout<<"The tree is null"<<std::endl;
        return;
    }
    deque<RBNode*> de;
    int flag = 0;
    RBNode *pCur = m_root;
    while(pCur)
    {
        if(pCur->pLeft && flag < 1)
        {
            de.push_back(pCur);
            pCur = pCur->pLeft;
            continue;
        }
        if(pCur->pRight && flag < 2)
        {
            de.push_back(pCur);
            pCur = pCur->pRight;
            flag = 0;
            continue;
        }
        std::cout<<pCur->value<<"("<<pCur->color<<"), ";
        
        if(de.size() == 0)
            break;
        RBNode *pParent = de.back();
        de.pop_back();
        
        if(pCur == pParent->pLeft)
        {
            flag = 1;
            pCur = pParent;
        }
        else if(pCur == pParent->pRight)
        {
            flag = 2;
            pCur = pParent;
        }
    }
    std::cout<<std::endl;
}


转载地址：http://www.cnblogs.com/geekma/archive/2012/06/28/2567718.html
yrlovelr
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
treemap:基于某处发现的红黑树算法的 C 语言中简单、简约的树图
06-13
基于某处发现的红黑树算法的 C 语言中的简单、简约的树映射。 应该感谢使用该算法编写原始 PDF 的人，但几年过去了，我不记得他们是谁。 这应该被优化，MapIterator 效率很低； 但我只是需要它来工作，我从来没有...
【考研】数据结构：红黑树（2022新增考点）
qq_34438969的博客
10-28 7205
一、前言 根据王道讲解和网上资料，总结的红黑树相关知识点和考点。 可能考：红黑树的性质、插入、删除（选择题，代码可能不考，略复杂） 二、红黑树 （一）定义 1. 红黑树是实质上是一棵自平衡的二叉查找树，有时形态不一定是平衡二叉树。 （左子树结点值 < 根结点值 < 右子树结点值） 2. 引入带颜色的节点也是为了方便在进行插入或删除操作时，如果破坏了二叉查找树的平衡性能通过一系列变换保持平衡。 3. 红黑树的查找、插入、删除的时间复杂度均为。 （注意：AVL的查找、插入、删除
王道数据结构笔记03-红黑树/RBT
最新发布
testleaf.cn
08-31 2452
为什么要发明红黑树？ 红黑树大概会怎么考？ 红黑树的定义 【实例】一颗红黑树： 【练习】是否符合红黑树要求？ 【一种可能的出题思路】 补充概念：结点的“黑高” 红黑树的性质 红黑树的查找 红黑树的插入 红黑树的删除 红黑树插入演示 与“黑高”相关的推论 左根右，根叶黑，不红红，黑路同 黑叔：旋转+染色 红叔：染色+变新 LL型：右单旋，父换爷+染色 RR型：左单旋，父换爷+染色 LR型：左、右双旋，儿换爷+染色 RL型：右、左双旋，儿换爷+染色............
红黑树研究记录-代码实现
weixin_33720452的博客
06-28 77
代码可以根据《红黑树研究记录-实例》那篇文章的图来验证 main.cpp #include <iostream.h> #include "RBTree.h" using namespace std; int main(int argc, char *argv[]) { int arr[20] = {12, 1, 9, 2, 0, 11, 7, 19, ...
【数据结构】红黑树完整代码
一个写湿的程序猿
03-05 1096
红黑树完整代码二叉树 - BinaryTree.java二叉搜索树 - BSTree.java平衡二叉搜索树 - BBSTree.javaAVL树 - AVLTree.java红黑树 - RBTree.java 二叉树 - BinaryTree.java 二叉树类是抽取了其他二叉树（BST，BBST，RBTree）的公共的属性与方法，本身并没有具体用途，所以也不存在添加元素、删除元素等方法。 @SuppressWarnings("unchecked") public class BinaryTree<
红黑树 一张导图解决红黑树全部插入和删除问题 包含详细操作原理 情况对比
热门推荐
孤柒的博客
04-01 1万+
本文的思维导图解决了红黑树全部插入和删除问题,包含详细操作原理,各种情况的对比和原因 思维导图源文件已经发布在我的资源当中，有需要的可以去 我的主页 了解更多计算机学科的精品思维导图整理 本文可以转载，但请注明来处，觉得整理的不错的小伙伴可以点赞关注支持一下哦！ ...
leetcode中国-leetcode:记录个人刷leetcode的题解
06-29
红黑树 LRU 排序 链表 答题细节 1、反复审题 2、与面试官交流确认细节 3、编写代码记得书写规范，例如 () {}前后添加空格。 最后，写上测试用例 四件套 1、跟面试官把题目都确认无误 2、尽可能想所有的解题方法，并...
javalruleetcode-LeetCode:文档用于存储平日所练习LeetCode题目的代码和思考方法，记录日常学习
06-29
查找（搜索）算法：二分查找、插值查找、红黑树等。 Hash表的使用：典型的以空间换时间，速度很快。值得深入思考 动态规划：0-1背包问题，迪杰斯特拉算法，贪心算法等。 图遍历算法：(1) , (2) 二叉树的前中后序遍历...
NtyTCP-v1.0.0-comments:用户态的TCPIP协议栈并包含了epoll技术实现原始代码，注释将不断维护，以保证质量-源码包
03-24
NtyTCP v1.0.0注释 作者 徐昌隆 电子邮件 零，前言 1，NtyTCP介绍 NtyTCP是王博靖前辈开发的单线程用户态TCP / IP协议栈，包含epoll实现代码，... epoll_create（）申请_nty_socket的详细过程，红黑树和双向链表初
hihocoder和leetcode-algo_practice:记录算法过程，每天更新！
07-06
二叉树，红黑树，B树，B+树，Trie 树，胜者树，败者树 图：DFS，BFS，Dijkstra 拓扑排序；并查集；最短路径；最小生成树 散列表：实现原理，扩容，效率 字符串：KMP，Manacher， 数组、链表、二叉树、队列、栈的各种...
数据结构之红黑树
快乐江湖的博客
07-05 368
文章目录一：红黑树基本概念（1）什么是红黑树（2）红黑树的性质（3）为什么要给空结点（NIL）上色？（4）为什么最长路径一定不超过最短路径的2倍？（5）红黑树效率 一：红黑树基本概念 （1）什么是红黑树 红黑树在二叉搜索树基础上，增加了一个域来标识结点的颜色，可以是红色和黑色。 通过对任何一条从根节点到叶子结点的简单路径上的各个结点的颜色的约束，红黑树可以确保没有一条路径能比其他路径长出2倍，也就是最长路径比最短路径的长度最长不超过2倍 AVL树是一颗严格的平衡二叉树，而红黑树只是近似于平衡，并不是严格平
考完研，才知道考研路上的这三个大坑！
weixin_34166847的博客
03-13 613
微信公众号【程序员江湖】作者黄小斜，斜杠青年，某985硕士，阿里研发工程师，于2018 年秋招拿到 BAT 头条、网易、滴滴等 8 个大厂 offer个人擅长领域 ：自学编程、技术校园招聘、软件工程考研（关注公众号后回复”资料“即可领取 3T 免费技术学习资源）​作为一个过来人，表示考研的坑真的很多，我当年的数学考得很难，除了数学之外其他都考的还行，最后总分380+。由于年代比较久远，确实有一些事...
（考研）数据结构及算法
heartblood的博客
05-16 1万+
本文会把复习中所遇到的所有算法记录并分析，以供以后查阅
示例，红黑树插入和删除过程
jfkidear的专栏
02-21 1394
示例，红黑树插入和删除过程     |字号 订阅 依次插入如下序列，最后再依次删除如下序列，图片为自动生成。 12 1 9 2 0 11 7 19 4 15 18 5 14 13 10 16 6 3 8 17
关于红黑树的研究总结
井底的青蛙
08-30 203
1：首先红黑树是什么的，它的基本性质： 从大到小的范围来描述红黑树，它依次是一棵树>一个二叉树>一个二叉查找树>一个平衡二叉树>一个红黑树。 红黑树的性质： 性质1. 节点是红色或黑色。 性质2. 根节点是黑色。 性质3 每个叶节点是黑色的。（如果发现叶子节点是红色的，也不要疑惑，实际上红色并不是叶子节点，当红色节点作为最后一个元素的时候，会默认在后边添加一个空的nil或者null黑色叶子节点。只不过现在很多地方都会省略显示nil或者nu...
红黑树的删除及其实例
jlu_zc的专栏
01-06 1407
这两天学习了一下红黑树，关于红黑树的资料如下，讲得很详细。 1.    教你透彻了解红黑树： http://blog.csdn.net/v_JULY_v/archive/2010/12/29/6105630.aspx  2.     红黑树算法的层层剖析与逐步实现 http://blog.csdn.net/v_JULY_v/archive/2010/12/31/6109153.as
红黑树考究
lou_liang的博客
06-14 337
红黑树是一种平衡二叉查找树，除了具备二叉查找树特性外还具备附加特性二叉查找树特性： 1.左子树上所有结点的值均小于或等于它的根结点的值。 2.右子树上所有结点的值均大于或等于它的根结点的值。 3.左、右子树也分别为二叉排序树。红黑树特性 ： 1、节点是黑色或者红色 2、根节点是黑色 3、每个叶子节点都是黑色的空节点（NIL节点） 4、每个红色节点的两个子节点都是黑色 5、从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点 下面这棵树就是一颗典型的二叉树 什么情况下会破坏红黑树的规则，什么.
红黑树研究记录-理论
weixin_34255793的博客
06-27 85
一、 什么是红黑树？ 红黑树，是二叉查找树的一种，相对于AVL树，通过放弃绝对的平衡而提高了插入的速度，它可以不要求节点的左右子树高度差小于2，但保证一颗子树的高度绝对小于另一颗子树高度的2倍。 一棵拥有n个内部结点的红黑树的树高h<=2log(n+1)。 红黑树性质： 1. 每个结点或红或黑。 2. 根结点为黑色。 3. 每个叶结点(实际上就是NULL指针)都是黑色的...
通俗易懂的红黑树简析
LiQiyao的博客
01-31 794
一、基本概念  红黑树本质上是一棵近似平衡的二叉树，它的节点只有两种颜色即红与黑，它满足二叉搜索树的基本性质，即树上的任何节点的值大于其左子节点（若左子节点存在），任何节点的值大于其右子节点的值（若右子节点存在）。  近似平衡：深度最大的节点的深度  红黑树与平衡二叉树比较：因为红黑树只追求近似平衡，所以在插入与删除节点时，翻转次数远远少于平衡树，因此在需要较多插入删除操作的
C++代码实现红黑树
05-24
红黑树是一种自平衡二叉查找树，它能够保证任何一个节点的左右子树的高度差不会超过两倍。下面是C++代码实现红黑树的基本操作： ```c++ #include <iostream> using namespace std; enum Color {RED, BLACK}; struct Node { int val; Color color; Node *left, *right, *parent; Node(int v) : val(v), color(RED), left(nullptr), right(nullptr), parent(nullptr) {} }; class RBTree { private: Node *root; void rotateLeft(Node *x) { Node *y = x->right; x->right = y->left; if (y->left != nullptr) { y->left->parent = x; } y->parent = x->parent; if (x->parent == nullptr) { root = y; } else if (x == x->parent->left) { x->parent->left = y; } else { x->parent->right = y; } y->left = x; x->parent = y; } void rotateRight(Node *x) { Node *y = x->left; x->left = y->right; if (y->right != nullptr) { y->right->parent = x; } y->parent = x->parent; if (x->parent == nullptr) { root = y; } else if (x == x->parent->right) { x->parent->right = y; } else { x->parent->left = y; } y->right = x; x->parent = y; } void insertFixup(Node *z) { while (z->parent != nullptr && z->parent->color == RED) { if (z->parent == z->parent->parent->left) { Node *y = z->parent->parent->right; if (y != nullptr && y->color == RED) { z->parent->color = BLACK; y->color = BLACK; z->parent->parent->color = RED; z = z->parent->parent; } else { if (z == z->parent->right) { z = z->parent; rotateLeft(z); } z->parent->color = BLACK; z->parent->parent->color = RED; rotateRight(z->parent->parent); } } else { Node *y = z->parent->parent->left; if (y != nullptr && y->color == RED) { z->parent->color = BLACK; y->color = BLACK; z->parent->parent->color = RED; z = z->parent->parent; } else { if (z == z->parent->left) { z = z->parent; rotateRight(z); } z->parent->color = BLACK; z->parent->parent->color = RED; rotateLeft(z->parent->parent); } } } root->color = BLACK; } void transplant(Node *u, Node *v) { if (u->parent == nullptr) { root = v; } else if (u == u->parent->left) { u->parent->left = v; } else { u->parent->right = v; } v->parent = u->parent; } void deleteFixup(Node *x) { while (x != root && x->color == BLACK) { if (x == x->parent->left) { Node *w = x->parent->right; if (w->color == RED) { w->color = BLACK; x->parent->color = RED; rotateLeft(x->parent); w = x->parent->right; } if (w->left->color == BLACK && w->right->color == BLACK) { w->color = RED; x = x->parent; } else { if (w->right->color == BLACK) { w->left->color = BLACK; w->color = RED; rotateRight(w); w = x->parent->right; } w->color = x->parent->color; x->parent->color = BLACK; w->right->color = BLACK; rotateLeft(x->parent); x = root; } } else { Node *w = x->parent->left; if (w->color == RED) { w->color = BLACK; x->parent->color = RED; rotateRight(x->parent); w = x->parent->left; } if (w->right->color == BLACK && w->left->color == BLACK) { w->color = RED; x = x->parent; } else { if (w->left->color == BLACK) { w->right->color = BLACK; w->color = RED; rotateLeft(w); w = x->parent->left; } w->color = x->parent->color; x->parent->color = BLACK; w->left->color = BLACK; rotateRight(x->parent); x = root; } } } x->color = BLACK; } public: RBTree() : root(nullptr) {} Node* search(int v) { Node *cur = root; while (cur != nullptr && cur->val != v) { if (cur->val > v) { cur = cur->left; } else { cur = cur->right; } } return cur; } void insert(int v) { Node *z = new Node(v); Node *y = nullptr; Node *x = root; while (x != nullptr) { y = x; if (z->val < x->val) { x = x->left; } else { x = x->right; } } z->parent = y; if (y == nullptr) { root = z; } else if (z->val < y->val) { y->left = z; } else { y->right = z; } insertFixup(z); } void remove(int v) { Node *z = search(v); if (z == nullptr) { return; } Node *y = z; Color yOriginalColor = y->color; Node *x; if (z->left == nullptr) { x = z->right; transplant(z, z->right); } else if (z->right == nullptr) { x = z->left; transplant(z, z->left); } else { y = z->right; while (y->left != nullptr) { y = y->left; } yOriginalColor = y->color; x = y->right; if (y->parent == z) { x->parent = y; } else { transplant(y, y->right); y->right = z->right; y->right->parent = y; } transplant(z, y); y->left = z->left; y->left->parent = y; y->color = z->color; } if (yOriginalColor == BLACK) { deleteFixup(x); } delete z; } void print() { printHelper(root, 0); } void printHelper(Node *cur, int depth) { if (cur == nullptr) { return; } printHelper(cur->right, depth + 1); for (int i = 0; i < depth; ++i) { cout << "\t"; } cout << cur->val << "(" << cur->color << ")" << endl; printHelper(cur->left, depth + 1); } }; int main() { RBTree tree; tree.insert(3); tree.insert(1); tree.insert(4); tree.insert(6); tree.insert(9); tree.insert(2); tree.insert(5); tree.insert(7); tree.insert(8); tree.print(); cout << endl; tree.remove(3); tree.remove(5); tree.print(); return 0; } ``` 在这段代码中，我们定义了一个`Node`结构体，表示红黑树的节点。它包含了节点值`val`、节点颜色`color`、左右子节点指针`left`和`right`、父节点指针`parent`。 我们还定义了一个`RBTree`类，表示红黑树。它包含了`root`节点指针，表示红黑树的根节点。 在`RBTree`类中，我们实现了如下操作： - `search`：在红黑树中查找某个值，返回相应节点指针。 - `insert`：向红黑树中插入一个值，保证插入后仍然是红黑树。 - `remove`：从红黑树中删除一个值，保证删除后仍然是红黑树。 - `print`：打印红黑树的结构。 其中，`insert`和`remove`操作中，我们还实现了红黑树的自平衡调整函数`insertFixup`和`deleteFixup`，保证插入和删除后仍然是红黑树。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值