红黑树 操作

最新推荐文章于 2024-08-19 23:33:53 发布
最新推荐文章于 2024-08-19 23:33:53 发布
阅读量543 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构与算法 C++ STL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/deram_boy/article/details/53302670

插入节点：

#include <iostream>  
#include <queue>  
using namespace std;  
static int _rb_black_node = 0;  
static int _rb_red_node   = 1;  
template<typename T>  
struct RBNode  
{  
    RBNode():left(NULL),right(NULL),parent(NULL),val(T()),color(_rb_red_node){}  
    RBNode(const T &v1):left(NULL),right(NULL),parent(NULL),val(v1),color(_rb_red_node){}  
    RBNode  *left;  
    RBNode  *right;  
    RBNode  *parent;  
    int     color;  
    T       val;  
};  
  
template<typename T>  
class RBTree  
{  
public:  
    RBTree():root(NULL){}  
    ~RBTree()  
    {  
        if(root)  
        {  
            Destroy(root);  
        }  
    }  
    void    print();  
    void    Search(const T &v1, RBNode<T> *&node);  
    bool    InsertUnique(const T &v1);  
    void    DeleteValue(const T &v1);  
    void    Destroy(RBNode<T> *p);  
    void    InsertReBalance(RBNode<T> *node);  
    RBNode<T>*    _rbtree_rotate_left(RBNode<T> *node);  
    RBNode<T>*  _rbtree_rotate_right(RBNode<T> *node);  
private:  
    RBNode<T> *root;  
};  
  
/* 
* 
* 打印红黑树的节点信息 
* 
*/  
template<typename T>  
void RBTree<T>::print()  
{  
    RBNode<T> *p;  
    queue<RBNode<T> *> Q;  
    Q.push(root);  
    while(!Q.empty())  
    {  
        p = Q.front();  
        Q.pop();  
        cout<<"节点: "<<p->val<<" ";  
        if(p->left)  
        {  
            cout<<"left:"<<p->left->val<<"->color:"<<p->left->color<<" ";  
            Q.push(p->left);  
        }  
        if(p->right)  
        {  
            cout<<"right:"<<p->right->val<<"->color:"<<p->right->color<<" ";  
            Q.push(p->right);  
        }  
        cout<<endl<<endl;  
    }  
}  
  
/* 
* 
* 搜索v1在红黑树中出现的位置，如果v1在红黑树中则node节点为 
* 值为v1所在红黑树中的节点。 
* 否则node节点为如果将v1插入到红黑树中的父节点 
* 
*/  
template<typename T>  
void RBTree<T>::Search(const T &v1,RBNode<T> *&node)  
{  
    RBNode<T> *p = root;  
    node = NULL;  
    while(p)  
    {  
        if(p->val == v1)  
        {  
            node = p;  
            break;  
        }  
        else if(p->val < v1)  
        {  
            node = p;  
            p = p->right;  
        }  
        else  
        {  
            node = p;  
            p = p->left;  
        }  
    }  
}  
  
template<typename T>  
bool RBTree<T>::InsertUnique(const T &v1)  
{  
    RBNode<T> *parent = NULL;  
    RBNode<T> *newNode = new RBNode<T>(v1);  
    Search(v1, parent);  
    if(parent == NULL)  
    {//红黑树为空，当前插入的节点为根节点。插入后将根颜色变为黑  
        root = newNode;  
        root->color = _rb_black_node;  
        return true;  
    }  
    if(parent->val == v1)//v1已经存在红黑树中。不再插入  
        return false;  
      
    if(v1 < parent->val)  
    {  
        parent->left = newNode;  
    }  
    else  
    {  
        parent->right = newNode;  
    }  
    newNode->parent = parent;  
    InsertReBalance(newNode);  
    return true;  
}  
  
