红黑树

最新推荐文章于 2024-12-11 00:02:12 发布
原创 最新推荐文章于 2024-12-11 00:02:12 发布 · 309 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#红黑树及其实现

1.红黑树简介
红黑树（Red Black Tree） 是一种自平衡二叉查找树，红黑树和AVL树类似，都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡，从而获得较高的查找性能。它虽然是复杂的，但它的最坏情况运行时间也是非常良好的，并且在实践中是高效的： 它可以在O(log n)时间内做查找，插入和删除，这里的n 是树中元素的数目。
红黑树是每个节点都带有颜色属性的二叉查找树，颜色或红色或黑色。在二叉查找树强制一般要求以外，对于任何有效的红黑树我们增加了如下的额外要求:
性质1. 节点是红色或黑色。
性质2. 根节点是黑色。
性质3 每个叶节点（NIL节点，空节点）是黑色的。
性质4 每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点)
性质5. 从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。
这些约束强制了红黑树的关键性质: 从根到叶子的最长的可能路径不多于最短的可能路径的两倍长。结果是这个树大致上是平衡的。因为操作比如插入、删除和查找某个值的最坏情况时间都要求与树的高度成比例，这个在高度上的理论上限允许红黑树在最坏情况下都是高效的，而不同于普通的二叉查找树。
2.代码实现

#ifndef RBT_H
#define RBT_H
#include <iostream>
using namespace std;
enum Color
{
    RED,
    BLACK
};

template<typename K, typename V>
struct Node
{
    K key;
    V val;
    int N;
    Color color;
    Node<K, V>* left;
    Node<K, V>* right;

    Node()
    {
        this->left = NULL;
        this->right = NULL;
    }

    Node(K key, V val)
    {
        this->key = key;
        this->val = val;
        this->N = 1;
        this->color = RED;
        this->left = NULL;
        this->right = NULL;
    }
};

template<typename K, typename V>
class RBT
{
public:
    RBT();
    ~RBT();
    V Getval(const K& key) const;
    Node<K, V>* Insert(const K& key, const V& val);
    void Del(int arr[], int index, const K& key);
    bool contain(const K& key) const;
    int size() const;
    void clean();
    K minKey() const;
    K MaxKey() const;
    K CountLevel() const;
    void pretree() const;
    void midtree() const;
    void lasttree() const;
protected:
    Node<K, V>* root;
    Node<K, V>* Roleft(Node<K, V>* node);
    Node<K, V>* Roright(Node<K, V>* node);
    void filpNode(Node<K, V>* node);
    void ReFilpNode(Node<K, V>* node);
    Node<K, V>* fixNode(Node<K, V>* node);
    Node<K, V>* Insert(Node<K, V>* node, const K& key, const V& val);
    V Getval(Node<K, V>* node, const K& key) const;
    bool contain(Node<K, V>* node, const K& key) const;
    Node<K, V>* del(int arr[], int index, Node<K, V>* node, const K& key);
    void clean(Node<K, V>* node);
    int size(Node<K, V>* node) const;
    K minKey(Node<K, V>* node) const;
    K MaxKey(Node<K, V>* node) const;
    K CountLevel(Node<K, V>* node) const;
    bool isRed(Node<K, V>* node);
    void pretree(Node<K, V>* node) const;
    void midtree(Node<K, V>* node) const;
    void lasttree(Node<K, V>* node) const;
};

//构造 析构函数
template<typename K, typename V>
RBT<K, V>::RBT()
{
    this->root = NULL;
}

template<typename K, typename V>
RBT<K, V>::~RBT()
{
    clean(this->root);
}


