红黑树

最新推荐文章于 2022-02-15 21:21:16 发布
最新推荐文章于 2022-02-15 21:21:16 发布
阅读量524 收藏 5
点赞数 1
分类专栏： 数据结构 c++ 文章标签： 二叉树 搜索 红黑树-判断红黑树 代码实现
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/simplehap/article/details/69692306
版权

红黑树的概念和性质

概念：红黑树是一棵二叉搜索树，它在以前的搜索二叉树的基础上每个节点上增加了一个存储位来表示节点的颜色，可以是红的或黑的。通过对任何一条从根到叶子简单路径上的颜色来约束，红黑树保证最长路径不超过最短路径的两倍，因而近似于平衡。
红黑树的性质：
1. 每个节点，不是红色就是黑色的
2. 根节点是黑色的
3. 如果一个节点是红色的，则它的两个子节点是黑色的 。即不存在两个相连的红色节点
4. 每条路径上有相同数量的黑色节点

为什么红黑树能保证最长路径不超过最短路径的两倍？

红黑树满足上面的四个性质。当一棵树全部是黑节点时，满足上面的所有性质：
比如：
这里写图片描述
在满足上面的性质情况下，可以增加红节点。
比如：
这里写图片描述
如图，最短路径就是为全黑节点，最长路径为加了红节点的那条路径。在最短路径不能再减少黑色节点了，否则就不满足第四条性质，每条路径有相同的黑色节点。而最长路径也不能再增加节点，如果加红节点，就会出现相连的红色节点；如果增加黑色节点，每条路径的黑色节点将不会相同。
可知，最长路径的节点数不会超过最短路径的节点数的两倍。

有了AVL树(高度平衡)，为什么还要有红黑树

AVL树高度平衡树，增删查改的时间复杂度O((Log2)N)（log以2为底N的对数）
红黑树是最长路径不超过最短路径的2倍，在最坏的情况下，时间复杂度为O(2Log2(N))（2倍的log以2为底N的对数）。
对于计算机来说，O((Log2)N)和O(2Log2(N))效率差不多。相对而言，降低了旋转的要求，所以性能会优于AVL树，所以有了红黑树的出现，而且实际运用中红黑树更多。
比如：
1. C++ STL库 – map
2. Java 库
3. linux内核
4. 其他一些库

红黑树的插入

为了满足那4条性质，在插入时，如果为空树，就插入黑节点；只要有节点，再插入时，插入的都是红节点，因为上面三条性质中，最难保持的就是每条路径的黑色节点数相同，所以在插入时尽量满足第四条性质，而去打破第三条。然后再进行调整节点的颜色。
插入分为三种情况：
第一种情况：cur为红色，parent为黑色，grandfather为黑色uncle存在且为黑色（parent和uncle可以互换位置）
cur是新插入的节点，则a,b,c,d,e都将不存在，cur还有可能就是子树的grandfather变色而来的。
如：
这里写图片描述
这时将节点进行变色，使该树继续满足红黑树的性质，将parent和uncle的颜色变为黑色，grandfather变为红色。
这里写图片描述
第二种情况：cur为红色且为parent的左孩子，parent为红色grandfather为黑色，uncle不存在或uncle为黑色
uncle不存在时，cur为新插节点，a,b,c,d,e都不存在
uncle存在时，cur是第一种情况调过来的，a,b,c,为红节点，d，e为黑节点。
这里写图片描述
然后以parent进行右旋，将parent变为黑色，grandfather变为红色
这里写图片描述
当parent为grandfather的右孩子，cur为parent的右孩子时，以grandfather进行左旋，一样的变色。
第三种情况：cur为红色且为parent的左孩子，parent为红色，grandfather为黑色，uncle不存在或uncle为黑色
uncle不存在时，cur为新插节点，a,b,c,d,e都不存在
uncle存在时，cur是第一种情况调过来的，a,b,c,为红节点，d，e为黑节点。
这里写图片描述
先以parent进行左旋，旋转后交换parent和cur
这里写图片描述
再以grandfather进行右旋，将parent变为黑色，grandfather变为红色
这里写图片描述
当parent为grandfather的右孩子，cur为parent的左孩子时，以parent进行右旋后交换，再以grandfather进行左旋，一样的变色。
代码：