/* 
* 
* 插入节点后进行调整， 
* 使所有节点满足红黑树的性质 
* 
*/  
template<typename T>  
void RBTree<T>::InsertReBalance(RBNode<T> *node)  
{  
    RBNode<T> *parent = node->parent;  
    RBNode<T> *grandParent = NULL;  
    while(parent && parent->color==_rb_red_node)  
    {  
        grandParent = parent->parent;  
        if(parent == grandParent->left)  
        {//父节点为祖父节点的左儿子  
            RBNode<T> *uncle = grandParent->right;  
            if(uncle && uncle->color == _rb_red_node)  
            {//情形1 父节点与叔节点都为红  
                //解决方法父与叔变黑，祖父变黑。祖父变为新的当前节点重新进入算法  
                parent->color = _rb_black_node;  
                uncle->color  = _rb_black_node;  
                grandParent->color = _rb_red_node;  
                node = grandParent;  
                parent = grandParent->parent;  
            }  
            else  
            {  
                if(node == parent->right)  
                {//情形2，叔为黑，当前节点为其父节点的右子节点  
                    //解决方法：以父节点为根进行左旋  
                    //操作后将转换为情形3  
                    node = _rbtree_rotate_left(parent);  
                    parent = node->parent;  
                    grandParent = parent->parent;  
                }  
                //情形3父为红，当前节点为父节点的左子节点  
                //解决方法：父节点变黑，祖父节点变红，以  
                //祖父节点为根节点进行右旋  
                parent->color = _rb_black_node;  
                grandParent->color = _rb_red_node;  
                _rbtree_rotate_right(grandParent);  
            }  
        }  
        else  
        {//父节点为祖父节点的右子节点，情况与上面相同  
            RBNode<T> *uncle = grandParent->left;  
            if(uncle && uncle->color == _rb_red_node)  
            {  
                uncle->color = _rb_black_node;  
                parent->color = _rb_black_node;  
                grandParent->color = _rb_red_node;  
                node = grandParent;  
                parent = node->parent;  
            }  
            else  
            {  
                if(node == parent->left)  
                {  
                    node = _rbtree_rotate_right(parent);  
                    parent = node->parent;  
                    grandParent = parent->parent;  
                }  
                parent->color = _rb_black_node;  
                grandParent->color = _rb_red_node;  
                _rbtree_rotate_left(grandParent);  
            }  
        }  
    }  
    root->color = _rb_black_node;  
}  
  
/* 
* 
* 左旋 
* 
*/  
template<typename T>  
RBNode<T> *RBTree<T>::_rbtree_rotate_left(RBNode<T> *x)  
{  
    RBNode<T> *y = x->right;  
    if(y == NULL)  
    {  
        return x;  
    }  
    //x的右节点为y的左节点  
    x->right = y->left;  
    if(y->left)//如果y的左节点存在，其父节点为y  
        y->left->parent = x;  
    if(root == x)  
    {//x为root，旋转后y为新的root根节点  
        root = y;  
    }  
    else  
    {  
        if(x == x->parent->left)  
        {//如果x为其父节点的左子节点。  
            //x的父节点的新左子节点为y  
            x->parent->left = y;  
        }  
        else  
        {  
            x->parent->right = y;  
        }  
        //y的父节点为x的父节点  
        y->parent = x->parent;  
    }  
    //y的左子节点为x  
    y->left = x;  
    //x的父节点为y  
    x->parent = y;  
    return x;  
}  
  
/* 
* 
* 右旋 
* 分析其逻辑与左旋代码类似 
* 
*/  
template<typename T>  
RBNode<T>* RBTree<T>::_rbtree_rotate_right(RBNode<T> *x)  
{  
    RBNode<T> *y = x->left;  
    if(y == NULL)  
    {  
        return x;  
    }  
    x->left = y->right;  
    if(y->right)  
        y->right->parent = x;  
    if(root == x)  
    {  
        root = y;  
    }  
    else  
    {  
        if(x == x->parent->left)  
        {  
            x->parent->left = y;  
        }  
        else  
        {  
            x->parent->right = y;  
        }  
        y->parent = x->parent;  
    }  
    y->right = x;  
    x->parent = y;  
    return x;  
}  
  