/********************************************************************
函数名称:  isRed
函数参数： @node 节点指针
函数说明:  判断节点的颜色
返回值:    成功返回true 失败返回false
*********************************************************************/
template<typename K, typename V>
bool RBT<K, V>::isRed(Node<K, V>* node)
{
    if (node == NULL || node->color == BLACK)
        return false;
    else
        return true;
}
/********************************************************************
函数名称:   Insert
函数说明:   放入键值对<key,value> 若存在则将原有的value替换成新的value
返回值:     无
*********************************************************************/
template<typename K, typename V>
Node<K,V>* RBT<K, V>::Insert(const K& key, const V& val)
{
    return this->root = Insert(this->root, key, val);
}
template<typename K, typename V>
Node<K, V>* RBT<K, V>::Insert(Node<K, V>* node, const K& key, const V& val)
{
    if (node == NULL)
        return new Node<K, V>(key, val);
    if (key > node->key)
        node->right = Insert(node->right, key, val);
    else if (key < node->key)
        node->left = Insert(node->left, key, val);
    else
        node->val = val;

    if (isRed(node->right) && !isRed(node->left))
        node = Roleft(node);
    if (node->left != NULL && isRed(node->left) && isRed(node->left->left))
        node = Roright(node);
    if (isRed(node->left) && isRed(node->right))
        filpNode(node);

    node->N = size(node->left) + size(node->right) + 1;
    return node;
}
/********************************************************************
函数名称:   Getval
函数说明:   获取指定key的value
返回值:     value
*********************************************************************/
template<typename K, typename V>
V RBT<K, V>::Getval(const K& key) const
{
    return Getval(this->root, key);
}
template<typename K, typename V>
V RBT<K, V>::Getval(Node<K, V>* node, const K& key) const
{
    if (node == NULL)
        return NULL;
    if (key > node->key)
        return Getval(node->right, key);
    else if (key < node->key)
        return Getval(node->left, key);
    else
        return node->val;
}
/********************************************************************
函数名称:   clean
函数说明:   清空表
返回值:    无
*********************************************************************/
template<typename K, typename V>
void RBT<K, V>::clean()
{
    clean(this->root);
    this->root = NULL;
}
template<typename K, typename V>
void RBT<K, V>::clean(Node<K, V>* node)
{
    if (node == NULL)
        return;
    clean(node->left);
    clean(node->right);
    delete node;
}
/********************************************************************
函数名称:   size
函数说明:   无
返回值:     红黑树节点个数
*********************************************************************/
template<typename K, typename V>
int RBT<K, V>::size() const
{
    return size(this->root);
}
template<typename K, typename V>
int RBT<K, V>::size(Node<K, V>* node) const
{
    if (node == NULL)
        return 0;
    return size(node->right) + size(node->left) + 1;
}
/********************************************************************
函数名称:   Del
函数说明:   删除某个key
返回值:     无
*********************************************************************/
template<typename K, typename V>
void RBT<K, V>::Del(int arr[], int index, const K& key)
{
    this->root = del(arr, index, this->root, key);
}
int Delete(int arr[],int n, int x)
{
    int p = 0, q = 0;  //用p和q两个变量  
    while (q<n)    //由q控制，扫描所有的元素  
    {
        if (arr[q] != x)  
        {
            arr[p] = arr[q];
            p++;
        }
        q++;
    }     
    return p;
}
template<typename K, typename V>
Node<K, V>* RBT<K, V>::del(int arr[],int index,Node<K, V>* node, const K& key)
{
    RBT<int, int>RBT1;
    if (node == NULL)
        return NULL;
    Delete(arr, index, key);
    for (int i = 0; i < index - 1; i++)
    {
        RBT1.Insert(arr[i], i);
    }
    swap(this->root, RBT1.root);
    root->color = BLACK;
    return this->root;
}

/********************************************************************
函数名称:   prevtree/midtree/lasttree
函数说明:   遍历
*********************************************************************/
template<typename K, typename V> //前序遍历
void RBT<K, V>::pretree() const
{
    pretree(this->root);
}
template<typename K, typename V>
void RBT<K, V>::pretree(Node<K, V>* node) const
{
    if (node != NULL)
    {
        cout << node->key << '\t';
        if (node->color == BLACK)
        {
            cout << "黑色" << endl;
        }
        else
        {
            cout << "红色" << endl;
        }
        pretree(node->left);
        pretree(node->right);
    }
}

template<typename K, typename V> //中序遍历
void RBT<K, V>::midtree()const
{
    midtree(this->root);
}
template<typename K, typename V>
void RBT<K, V>::midtree(Node<K, V>* node) const
{
    if (node != NULL)
    {
        midtree(node->left);
        cout << node->key << '\t';
        if (node->color == BLACK)
        {
            cout << "黑色" << endl;
        }
        else
        {
            cout << "红色" << endl;
        }
        midtree(node->right);
    }
}