bool Insert(const K& key, const V& value)
    {
        if (_root == NULL)
        {
            _root = new Node(key, value);
            _root->_color = BLACK;
            return true;
        }

        Node* cur = _root;
        Node* parent = NULL;
        //找插入的位置
        while (cur)
        {
            if (key < cur->_key)
            {
                parent = cur;
                cur = cur->_left;
            }
            else if (key > cur->_key)
            {
                parent = cur;
                cur = cur->_right;
            }
            else
                return false;
        }

        cur = new Node(key, value);

        if (key < parent->_key)
        {
            parent->_left = cur;
            cur->_parent = parent;
        }
        else
        {
            parent->_right = cur;
            cur->_parent = parent;
        }

        while (parent && parent->_color == RED)
        {
            Node* grandfather = parent->_parent;
            if (parent == grandfather->_left)//parent为左孩子
            {
                Node* uncle = grandfather->_right;
                if (uncle && uncle->_color == RED)
                {
                    parent->_color = uncle->_color = BLACK;
                    grandfather->_color = RED;
                    cur = grandfather;
                    parent = cur->_parent;
                }


                else//uncle不存在或uncle存在且为黑色
                {
                    //uncle不存在，cur为新插节点。uncle存在，cur为上面的if调过来的，
                    //就是相当于if中的grandfather
                    if (cur == parent->_right)
                    {
                        RotateL(parent);
                        swap(cur, parent);
                    }
                    RotateR(grandfather);
                    parent->_color = BLACK;
                    grandfather->_color = RED;
                    break;
                }
            }
            else//parent==grandfather->_right
            {
                Node* uncle = grandfather->_left;
                if (uncle && uncle->_color == RED)
                {
                    parent->_color = uncle->_color = BLACK;
                    grandfather->_color = RED;
                    cur = grandfather;
                    parent = cur->_parent;
                }
                else//uncle不存在或uncle存在且为黑
                {
                    if (cur == parent->_left)
                    {
                        RotateR(parent);
                        swap(cur, parent);
                    }
                    RotateL(grandfather);
                    parent->_color = BLACK;
                    grandfather->_color = RED;
                    break;
                }
            }
            _root->_color = BLACK;
        }
        return true;
    }

红黑树的查找和删除

红黑树的查找和搜索二叉数类似
红黑树的删除和搜索二叉树的类似，不同的是要进行调整红黑节点，使删除后还是红黑树

判断是不是一棵红黑树

就是看一棵搜索二叉树是不是满足红黑树的性质：
1、根节点是不是黑的，是黑的继续向下判断，是红的就直接返回，不是红黑树
2、找父子节点有没有相连的红节点
3、先找了最左路径的黑节点的个数，与其他路径的黑节点进行比较，用递归实现，只要有不相同的黑色节点，就不是红黑树。
代码：

bool IsRBTree()
    {
        if (_root == NULL)//空树，算是红黑树
            return true;
        if (_root->_color == RED)//根节点为红色，不是红黑树
            return false;
        Node* cur = _root;
        size_t BlackNum = 0;
        while (cur)
        {
            if (cur->_color == BLACK)
                ++BlackNum;
            cur = cur->_left;
        }
        int num = 0;
        return _IsRBTree(_root, BlackNum, num);
    }
    bool _IsRBTree(Node* cur, const int& BlackNum, int num)
    {
        if (cur == NULL)
        {
            if (BlackNum != num)
            {
                cout << "黑色节点不相同" << endl;
                return false;
            }
            return true;
        }
        //有两个连续的红节点，不是红黑树，直接返回
        if (cur->_parent && cur->_parent->_color == RED && cur->_color == RED)
            return false;
        if (cur->_color == BLACK)
            num++;
        return _IsRBTree(cur->_left, BlackNum, num) && _IsRBTree(cur->_left, BlackNum, num);
    }

红黑树的左右旋

左单旋和右单旋原理与AVL树相同，不同的是AVL树调整平衡因子，红黑树调整红黑节点。
代码：

void RotateL(Node* parent)//左单旋
    {
        Node* subR = parent->_right;
        Node* subRL = subR->_left;
        parent->_right = subRL;
        if (subRL)
            subRL->_parent = parent;

        Node* ppNode = parent->_parent;

        subR->_left = parent;
        parent->_parent = subR;

        if (ppNode == NULL)
        {
            _root = subR;
            subR->_parent = NULL;
        }
        else
        {
            if (ppNode->_left == parent)
                ppNode->_left = subR;
            else
                ppNode->_right = subR;
            subR->_parent = ppNode;
        }
    }

    void RotateR(Node* parent)//右单旋
    {
        Node* subL = parent->_left;
        Node* subLR = subL->_right;

        parent->_left = subLR;
        if (subLR)
            subLR->_parent = parent;

        Node* ppNode = parent->_parent;
        subL->_right = parent;
        parent->_parent = subL;
        if (ppNode == NULL)
        {
            _root = subL;
            subL->_parent = NULL;
        }
        else
        {
            if (ppNode->_left == parent)
                ppNode->_left = subL;
            else
                ppNode->_right = subL;
            subL->_parent = ppNode;
        }
    }

