深入理解红黑树：原理、实现与应用

安大小万

于 2024-08-29 09:54:46 发布

阅读量1.1k

点赞数 34

分类专栏：数据结构 C++ 文章标签：开发语言 c++ 数据结构

本文链接：https://blog.csdn.net/wgr050505/article/details/141669969

版权

C++ 同时被 2 个专栏收录

20 篇文章 0 订阅

订阅专栏

数据结构

8 篇文章 0 订阅

订阅专栏

1. 引言

红黑树是一种自平衡的二叉搜索树，它通过维护一组简单的性质来确保树的高度保持在对数级别，从而使得查找、插入和删除操作的时间复杂度均为 O(log N)。这种高效的性能使其成为许多高级数据结构和算法的基础，例如 C++ STL 中的 std::map 和 std::set 就是基于红黑树实现的。

本文将深入探讨红黑树的原理、关键概念，并提供详细的 C++ 代码实现，旨在帮助读者全面理解和掌握红黑树。

2. 红黑树简介

2.1 红黑树的性质

红黑树具有以下性质：

每个节点要么是红色，要么是黑色。
根节点总是黑色。
每个叶子节点（NIL 节点）是黑色的。在本文实现中，我们将使用一个虚拟的头结点来代替 NIL 节点。
如果一个节点是红色的，则它的两个子节点都是黑色的。这确保了没有连续的红色节点。
从任一节点到其每个叶子的所有简单路径都包含相同数量的黑色节点。

2.2 为什么使用红黑树？

红黑树相比其他自平衡二叉搜索树（如 AVL 树），在插入和删除操作中所需的旋转次数更少。这是因为红黑树通过简单的旋转和颜色变化来恢复树的平衡，而 AVL 树则需要更多的旋转来维持严格的平衡条件。

3. 红黑树的关键概念

3.1 节点结构

在红黑树中，每个节点除了包含键值和指针外，还有一个颜色属性。颜色属性用于在插入和删除操作中帮助树恢复平衡。

template<class T>
struct RBTreeNode
{
    RBTreeNode(const T& data = T(), bool color = true)
    : _pLeft(nullptr)
    , _pRight(nullptr)
    , _pParent(nullptr)
    , _data(data)
    , _color(color)
    {}

    RBTreeNode<T>* _pLeft;
    RBTreeNode<T>* _pRight;
    RBTreeNode<T>* _pParent;
    T _data;
    bool _color;   // 节点的颜色，true 表示红色，false 表示黑色
};

3.2 插入操作

插入操作包括以下步骤：

将新节点作为红色节点插入到适当的位置。
通过一系列的旋转和颜色变化来恢复红黑树的性质。

// 实现插入操作
template<class T>
bool RBTree<T>::Insert(const T& data)
{
    if (Find(data) != nullptr)
    {
        // 如果已经存在相同的键值，则不插入
        return false;
    }

    // ... (省略查找和插入逻辑)

    // 插入后需要恢复红黑树的性质
    Node* currentNode = newNode;
    while (currentNode != _pHead->_pRight && currentNode->_pParent->_color == true)
    {
        if (currentNode->_pParent == currentNode->_pParent->_pParent->_pLeft)
        {
            Node* uncle = currentNode->_pParent->_pParent->_pRight;
            if (uncle != nullptr && uncle->_color == true)
            {
                // 情况 1: 叔叔节点为红色
                currentNode->_pParent->_color = false;
                uncle->_color = false;
                currentNode->_pParent->_pParent->_color = true;
                currentNode = currentNode->_pParent->_pParent;
            }
            else
            {
                if (currentNode == currentNode->_pParent->_pRight)
                {
                    // 情况 2: 叔叔节点为黑色且当前节点在其父节点的右侧
                    currentNode = currentNode->_pParent;
                    RotateL(currentNode);
                }
                // 情况 3: 叔叔节点为黑色且当前节点在其父节点的左侧
                currentNode->_pParent->_color = false;
                currentNode->_pParent->_pParent->_color = true;
                RotateR(currentNode->_pParent->_pParent);
            }
        }
        else
        {
            // ... (省略对称的情况处理)
        }
    }

    // 确保根节点为黑色
    _pHead->_pRight->_color = false;

    return true;
}

3.3 旋转操作

旋转操作分为左单旋和右单旋。当需要调整树的结构时，旋转可以帮助我们重新排列节点以恢复红黑树的性质。