template<typename K, typename V> //后序遍历
void RBT<K, V>::lasttree()const
{
    lasttree(this->root);
}
template<typename K, typename V>
void RBT<K, V>::lasttree(Node<K,V>* node) const
{
    if (node != NULL)
    {
        lasttree(node->left);
        lasttree(node->right);
        cout << node->key << '\t';
        if (node->color == BLACK)
        {
            cout << "黑色" << endl;
        }
        else
        {
            cout << "红色" << endl;
        }
    }
}

/********************************************************************
函数名称:   contain
函数说明:   是否包含key
返回值:     包含返回true 不包含返回false
*********************************************************************/
template<typename K, typename V>
bool RBT<K, V>::contain(const K& key) const
{
    return contain(this->root, key);
}
template<typename K, typename V>
bool RBT<K, V>::contain(Node<K, V>* node, const K& key) const
{
    if (node == NULL)
        return false;
    if (key > node->key)
        Getval(node->right, key);
    else if (key < node->key)
        Getval(node->left, key);
    else
        return true;
}
/********************************************************************
函数名称:  Roleft
函数参数： 需要旋转的节点指针
函数说明:  将右节点旋转到左边并设置为红色
返回值:    旋转后的树根指针
*********************************************************************/
template<typename K, typename V>
Node<K, V>* RBT<K, V>::Roleft(Node<K, V>* node)
{
    Node<K, V>* right = node->right;
    node->right = right->left;
    right->left = node;
    right->color = node->color;
    node->color = RED;
    node->N = size(node->left) + size(node->right) + 1;
    right->N = size(right->left) + size(right->right) + 1;
    return right;
}

/********************************************************************
函数名称:  Roright
函数参数： 需要旋转的节点指针
函数说明:  将左节点旋转到右边并设置为红色
返回值:    旋转后的树根指针
*********************************************************************/
template<typename K, typename V>
Node<K, V>* RBT<K, V>::Roright(Node<K, V>* node)
{
    Node<K, V>* left = node->left;
    node->left = left->right;
    left->right = node;
    left->color = node->color;
    node->color = RED;
    node->N = size(node->left) + size(node->right) + 1;
    left->N = size(left->left) + size(left->right) + 1;
    return left;
}

/********************************************************************
函数名称:  flipNode
函数参数： 节点指针
函数说明:  将节点的左右子树的颜色变成黑色 同时节点颜色变成红色
*********************************************************************/
template<typename K, typename V>
void RBT<K, V>::filpNode(Node<K, V>* node)
{
    node->color = RED;
    node->left->color = BLACK;
    node->right->color = BLACK;
}
/********************************************************************
函数名称:  ReFilpNode
函数参数： @node 节点指针
函数说明:  反向翻转节点和子节点的颜色 将节点颜色变成黑色 子节点红色
返回值:    无
*********************************************************************/
template<typename K, typename V>
void RBT<K, V>::ReFilpNode(Node<K, V>* node)
{
    node->color = BLACK;
    node->left->color = RED;
    node->right->color = RED;
}

/********************************************************************
函数名称:  fixRedNode
函数参数： @node 节点指针
函数说明:  修复反向反转后节点 node->right->left 为红色的情况
返回值:
*********************************************************************/
template<typename K, typename V>
Node<K, V>* RBT<K, V>::fixNode(Node<K, V>* node)
{
    node->right = Roright(node->right);
    node = Roleft(node);
    return node;
}

/********************************************************************
函数名称:  minKey
函数参数： 无
函数说明:  返回表中最小的key
返回值:    key
*********************************************************************/
template<typename K, typename V>
K RBT<K, V>::minKey() const
{
    return minKey(this->root);
}
template<typename K, typename V>
K RBT<K, V>::minKey(Node<K, V>* node) const
{
    if (node->left == NULL)
        return node->key;
    else
        minKey(node->left);
}
/********************************************************************
函数名称:  MaxKey
函数参数： 无
函数说明:  返回红黑树中最大的key
返回值:    key
*********************************************************************/
template<typename K, typename V>
K RBT<K, V>::MaxKey() const
{
    return MaxKey(this->root);
}
template<typename K, typename V>
K RBT<K, V>::MaxKey(Node<K, V>* node) const
{
    if (node->right == NULL)
        return node->key;
    else
        MaxKey(node->right);
}
template<typename K, typename V>
K RBT<K, V>::CountLevel() const
{
    return CountLevel(this->root);
}
template<typename K, typename V>
K RBT<K, V>::CountLevel(Node<K, V>* node) const
{
    static int count = 0;
    if (node)
    {
        if (node->left == NULL&&node->right == NULL)
        ++count;
        CountLevel(node->left);
        CountLevel(node->right);
    }
    return count;
}
#endif