整体代码：

"RBTree.h"
#pragma once

enum Color
{
    RED,
    BLACK,
};

template<class K,class V>
struct RBTreeNode
{
    K _key;
    V _value;

    Color _color;

    RBTreeNode<K, V>* _left;
    RBTreeNode<K, V>* _right;
    RBTreeNode<K, V>* _parent;

    RBTreeNode(const K& key,const V& value)
        :_key(key)
        , _value(value)
        , _color(RED)
        , _left(NULL)
        , _right(NULL)
        , _parent(NULL)
    {}
};

template <class K,class V>
class RBTree
{
    typedef RBTreeNode<K, V> Node;
public:
    RBTree()
        :_root(NULL)
    {}

    ~RBTree()
    {
        _Destroy(_root);
    }

    bool Insert(const K& key, const V& value)
    {
        if (_root == NULL)
        {
            _root = new Node(key, value);
            _root->_color = BLACK;
            return true;
        }

        Node* cur = _root;
        Node* parent = NULL;
        //找插入的位置
        while (cur)
        {
            if (key < cur->_key)
            {
                parent = cur;
                cur = cur->_left;
            }
            else if (key > cur->_key)
            {
                parent = cur;
                cur = cur->_right;
            }
            else
                return false;
        }

        cur = new Node(key, value);

        if (key < parent->_key)
        {
            parent->_left = cur;
            cur->_parent = parent;
        }
        else
        {
            parent->_right = cur;
            cur->_parent = parent;
        }

        while (parent && parent->_color == RED)
        {
            Node* grandfather = parent->_parent;
            if (parent == grandfather->_left)//parent为左孩子
            {
                Node* uncle = grandfather->_right;
                if (uncle && uncle->_color == RED)
                {
                    parent->_color = uncle->_color = BLACK;
                    grandfather->_color = RED;
                    cur = grandfather;
                    parent = cur->_parent;
                }


                else//uncle不存在或uncle存在且为黑色
                {
                    //uncle不存在，cur为新插节点。uncle存在，cur为上面的if调过来的，
                    //就是相当于if中的grandfather
                    if (cur == parent->_right)
                    {
                        RotateL(parent);
                        swap(cur, parent);
                    }
                    RotateR(grandfather);
                    parent->_color = BLACK;
                    grandfather->_color = RED;
                    break;
                }
            }
            else//parent==grandfather->_right
            {
                Node* uncle = grandfather->_left;
                if (uncle && uncle->_color == RED)
                {
                    parent->_color = uncle->_color = BLACK;
                    grandfather->_color = RED;
                    cur = grandfather;
                    parent = cur->_parent;
                }
                else//uncle不存在或uncle存在且为黑
                {
                    if (cur == parent->_left)
                    {
                        RotateR(parent);
                        swap(cur, parent);
                    }
                    RotateL(grandfather);
                    parent->_color = BLACK;
                    grandfather->_color = RED;
                    break;
                }
            }
            _root->_color = BLACK;
        }
        return true;
    }

    bool IsRBTree()
    {
        if (_root == NULL)//空树，算是红黑树
            return true;
        if (_root->_color == RED)//根节点为红色，不是红黑树
            return false;
        Node* cur = _root;
        size_t BlackNum = 0;
        while (cur)
        {
            if (cur->_color == BLACK)
                ++BlackNum;
            cur = cur->_left;
        }
        int num = 0;
        return _IsRBTree(_root, BlackNum, num);
    }

    void RotateL(Node* parent)
    {
        Node* subR = parent->_right;
        Node* subRL = subR->_left;
        parent->_right = subRL;
        if (subRL)
            subRL->_parent = parent;

        Node* ppNode = parent->_parent;

        subR->_left = parent;
        parent->_parent = subR;

        if (ppNode == NULL)
        {
            _root = subR;
            subR->_parent = NULL;
        }
        else
        {
            if (ppNode->_left == parent)
                ppNode->_left = subR;
            else
                ppNode->_right = subR;
            subR->_parent = ppNode;
        }
    }