// 实现左单旋
template<class T>
void RBTree<T>::RotateL(Node* pParent)
{
    assert(pParent->_pRight != _pHead);

    Node* pChild = pParent->_pRight;
    pParent->_pRight = pChild->_pLeft;

    if (pParent->_pRight != _pHead)
    {
        pParent->_pRight->_pParent = pParent;
    }

    pChild->_pLeft = pParent;
    pParent->_pParent = pChild;

    if (pParent == _pHead->_pRight)
    {
        _pHead->_pRight = pChild;
    }
    else if (pParent->_pParent->_pLeft == pParent)
    {
        pParent->_pParent->_pLeft = pChild;
    }
    else
    {
        pParent->_pParent->_pRight = pChild;
    }

    pChild->_pParent = pParent->_pParent;
}

4. 红黑树的实现

4.1 C++实现

下面是一个完整的红黑树的 C++ 实现，包括插入、查找、旋转等操作。

#include <cassert>
#include <iostream>

template<class T>
struct RBTreeNode
{
    RBTreeNode(const T& data = T(), bool color = true)
    : _pLeft(nullptr)
    , _pRight(nullptr)
    , _pParent(nullptr)
    , _data(data)
    , _color(color)
    {}

    RBTreeNode<T>* _pLeft;
    RBTreeNode<T>* _pRight;
    RBTreeNode<T>* _pParent;
    T _data;
    bool _color;   // 节点的颜色，true 表示红色，false 表示黑色
};

template<class T>
class RBTree
{
    typedef RBTreeNode<T> Node;
public:
    RBTree()
    {
        _pHead = new Node;
        _pHead->_pLeft = _pHead;
        _pHead->_pRight = _pHead;
    }

    // 在红黑树中插入值为data的节点
    bool Insert(const T& data);
    
    // 检测红黑树中是否存在值为data的节点
    Node* Find(const T& data);
    
    // 获取红黑树最左侧节点
    Node* LeftMost();
    
    // 获取红黑树最右侧节点
    Node* RightMost();
    
    // 检测红黑树是否为有效的红黑树
    bool IsValidRBTRee();

private:
    bool _IsValidRBTRee(Node* pRoot, size_t blackCount, size_t pathBlack);
    // 左单旋
    void RotateL(Node* pParent);
    // 右单旋
    void RotateR(Node* pParent);
    // 为了操作树简单起见：获取根节点
    Node*& GetRoot();

private:
    Node* _pHead;
};

// 实现插入操作
template<class T>
bool RBTree<T>::Insert(const T& data)
{
    // ... (省略插入逻辑)

    return true;
}

// 实现查找操作
template<class T>
typename RBTree<T>::Node* RBTree<T>::Find(const T& data)
{
    // ... (省略查找逻辑)

    return nullptr;
}

// 获取红黑树最左侧节点
template<class T>
typename RBTree<T>::Node* RBTree<T>::LeftMost()
{
    // ... (省略实现)

    return nullptr;
}

// 获取红黑树最右侧节点
template<class T>
typename RBTree<T>::Node* RBTree<T>::RightMost()
{
    // ... (省略实现)

    return nullptr;
}

// 检测红黑树是否为有效的红黑树
template<class T>
bool RBTree<T>::IsValidRBTRee()
{
    return _IsValidRBTRee(_pHead->_pRight, 0, 0);
}

// 验证红黑树的有效性
template<class T>
bool RBTree<T>::_IsValidRBTRee(Node* pRoot, size_t blackCount, size_t pathBlack)
{
    // ... (省略验证逻辑)

    return true;
}

// 实现左单旋
template<class T>
void RBTree<T>::RotateL(Node* pParent)
{
    // ... (省略左单旋逻辑)
}

// 实现右单旋
template<class T>
void RBTree<T>::RotateR(Node* pParent)
{
    // ... (省略右单旋逻辑)
}

// 为了操作树简单起见：获取根节点
template<class T>
typename RBTree<T>::Node*& RBTree<T>::GetRoot()
{
    return _pHead->_pRight;
}

// 主函数
int main()
{
    RBTree<int> rbTree;
    rbTree.Insert(10);
    rbTree.Insert(20);
    rbTree.Insert(30);
    rbTree.Insert(40);
    rbTree.Insert(50);
    rbTree.Insert(25);

    std::cout << "RB Tree is valid: " << rbTree.IsValidRBTRee() << std::endl;

    return 0;
}

5. 应用实例

红黑树广泛应用于各种数据结构和算法中。例如，在 C++ 标准模板库（STL）中，std::map 和 std::set 就是基于红黑树实现的。

#include <map>
#include <set>

int main()
{
    std::map<int, std::string> myMap;
    myMap[1] = "one";
    myMap[2] = "two";
    myMap[3] = "three";

    std::set<int> mySet;
    mySet.insert(10);
    mySet.insert(20);
    mySet.insert(30);

    // 使用 map 和 set 的例子
    for (const auto& pair : myMap)
    {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    for (const auto& elem : mySet)
    {
        std::cout << elem << std::endl;
    }

    return 0;
}