void test()
{
    RBT<int, int>RBT;
    int arr[11] = { 15, 6, 18, 3, 7, 17, 20, 2, 4, 13, 9 };
    //int arr[5] = { 3, 5, 6, 2, 4 };
    int index = sizeof(arr) / sizeof(arr[0]);
    Node<int, int>*ret = NULL;
    for (int i = 0; i < 11; i++)
    {
        ret = RBT.Insert(arr[i], i);
    }
    ret->color = BLACK;
    RBT.Del(arr, index, 3);
    RBT.midtree();
    cout << endl;
    cout << RBT.minKey() << endl;
    cout << RBT.MaxKey() << endl;
    cout << RBT.Getval(6) << endl;
    cout << RBT.size() << endl;
    cout << RBT.CountLevel() << endl;
    cout << RBT.contain(6) << endl;
    RBT.pretree();
    cout << endl;
    RBT.lasttree();
    cout << endl;
}
int main()
{
    test();
    system("pause");
    return 0;
}

这里写图片描述
这里写图片描述
这里写图片描述
3.红黑树和AVL树的比较
红黑树和AVL树都是高效的平衡二叉树， 增删查改的时间复杂度都是O(lg(N))
红黑树的不追求完全平衡， 保证最长路径不超过最短路径的2倍， 相对而言， 降低了旋转的要求， 所以性能会优于AVL树， 所以实际运用
中红黑树更多。