    void RotateR(Node* parent)
    {
        Node* subL = parent->_left;
        Node* subLR = subL->_right;

        parent->_left = subLR;
        if (subLR)
            subLR->_parent = parent;

        Node* ppNode = parent->_parent;
        subL->_right = parent;
        parent->_parent = subL;
        if (ppNode == NULL)
        {
            _root = subL;
            subL->_parent = NULL;
        }
        else
        {
            if (ppNode->_left == parent)
                ppNode->_left = subL;
            else
                ppNode->_right = subL;
            subL->_parent = ppNode;
        }
    }
    void InOrder()
    {
        _InOrder(_root);
        cout << endl;
    }

protected:
    void _Destroy(Node* cur)
    {
        if (cur == NULL)
            return;
        _Destroy(cur->_left);
        _Destroy(cur->_right);

        delete cur;
        cur = NULL;
    }
    bool _IsRBTree(Node* cur, const int& BlackNum, int num)
    {
        if (cur == NULL)
        {
            if (BlackNum != num)
            {
                cout << "黑色节点不相同" << endl;
                return false;
            }
            return true;
        }
        //有两个连续的红节点，不是红黑树，直接返回
        if (cur->_parent && cur->_parent->_color == RED && cur->_color == RED)
            return false;
        if (cur->_color == BLACK)
            num++;
        return _IsRBTree(cur->_left, BlackNum, num) && _IsRBTree(cur->_left, BlackNum, num);
    }
    void _InOrder(Node* cur)
    {
        if (cur == NULL)
            return;
        _InOrder(cur->_left);
        cout << cur->_key << " ";
        _InOrder(cur->_right);
    }
protected:
    Node* _root;
};

void TestRBTree()
{
    int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
    RBTree<int, int> rb;
    for (size_t i = 0; i < sizeof(a) / sizeof(a[0]); ++i)
    {
        rb.Insert(a[i], i);
        //cout << a[i] <<"IsRBTree?" << rb.IsRBTree() << endl;
    }
    rb.InOrder();
    cout << "IsRBTree?" << rb.IsRBTree() << endl;
}
"Test.cpp"
#include <iostream>
using namespace std;