/* 
* 
* 销毁整棵红黑树 
* 
*/  
template<typename T>  
void RBTree<T>::Destroy(RBNode<T> *p)  
{  
    if(p->left)  
    {  
        Destroy(p->left);  
    }  
    if(p->right)  
    {  
        Destroy(p->right);  
    }  
    delete p;  
}  

#include "rbtree.h"  
#include <iostream>  
using namespace std;  
  
int main()  
{  
    RBTree<int> obj;  
    obj.InsertUnique(30);  
    obj.InsertUnique(40);  
    obj.InsertUnique(50);  
    obj.InsertUnique(20);  
    obj.InsertUnique(35);  
    obj.InsertUnique(10);  
    obj.InsertUnique(11);  
    obj.print();  
    return 0;  
}

删除节点： 

template<typename T>  
void RBTree<T>::DeleteValue(const T &v1)  
{  
    RBNode<T>     *p = NULL;  
    RBNode<T>     *nextNode = NULL;  
    Search(v1,p);  
    if(p==NULL)  
    {  
        cout<<"删除的值不存在"<<endl;  
        return;  
    }  
    if(p->left && p->right)  
    {  
        RBNode<T> *tempNode = p->right;  
        while(tempNode)  
        {//中序序列的后继节点  
            nextNode = tempNode;  
            tempNode = tempNode->left;  
        }  
        p->val = nextNode->val;  
        p = nextNode;  
    }  
    if(p->left)  
    {  
        //直接用后继节点的值替换  
        RBNode<T> *temp = p->left;  
        p->val = temp->val;  
        p->left = NULL;  
        delete temp;  
    }  
    else if(p->right)  
    {  
        //直接用后继节点的值替换  
        RBNode<T> *temp = p->right;  
        p->val = temp->val;  
        p->right = NULL;  
        delete temp;  
    }  
    else  
    {  
        //左右子树都不存在，需要进入删除调整算法  
        DeleteReblance(p);  
        if(p==root)  
        {  
            root = NULL;  
        }  
        else if(p==p->parent->left)  
        {//父节点的指针域需要修改  
            p->parent->left = NULL;  
        }  
        else if(p==p->parent->right)  
        {//父节点的指针域需要修改  
            p->parent->right = NULL;  
        }  
        delete p;  
    }  
}

调整节点： 

template<typename T>  
void RBTree<T>::DeleteReblance(RBNode<T> *node)  
{  
    RBNode<T> *parent = NULL;  
    RBNode<T> *other = NULL;  
    while(node->color==_rb_black_node && node->parent)  
    {  
        parent = node->parent;  
        if(node == parent->left)  
        {  
            other = parent->right;  
            if(other->color==_rb_red_node)  
            {//情形1兄弟节点为红  
                parent->color = _rb_red_node;  
                other->color = _rb_black_node;  
                _rbtree_rotate_left(parent);  
                other = parent->right;  
            }  
            if( (other->left==NULL || other->left->color==_rb_black_node)  
                && (other->right==NULL || other->left->color==_rb_black_node))  
            {//情形2兄弟为黑，且兄弟的两个孩子也为黑  
                other->color=_rb_red_node;  
                node = parent;  
                continue;  
            }  
            if( other->right==NULL || other->right->color==_rb_black_node)  
            {//情形3兄弟节点的右孩子为黑，左为红  
                other->left->color=_rb_black_node;//此时左孩子一定存在且颜色为红，如果不满足就不会进入这个条件  
                other->color = _rb_red_node;  
                _rbtree_rotate_right(other);  
                other = parent->right;  
            }  
            //情形4兄弟节点的右孩子为红  
            other->right->color=_rb_black_node;  
            other->color = parent->color;  
            parent->color = _rb_black_node;  
            _rbtree_rotate_left(parent);  
            break;  
        }  
        else  
        {  
            other = parent->left;  
            if(other->color==_rb_red_node)  
            {//情形1兄弟节点为红  
                parent->color = _rb_red_node;  
                other->color = _rb_black_node;  
                _rbtree_rotate_right(parent);  
                other = parent->left;  
            }  
            if( (other->left==NULL || other->left->color==_rb_black_node)  
                && (other->right==NULL || other->left->color==_rb_black_node))  
            {//情形2兄弟为黑，且兄弟的两个孩子也为黑  
                other->color=_rb_red_node;  
                node = parent;  
                continue;  
            }  
            if( other->left==NULL || other->left->color==_rb_black_node)  
            {//情形3兄弟节点的右孩子为黑，左为红  
                other->right->color=_rb_black_node;//此时左孩子一定存在且颜色为红，如果不满足就不会进入这个条件  
                other->color = _rb_red_node;  
                _rbtree_rotate_left(other);  
                other = parent->left;  
            }  
            //情形4兄弟节点的右孩子为红  
            other->left->color=_rb_black_node;  
            other->color = parent->color;  
            parent->color = _rb_black_node;  
            _rbtree_rotate_right(parent);  
            break;  
        }  
    }  
    node->color = _rb_black_node;  
}