红黑树精通指南：面试、实战与源码分析
张彦峰的博客
05-12 177万+
本文深入探讨了红黑树的基本原理、实现方法及其在实际应用中的重要性。红黑树是一种自平衡的二叉搜索树，通过一系列颜色标记和旋转操作保证了查找、插入和删除操作的时间复杂度始终保持在 O(log n) 级别。文章首先介绍了红黑树的关键性质和与 AVL 树的区别，分析了红黑树在数据库索引、内存管理等领域的应用。接着，详细讲解了红黑树的插入和删除操作，以及如何通过旋转和颜色调整保持树的平衡。最后，文章通过源码分析展示了红黑树在 Java 和 Linux 内核中的实现，帮助读者更好地理解这一数据结构的实际应用和开发过程。
解析红黑树（ppt文档）.ppt
03-01
解析红黑树（ppt文档） 红黑树是一种自平衡二叉查找树，它的每个节点都包含一个键值和对应的值。红黑树的主要特点是它可以自动维持平衡，从而保证查找、插入、删除操作的时间复杂度为 O(log n)。 红黑树的五个性质...
【数据结构】史上最好理解的红黑树讲解，让你彻底搞懂红黑树
热门推荐
小七的博客
01-18 27万+
狂肝半个月的学习笔记，最通俗易懂的红黑树讲解。带你快速掌握红黑树~
红黑树 详解
最新发布
T_Y_F_的博客
12-11 964
红黑树 详解
C++红黑树
~
03-26 7002
C++红黑树零、前言一、红黑树的概念及性质二、红黑树结点的定义三、红黑树的插入操作1、变色处理2、单旋+变色3、双旋+变色4、插入实现四、红黑树的验证五、红黑树的删除六、红黑树与**AVL**树的比较 零、前言 本章继AVL树后继续讲解学习C++中另一个二叉搜索树–红黑树 一、红黑树的概念及性质 概念： 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长
红黑树详解
lucyLee的博客
09-12 10万+
1. 概述 1.1 红黑树的引入 有了二叉搜索树，为什么还需要平衡二叉树？ 在学习二叉搜索树、平衡二叉树时，我们不止一次提到，二叉搜索树容易退化成一条链 这时，查找的时间复杂度从O(log2N)O(log_2N)O(log2​N)也将退化成O(N)O(N)O(N) 引入对左右子树高度差有限制的平衡二叉树，保证查找操作的最坏时间复杂度也为O(log2N)O(log_2N)O(log2​N) 有了平衡二叉树，为什么还需要红黑树？ AVL的左右子树高度差不能超过1，每次进行插入/删除操作时，几乎都需要通过旋
图解红黑树
Dablelv 的博客专栏。
08-10 1999
1.红黑树简介 红黑树（Red Black Tree）是一种含有红黑结点并能自平衡二叉查找树，典型的用途是实现 map。 它必须满足下面规则： 规则1：每个结点要么是黑色，要么是红色。 规则2：根结点是黑色。 规则3：每个叶子结点（NIL）是黑色。 规则4：每个红色结点的两个子结点都是黑色。 规则5：任意一结点到每个叶子结点的路径都包含相同数量的黑结点。 记住上面的规则也不难，我们会发现黑色结点非常特殊，规则1即“非红即黑”，规则2和3即“首尾全黑”，规则4即“红子双黑”，规则5即“路径等黑”。 这些规则
红黑树简介
Charge8的博客
12-28 964
红黑树简介
C++：红黑树
HZzzzzLu的博客
11-07 1万+
红黑变换之间，平衡之道也
面试常问：什么是红黑树？
Mr.TS的博客
10-22 7万+
什么是红黑树？   ———————————— 二叉查找树（BST）具备什么特性呢？ 1.左子树上所有结点的值均小于或等于它的根结点的值。 2.右子树上所有结点的值均大于或等于它的根结点的值。 3.左、右子树也分别为二叉排序树。 下图中这棵树，就是一颗典型的二叉查找树： 1.查看根节点9： 2.由于10 &gt; 9，...
红黑树的插入详细图解，直接拿下红黑树
08-17
红黑树是一种自平衡二叉查找树，它的主要特点是在保持二叉查找树特性的同时，通过特定的颜色规则来确保树的平衡，以达到快速查找、插入和删除的目的。红黑树的每个节点都有一个颜色属性，可以是红色或黑色。在插入新...
红黑树java操作代码 红黑树是java里面遍历性能最好数据结构
10-17
红黑树（Red-Black Tree）是一种自平衡二叉查找树，它在计算机科学中扮演着重要的角色，尤其是在实现高效的数据结构和算法时。在Java中，虽然标准库并未直接提供红黑树的类，但我们可以自定义实现，如提供的`Red...
栈和队列的基本概念和操作
Nou_Camp的博客
05-18 2856
栈和队列 1.栈的定义 栈是限定只能在一端进行插入和删除的线性表。允许进行插入和删除操作的一端称为栈顶，另一端为栈底。当栈中没有元素时，称为空栈。 栈的特点是“后进先出”（Last In First Out，LIFO），即后入栈的元素先出栈。 2.队列定义 队列是限定在一端进行插入，在另一端进行删除的线性表。队列中允许插入一端称为队尾，允许删除的一端称为队头。 在队尾插入元素的操作
树和二叉树（三）-线索二叉树
Nou_Camp的博客
05-15 619
二叉树是一种非线性结构， 遍历二叉树几乎都是通过递归或者用栈辅助实现非递归的遍历。 用二叉树作为存储结构时， 取到一个节点， 只能获取节点的左孩子和右孩子， 不能直接得到节点的任一遍历序列的前驱或者后继。 为了保存这种在遍历中需要的信息， 我们利用二叉树中指向左右子树的空指针来存放节点的前驱和后继信息。 通过对二叉链表的分析可知，存储n个结点的二叉链表具有n+1个空指针域。线索二叉树正是
二叉搜索树及其模拟实现
Nou_Camp的博客
06-03 489
1.二叉搜索树（二叉排序树）的定义 二叉搜索树或者是空树，或者具有以下性质的二叉树： ① 若左子树为空，则左子树上所有结点的关键字值均小于它的根节点的关键字值。 ② 若右子树为空，则右子树上所有结点的关键字值均大于它的根节点的关键字值。 ③左右子树本身又是一颗二叉搜索树。 2.二叉搜索树的查找 查找思路为：若待查找数据元素的关键字值等于二叉搜索树根节点的关键字值，则查找成功；若待查找数据
树和二叉树（一）
Nou_Camp的博客
05-11 467
二叉树的基本概念 二叉树的定义：二叉树是n(n>=0)个结点构成的有限集合。当n=0时，它是一棵空二叉树；当n>0时，它由一个根节点和两棵互不相交的，分别称作左子树和右子树的二叉树构成。 (1)完全二叉树——若设二叉树的高度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第h层有叶子结点，并且叶子结点都是从左到右依次排布，这就是完全二叉树。 (2)满二叉树——除了叶结点
树和二叉树（四）-线索化二叉树
Nou_Camp的博客
05-16 315
线索化二叉树
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值