#include "RBTree.h"
int main()
{
    TestRBTree();
    return 0;
}
simplehap
关注
专栏目录
红黑树的旋转与变色
诺浅的专栏
01-27 9583
缘起 在此之前，笔者写过一篇关于TreeMap工作原理的简单解析，其中限于当时知识和时间有限，暂没有解析关于树的旋转和变色等操作。后来笔者查询了一部分资料也参考了很多文章，终于弄清楚变色和旋转是如何工作的。本文主要详解一下红黑树的变色和旋转是如何工作的。 为什么红黑树要旋转和变色 这需要从红黑树的特效说起，红黑树发明之初就定义了以下5个特性，因为这几个特性，使得红黑树成为一个相对平衡的二叉树，也就...
红黑树的插入详细图解，直接拿下红黑树
08-17
红黑树是一种自平衡二叉查找树，它的主要特点是在保持二叉查找树特性的同时，通过特定的颜色规则来确保树的平衡，以达到快速查找、插入和删除的目的。红黑树的每个节点都有一个颜色属性，可以是红色或黑色。在插入新...
红黑树基本概念
铭毅天下Elasticsearch
09-27 7727
红黑树基本概念        【维基百科】 红黑树是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。它是在1972年由鲁道夫·贝尔发明的，他称之为"对称二叉B树"，它现代的名字是在 Leo J. Guibas 和 Robert Sedgewick 于1978年写的一篇论文中获得的。它是复杂的，但它的操作有着良好的最坏情况运行时间，并且在实践中是高效的:
红黑树（RED-BLACK TREES）基本概念
架构设计
03-31 242
下面是一棵红黑树 红黑树：是一棵要么标记为红色要么标记为黑色的二叉搜索树，同时是一棵extended二叉树（即在原来二叉树的基础上将叶子节点的两个null指针替换成external节点，上图的方块就是external节点）。性质如下： 1）根节点和external节点都是黑色的。 2）任何一条从根节点到external节点的路径中不存在两个连续的红色节点。 3）所有从根节点到exter...
红黑树概念
weixin_57763462的博客
02-15 723
1.为什么需要红黑树？ 对于二叉搜索树，如果插入的数据是随机的，那么它就是接近平衡的二叉树，平衡的二叉树，它的操作效率（查询，插入，删除）效率较高，时间复杂度是O（logN）。但是可能会出现一种极端的情况，那就是插入的数据是有序的（递增或者递减），那么所有的节点都会在根节点的右侧或左侧，此时，二叉搜索树就变为了一个链表，它的操作效率就降低了，时间复杂度为O(N)，所以可以认为二叉搜索树的时间复杂度介于O（logN）和O(N)之间，视情况而定。那么为了应对这种极端情况，红黑树就出现了，它是具备了..
红黑树java操作代码 红黑树是java里面遍历性能最好数据结构
10-17
红黑树（Red-Black Tree）是一种自平衡二叉查找树，它在计算机科学中扮演着重要的角色，尤其是在实现高效的数据结构和算法时。在Java中，虽然标准库并未直接提供红黑树的类，但我们可以自定义实现，如提供的`Red...
红黑树与区间树算法实现
04-08
红黑树和区间树是两种在计算机科学中广泛使用的数据结构，主要应用于高效的数据管理和查询。在本实验中，我们探讨了如何用C++来实现这两种数据结构，并提供了相关的可视化功能。 红黑树是一种自平衡二叉查找树，由...
红黑树：红黑树的Matlab实现-matlab开发
05-30
红黑树是一种自平衡二叉查找树，由Rudolf Bayer于1972年提出。它的设计目标是在保持二叉查找树基本性质的同时，通过引入颜色（红色或黑色）来确保任何节点到其每个叶子节点的所有路径都具有相同的黑色节点数，从而...
控制台打印红黑树.rar
05-17
红黑树（Red-Black Tree）是一种自平衡二叉查找树，由计算机科学家鲁道夫·贝尔在1978年提出。它在保持二叉查找树特性的同时，通过引入颜色属性来确保树的平衡，从而优化了查找、插入和删除操作的时间复杂度。红黑树...
红黑树--基本概念
pengwenrui的博客
06-18 429
1.java中的TreeSet，TreeMap底层使用了红黑树2.红黑树的定义enum Color {RED = 0;BLACK = 1;}struct RBTreeNode{struct RBTreeNode *left,*right,*parent;int key;int data;Color color;}3.红黑树有哪些性质？1.每个结点要么是红的，要么是黑的。2.根节点是黑色的。3.每个...
红黑树的基本概念
flyapy
07-09 565
红黑树是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。它是在1972年由鲁道夫·贝尔发明的，他称之为"对称二叉B树"，它现代的名字是在 Leo J. Guibas 和 Robert Sedgewick 于1978年写的一篇论文中获得的。它是复杂的，但它的操作有着良好的最坏情况运行时间，并且在实践中是高效的: 它可以在O(log n)时间内做查找，插入和
红黑树的一些概念
Hi, Sun
02-05 120
普通的二叉树作为数据存储有重要的优势，可以快速的找到一个给定的关键字，数据项，并且可以快速的插入 和删除数据项。其他的数据存储结构，数组有序数组链表在执行这些操作的时候却很满。   但是。遗憾的是二叉树搜索树有一个很麻烦的问题就是：如果树中插入的是随机数据，那么执行的效果很好。 但是，如果插入的是有序的数据或者逆序数据，速度就变的特别慢。因为当插入的数据有序时，二叉树就是非平衡了，而...
红黑树的特性及其应用
qiuyumin430的博客
03-08 475
红黑树的特性:（1）每个节点或者是黑色，或者是红色。（2）根节点是黑色。（3）每个叶子节点（NIL）是黑色。 [注意：这里叶子节点，是指为空(NIL或NULL)的叶子节点！]（4）如果一个节点是红色的，则它的子节点必须是黑色的。（5）从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。红黑树的应用：Java集合中的TreeSet和TreeMap，C++ STL中的set、map，以及Li...
Java基础：红黑树概念
KaiSarH
03-22 368
红黑树概念
红黑树的定义与性质
Weightwwc的专栏
09-11 566
红黑树是每个节点都带有颜色属性的二叉查找树，颜色或红色或黑色。在二叉查找树强制一般要求以外，对于任何有效的红黑树我们增加了如下的额外要求: 性质1. 节点是红色或黑色。 性质2. 根节点是黑色。 性质3 每个叶节点（NIL节点，空节点）是黑色的。 性质4 每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点) 性质5. 从任一节点到其每个叶子的所有路径都
深入理解红黑树算法
"红黑树算法详细介绍" 红黑树是一种自平衡的二叉查找树，它的设计目的是为了在保持高效查找性能的同时，尽可能地减少树的不平衡性。这种数据结构在许多计算机科学领域，尤其是算法和数据结构的设计中，扮演着重要的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值