红黑树与2-3树：插入、删除操作的时间复杂度与实现机制比较
一键难忘的博客
11-03 2903
红黑树是一种平衡二叉查找树，其节点具有颜色属性（红色或黑色）。通过一系列规则来确保树的平衡性，红黑树的最大高度是 (2 \log(n)) 级别，从而保证了查找、插入和删除操作的时间复杂度为 (O(\log n))。节点是红色或黑色。根节点是黑色。所有叶节点（NIL）是黑色。红色节点的子节点必须是黑色（即不存在两个相连的红色节点）。从任一节点到其所有叶节点的每条路径都包含相同数量的黑色节点。2-3树是一种B树的特例，其中每个节点可以包含2个或3个子节点。
红黑树及相关操作
SanFancsgo的博客
07-01 653
红黑树 红黑树是一种常用的平衡二叉树，C++标准模板库中的set正是基于红黑树构造。红黑树具有以下几个性质： (1) 每个节点被着色成红色或黑色。 (2) 树的根节点是黑色的。 (3) 如果一个节点是红色的，则它的子节点必须是黑色的（即两个红色的节点不能连续出现）。 (4) 从一个节点到一个NULL指针的没一条路径必须包含相同数目的黑色节点。 一个红黑树的例子 自底向上红黑树 ...
红黑树的各种操作
pleasetojava
11-01 167
红黑树各种操作 // 红黑树各种操作.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include&lt;iostream&gt; using namespace std; enum MyColor{red,black}; typedef int DType;...
红黑树操作
weixin_33752045的博客
10-08 93
红黑树规则 每一个节点不是红色就是黑色的 根总是黑色的 如果节点是红色的,则它的子节点必须是黑色的(节点是黑色，子节点也可以为红色/黑色) 从根到叶节点或空子节点的每条路径，必须包含相同数目的黑色节点 试验1：插入两个红色节点 图1 试验2：旋转 1.向右旋转 图2 开始时如图1 选中50，向右旋转 父节点移到其右子节点位置 ...
红黑树的操作揭秘手册
stven_king的专栏
03-18 1003
前言 二叉树知识点回忆以及整理这篇文章中我们说过“二叉树是一个简单的二分查找，但其性能取决于二叉树的层数”。 - 最好的情况是O(logn),存在于完全二叉树情况下，其访问性能近似于折半查找； - 最差的情况是O(n),比如插入的元素所有节点都没有左子树（右子树），这种情况需要将二叉树的全部节点遍历一次。 红黑树本质上是一种二叉查找树，在节点类中添加类一个用来标识颜色的字段，同时具有一...
详细红黑树操作通俗易懂讲解（插入与删除+图片通俗讲解）
最新发布
weixin_62513677的博客
08-19 1178
详细通俗易懂的红黑树操作讲解，快来看看吧
红黑树精通指南：面试、实战与源码分析
热门推荐
张彦峰的博客
05-12 177万+
本文深入探讨了红黑树的基本原理、实现方法及其在实际应用中的重要性。红黑树是一种自平衡的二叉搜索树，通过一系列颜色标记和旋转操作保证了查找、插入和删除操作的时间复杂度始终保持在 O(log n) 级别。文章首先介绍了红黑树的关键性质和与 AVL 树的区别，分析了红黑树在数据库索引、内存管理等领域的应用。接着，详细讲解了红黑树的插入和删除操作，以及如何通过旋转和颜色调整保持树的平衡。最后，文章通过源码分析展示了红黑树在 Java 和 Linux 内核中的实现，帮助读者更好地理解这一数据结构的实际应用和开发过程。
Java_Algorithm_Project:这个存储库包含我的数据结构和算法项目，使用 Java 中的红黑树操作和列表操作
07-07
Java算法项目是一个旨在深入理解和应用数据结构与算法的实践平台，尤其关注Java中的红黑树操作和列表操作。红黑树是一种自平衡二叉查找树，它的设计目标是尽可能地保持树的高度平衡，从而在插入、删除和查找操作中...
红黑树java操作代码 红黑树是java里面遍历性能最好数据结构
10-17
红黑树的插入操作首先会像普通二叉查找树一样进行，然后通过旋转和重新着色来维护红黑树的性质。插入新节点后，可能破坏原有红黑树的性质，因此通常需要调整树结构。 - 基本步骤： 1. 插入节点默认为红色。 2. ...
红黑树基本操作
dudu3332的博客
03-02 808
很早之前就想写一篇关于红黑树的文章，但是由于担心自己理解的不透彻，就一直不敢下笔。于是在重新看了很多篇文章和资料之后，决定彻彻底底的把红黑树搞清楚。也希望让你在面试中游刃有余。OK，废话不多说，开始今天的文章。 整篇文章的思路是这样的，红黑树其实就是一种数据结构，设计它的目的就是为了高效地进行增删改查，所以我们文章的顺序也会按照这个思路来进行。我们先从二叉查找树逐渐引入到红黑树，然后再详细的讲解...
红黑树(RBTree)的简单操作
qq_44819750的博客
08-11 427
红黑树介绍 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过 对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。 性质 每个结点不是红色就是黑色 根节点是黑色的 如果一个节点是红色的，则它的两个孩子结点是黑色的 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均 包含相同数目的黑色结点 每个叶子结点都是黑色的(此处的叶子结点指的是空结点） 如下图为一颗红黑树 比如17这个结点开始，
红黑树及其操作
shengzhu1的博客
07-14 363
介绍另一种平衡二叉树：红黑树（Red Black Tree），红黑树由Rudolf Bayer于1972年发明，当时被称为平衡二叉B树（symmetric binary B-trees），1978年被Leonidas J. Guibas 和Robert Sedgewick改成一个比较摩登的名字：红黑树。 红黑树和之前所讲的AVL树类似，都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从
红黑树的基本操作
w007d的专栏
07-26 322
红黑树的基本操作
红黑树 基本操作
qq_23835497的博客
05-17 522
红黑树首先是一棵二叉查找树，它每个结点都被标上了颜色（红色或黑色），红黑树满足以下5个性质： 1、 每个结点的颜色只能是红色或黑色。 2、 根结点是黑色的。 3、 每个叶子结点都带有两个空的黑色结点（被称为黑哨兵），如果一个结点n的只有一个左孩子，那么n的右孩子是一个黑哨兵；如果结点n只有一个右孩子，那么n的左孩子是一个黑哨兵。 4、 如果一个结点是红的，则它的两个儿子都是
C++实现的区间树算法及红黑树操作演示
- 删除操作：在删除节点时，除了执行红黑树的删除操作外，还要维护红黑树的平衡性和区间树的特定属性。 - 查找操作：可以用于查找特定的区间或寻找与给定区间有交集的区间。通过二叉搜索树的性质，可以快速缩小...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值