[C++](20)红黑树，调整规则图解，插入功能代码实现

最新推荐文章于 2024-02-14 09:24:55 发布
最新推荐文章于 2024-02-14 09:24:55 发布
阅读量312 收藏 2
点赞数 1
分类专栏： 数据结构 C++学习 文章标签： c++ 数据结构 算法 后端 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CegghnnoR/article/details/126164563
版权
本文详细介绍了红黑树的概念、性质，并提供了C++实现，包括插入操作、旋转调整以及红黑树性质的检查。通过示例展示了如何在插入过程中保持红黑树的平衡，以及如何通过层序遍历、中序遍历和计算路径长度验证红黑树的正确性。
摘要由CSDN通过智能技术生成

文章目录

概念

在计算机科学中，红黑树是一种自平衡的二叉搜索树。每个结点都增加了一个代表 “颜色”（"红色 "或 “黑色”）的额外存储位，用于确保树在插入和删除时保持平衡。

通过对各个结点着色方式的限制，红黑树确保从根到空结点（NIL结点）的最长的可能路径长度不多于最短的可能路径的两倍。所以红黑树不是严格意义上的平衡二叉树（AVL），但对之进行平衡的代价较低， 其平均统计性能要强于 AVL 。

红黑树的性质：

  1. 每个结点不是红色就是黑色
  2. 根结点是黑色
  3. 如果一个结点是红色，则它的两个孩子结点是黑色（没有连续的红色结点）
  4. 从一个给定的节点到其任何一个后代 NIL 结点的每条路径都要经过相同数量的黑色结点。
  5. NIL 结点都是黑色

红黑树

为什么满足上面的性质，就能保证从根到叶子的最长路径长度不会超过最短路径的 2 倍？

是性质 3 和性质 4 确保了这个结果，一棵红黑树从根到 NIL 结点的所有路径上的黑色结点数是相等的，其中一条最短可能路径一定都是黑色，最长路径要保证尽可能长，在性质3的前提下只能在中间间隔式地插入红色结点，其最长的可能长度也不会超过最短可能长度的 2 倍。

框架

enum Colour
{
	RED,
	BLACK
};

template<class K, class V>
struct RBTreeNode
{
	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;
	pair<K, V> _kv;

	Colour _col;

    RBTreeNode(const pair<K, V>& kv)
        : _left(nullptr)
        , _right(nullptr)
        , _parent(nullptr)
        , _kv(kv)
        , _col(RED)
    {}
};

template<class K, class V>
struct RBTree
{
	typedef RBTreeNode<K, V> Node;
public:

private:
	Node* _root;
};

插入

按搜索树规则插入

bool Insert(const pair<K, V>& kv)
{
    if (_root == nullptr)
    {
        _root = new Node(kv);
        _root->_col = BLACK;
        return true;
    }

    Node* parent = nullptr;
    Node* cur = _root;
    while (cur)
    {
        if (cur->_kv.first < kv.first)
        {
            parent = cur;
            cur = cur->_right;
        }
        else if (cur->_kv.first > kv.first)
        {
            parent = cur;
            cur = cur->_left;
        }
        else
        {
            return false;
        }
    }
    cur = new Node(kv);
    cur->_col = RED; // 新结点初始颜色为红，易于维护
    if (parent->_kv.first < kv.first)
        parent->_right = cur;
    else
        parent->_left = cur;
    cur->_parent = parent;
    
    //...
    
    return true;
}

我们的新结点先染为红色，因为插入红色对性质 3 可能有影响，对性质 4 没有影响，且性质 3 比性质 4 易于维护。

调整

当通过搜索树规则找到要插入的位置时，该位置的父结点有可能是红，也可能是黑。如果是黑，即未破坏性质 3 ，不用调整。

如果父结点是红，则需要调整：

父结点是红，红结点一定不是根，所以一定还有祖父结点，且祖父结点一定是黑，所以这三个结点的情况是固定的。那么关键看叔叔结点。

下面 cur 为当前结点，p 为父结点，g 为祖父结点，u 为叔叔结点

情况一：cur 为红，p 为红，g 为黑，u 存在且为红

解决方案：p 和 u 设为黑，g 设为红。如果 g 是根结点，那么 g 直接设为黑，否则 g 设为 cur 继续向上调整。

因为要保持一条路径的黑色结点个数不变，所以最好把 p 改成红色，g 改成黑色，同时 u 要改成黑色，调整完看 g 是不是根结点，如果不是还要继续向上调，因为上面可能还有连续红色结点。

小三角表示子树，表示 cur 可能是新插入的结点（子树高度为 0），也可能是从下面调整上来的。

情况一

上图仅为p左u右的情况，其镜像同理：

//...

// 有父亲，且父亲为红才处理
while (parent && parent->_col == RED)
{
    Node* grandfather = parent->_parent;
    if (parent == grandfather->_left)
    {
        Node* uncle = grandfather->_right;
        // 情况一
        if (uncle && uncle->_col == RED)
        {
            parent->_col = uncle->_col = BLACK;
            grandfather->_col = RED;
            // 继续向上处理
            cur = grandfather;
            parent = cur->_parent;
        }
        else
        {
			//...
            
        }
    }
    else
    {
        Node* uncle = grandfather->_left;
        // 情况一
        if (uncle && uncle->_col == RED)
        {
            parent->_col = uncle->_col = BLACK;
            grandfather->_col = RED;
            // 继续向上处理
            cur = grandfather;
            parent = cur->_parent;
        }
        else
        {
			//...
        }
    }
}
_root->_col = BLACK; // 不废话，根直接设为黑色

//...

情况二：cur 为红，p 为红，g 为黑，u 不存在/u 存在且为黑，cur 在 p 的外侧

如图，因为插入新结点前就应该满足红黑树，所以如果 u 不存在，那么 g 到 NIL 的每条路径的黑色结点个数一定是 2，所以插入前 g 的左路径只可能是 g-p-NIL，要获得连续红结点，cur 只能是新插入的结点。因为没有子树，所以没画小三角。

如果 u 存在且为黑，那么 g 到 NIL 的每条路径至少有 3 个黑色结点，如果 cur 是新插入的结点，那么插入前 g-p-NIL 路径只有 2 个黑色结点，与插入前满足红黑树的条件矛盾，所以 cur 一定是下面的子树新增结点之后通过情况一调整上来的。

情况二

解决方案：旋转 + 变色：以 g 为旋转点进行旋转，然后 p 变为黑色，g 变为红色。结束后 p 作为该子树的根结点，为黑色，不需要再向上调整。

此时仅仅通过变色无法满足要求了，所以要先旋转，旋转后，p 是新的根结点，但是 p 的左路径少了一个黑色，所以我们将 p 变黑，这样一来 p 的右路径又多了一个黑色，所以我们将 g 变红，最后保证了各路径的黑色结点数不变。

上图仅为 p 在 g 左边的情况，如果 p 在右边则需要右旋，注意旋转方向，旋转的处理和AVL树一样，具体参见博文：AVL树插入，旋转，详细图解与代码

//...父亲在左，叔叔在右

else // 情况二：叔叔不存在或叔叔存在且为黑
{
    if (cur == parent->_left)
    {
        RotateR(grandfather);
        parent->_col = BLACK;
        grandfather->_col = RED;
    }
    break;
}

//...叔叔在左，父亲在右

else // 情况二：叔叔不存在或叔叔存在且为黑
{
    if (cur == parent->_right)
    {
        RotateL(grandfather);
        parent->_col = BLACK;
        grandfather->_col = RED;
    }
    break;
}

//...

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

        parent->_right = subRL;
        if (subRL) subRL->_parent = parent; // subRL有可能是空树，需要if判断

        Node* ppNode = parent->_parent; // 提前记录祖先，后面用来连接新的parent
        subR->_left = parent;
        parent->_parent = subR;

        if (parent == _root) // 如果parent就是根结点，那么新的根是subR
        {
            _root = subR;
            _root->_parent = nullptr;
        }
        else // 否则需要祖先来连接新的parent(即subR)，注意判断左右
        {
            if (parent == ppNode->_left)
            {
                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 (parent == _root)
        {
            _root = subL;
            _root->_parent = nullptr;
        }
        else
        {
            if (parent == ppNode->_left)
            {
                ppNode->_left = subL;
            }
            else
            {
                ppNode->_right = subL;
            }
            subL->_parent = ppNode;
        }
    }

情况三：cur 为红，p 为红，g 为黑，u 不存在/u 存在且为黑，cur 在 p 的内侧

解决方案：和情况二类似，不同点是要进行双旋+变色：先对 p 左/右旋，然后对 g 右/左旋，最后 cur 和 g 变色

第一次旋转对性质 4 没有造成影响，不用变色，第二次旋转和情况二的旋转一样，需要对 g 和 cur 这两个旋转点变色。

情况三

//...父亲在左，叔叔在右

else // 情况二：叔叔不存在或叔叔存在且为黑
{
    if (cur == parent->_left) // 左左：右旋
    {
        RotateR(grandfather);
        parent->_col = BLACK;
        grandfather->_col = RED;
    }
    else // 左右：左右双旋
    {
        RotateL(parent);
        RotateR(grandfather);
        cur->_col = BLACK;
        grandfather->_col = RED;
    }
    break;
}

//...叔叔在左，父亲在右

else // 情况二：叔叔不存在或叔叔存在且为黑
{
    if (cur == parent->_right) // 右右：左旋
    {
        RotateL(grandfather);
        parent->_col = BLACK;
        grandfather->_col = RED;
    }
    else // 右左：右左双旋
    {
        RotateR(parent);
        RotateL(grandfather);
        cur->_col = BLACK;
        grandfather->_col = RED;
    }
    break;
}

//...

总结

关键看叔叔：

  • 叔叔存在且为红，情况一，只需要变色。但仍需向上调整

  • 叔叔不存在或存在且为黑，旋转+变色，旋转变色完成，符合红黑树性质，不再影响上层，处理结束。

    • 旋转遵循AVL树的规则：左左：右旋，右右：左旋，左右：左右双旋，右左：右左双旋
    • 单旋与双旋分别为情况二和情况三

测试

  1. 通过层序遍历和中序遍历直观感受：
public:
	void LevelOrder()
    {
        queue<Node*> que;
        if (_root != NULL) que.push(_root);
        while (!que.empty())
        {
            int size = que.size();
            for (int i = 0; i < size; i++)
            {
                Node* node = que.front();
                que.pop();
                cout << node->_kv.first << ' ';
                if (node->_left) que.push(node->_left);
                if (node->_right) que.push(node->_right);
            }
            cout << endl;
        }
    }

    void Inorder()
    {
        _Inorder(_root);
        cout << endl;
    }

private:
    void _Inorder(Node* root)
    {
        if (root == nullptr) return;
        _Inorder(root->_left);
        cout << root->_kv.first << ' ';
        _Inorder(root->_right);
    }

顺序插入0-99：

void testRBTree1()
{
	const int N = 100;
	RBTree<int, int> t{};
	for (int i = 0; i < N; ++i)
	{
		t.Insert(make_pair(i, 0));
	}
	t.LevelOrder();
	t.Inorder();
}

测试1

  1. 计算最长路径和最短路径
public:
	void Height()
    {
        cout << "最长路径：" << _MaxHeight(_root) << endl;
        cout << "最短路径：" << _MinHeight(_root) << endl;
    }
private:
    int _MaxHeight(Node* root)
    {
        if (root == nullptr) return 0;
        int leftHeight = _MaxHeight(root->_left);
        int rightHeight = _MaxHeight(root->_right);
        return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
    }

    int _MinHeight(Node* root)
    {
        if (root == nullptr) return 0;
        int leftHeight = _MinHeight(root->_left);
        int rightHeight = _MinHeight(root->_right);
        return leftHeight < rightHeight ? leftHeight + 1 : rightHeight + 1;
    }

插入随机值：

void testRBTree2()
{
	const int N = 100;
	vector<int> v;
	v.reserve(N);
	for (int i = 0; i < N; ++i)
	{
		v.push_back(rand());
	}
	RBTree<int, int> t{};
	for (auto e : v)
	{
		t.Insert(make_pair(e, 0));
	}
	t.LevelOrder();
	cout << endl;
	t.Inorder();
	cout << endl;
	t.Height();
}

测试2

结果没问题。

但是这还不足以说明我们写的就是红黑树，下面写一个验证规则：

public:
	bool IsRBTree()
    {
        if (_root == nullptr) return true; // 空树也是红黑树

        if (_root->_col != BLACK) // 检查根结点
        {
            cout << "错误：根结点不为黑色" << endl;
            return false;
        }

        // 获取任一条路径的黑色结点的个数，作为比较的基准值
        size_t blackCount = 0;
        Node* cur = _root;
        while (cur)
        {
            if (cur->_col == BLACK) ++blackCount;
            cur = cur->_left;
        }

        // 检查是否满足红黑树的性质，k用来记录路径中黑色结点的个数
        size_t k = 0;
        return _IsRBTree(_root, k, blackCount);
    }

private:
    bool _IsRBTree(Node* root, size_t k, const size_t blackCount)
    {
        // 走到空，判断黑色结点个数和基准值是否相等
        if (root == nullptr)
        {
            if (k != blackCount)
            {
                cout << "错误：每条路径中黑色结点的个数不同" << endl;
                return false;
            }
            return true;
        }

        if (root->_col == BLACK) ++k;
        
        // 检查是否有连续的红色结点
        Node* parent = root->_parent;
        if (parent && parent->_col == RED && root->_col == RED)
        {
            cout << "错误：有连续的红结点" << endl;
            return false;
        }

        return _IsRBTree(root->_left, k, blackCount) && _IsRBTree(root->_right, k, blackCount);
    }

插入1000000个随机数：

void testRBTree3()
{
	const int N = 1000000;
	vector<int> v;
	v.reserve(N);
	for (int i = 0; i < N; ++i)
	{
		v.push_back(rand());
	}
	RBTree<int, int> t{};
	for (auto e : v)
	{
		t.Insert(make_pair(e, 0));
	}
	//t.LevelOrder();
	//cout << endl;
	//t.Inorder();
	//cout << endl;
	t.Height();
	cout << t.IsRBTree();
}

测试3

完整代码

#pragma once
#include <iostream>
#include <queue>
using namespace std;

enum Colour
{
	RED,
	BLACK
};

template<class K, class V>
struct RBTreeNode
{
	RBTreeNode<K, V>* _left;
	RBTreeNode<K, V>* _right;
	RBTreeNode<K, V>* _parent;
	pair<K, V> _kv;

	Colour _col;

    RBTreeNode(const pair<K, V>& kv)
        : _left(nullptr)
        , _right(nullptr)
        , _parent(nullptr)
        , _kv(kv)
        , _col(RED)
    {}
};

template<class K, class V>
struct RBTree
{
	typedef RBTreeNode<K, V> Node;
public:
    bool Insert(const pair<K, V>& kv)
    {
        if (_root == nullptr)
        {
            _root = new Node(kv);
            _root->_col = BLACK;
            return true;
        }

        Node* parent = nullptr;
        Node* cur = _root;
        while (cur)
        {
            if (cur->_kv.first < kv.first)
            {
                parent = cur;
                cur = cur->_right;
            }
            else if (cur->_kv.first > kv.first)
            {
                parent = cur;
                cur = cur->_left;
            }
            else
            {
                return false;
            }
        }
        cur = new Node(kv);
        cur->_col = RED; // 新结点初始颜色为红，易于维护
        if (parent->_kv.first < kv.first)
            parent->_right = cur;
        else
            parent->_left = cur;
        cur->_parent = parent;

        // 有父亲，且父亲为红才处理
        while (parent && parent->_col == RED)
        {
            Node* grandfather = parent->_parent;
            if (parent == grandfather->_left) // 父亲在左，叔叔在右
            {
                Node* uncle = grandfather->_right;
                // 情况一
                if (uncle && uncle->_col == RED)
                {
                    parent->_col = uncle->_col = BLACK;
                    grandfather->_col = RED;
                    // 继续向上处理
                    cur = grandfather;
                    parent = cur->_parent;
                }
                else // 情况二：叔叔不存在或叔叔存在且为黑
                {
                    if (cur == parent->_left) // 左左：右旋
                    {
                        RotateR(grandfather);
                        parent->_col = BLACK;
                        grandfather->_col = RED;
                    }
                    else // 左右：左右双旋
                    {
                        RotateL(parent);
                        RotateR(grandfather);
                        cur->_col = BLACK;
                        grandfather->_col = RED;
                    }
                    break;
                }
            }
            else // 叔叔在左，父亲在右
            {
                Node* uncle = grandfather->_left;
                // 情况一：叔叔存在且为红
                if (uncle && uncle->_col == RED)
                {
                    parent->_col = uncle->_col = BLACK;
                    grandfather->_col = RED;
                    // 继续向上处理
                    cur = grandfather;
                    parent = cur->_parent;
                }
                else // 情况二：叔叔不存在或叔叔存在且为黑
                {
                    if (cur == parent->_right) // 右右：左旋
                    {
                        RotateL(grandfather);
                        parent->_col = BLACK;
                        grandfather->_col = RED;
                    }
                    else // 右左：右左双旋
                    {
                        RotateR(parent);
                        RotateL(grandfather);
                        cur->_col = BLACK;
                        grandfather->_col = RED;
                    }
                    break;
                }
            }
        }

        _root->_col = BLACK; // 不废话，根直接设为黑色
        return true;
    }

    void LevelOrder()
    {
        queue<Node*> que;
        if (_root != NULL) que.push(_root);
        while (!que.empty())
        {
            int size = que.size();
            for (int i = 0; i < size; i++)
            {
                Node* node = que.front();
                que.pop();
                cout << node->_kv.first << ' ';
                if (node->_left) que.push(node->_left);
                if (node->_right) que.push(node->_right);
            }
            cout << endl;
        }
    }

    void Inorder()
    {
        _Inorder(_root);
        cout << endl;
    }

    void Height()
    {
        cout << "最长路径：" << _MaxHeight(_root) << endl;
        cout << "最短路径：" << _MinHeight(_root) << endl;
    }

    bool IsRBTree()
    {
        if (_root == nullptr) return true; // 空树也是红黑树

        if (_root->_col != BLACK) // 检查根结点
        {
            cout << "错误：根结点不为黑色" << endl;
            return false;
        }

        // 获取任一条路径的黑色结点的个数，作为比较的基准值
        size_t blackCount = 0;
        Node* cur = _root;
        while (cur)
        {
            if (cur->_col == BLACK) ++blackCount;
            cur = cur->_left;
        }

        // 检查是否满足红黑树的性质，k用来记录路径中黑色结点的个数
        size_t k = 0;
        return _IsRBTree(_root, k, blackCount);
    }

private:
    bool _IsRBTree(Node* root, size_t k, const size_t blackCount)
    {
        // 走到空，判断黑色结点个数和基准值是否相等
        if (root == nullptr)
        {
            if (k != blackCount)
            {
                cout << "错误：每条路径中黑色结点的个数不同" << endl;
                return false;
            }
            return true;
        }

        if (root->_col == BLACK) ++k;
        
        // 检查是否有连续的红色结点
        Node* parent = root->_parent;
        if (parent && parent->_col == RED && root->_col == RED)
        {
            cout << "错误：有连续的红结点" << endl;
            return false;
        }

        return _IsRBTree(root->_left, k, blackCount) && _IsRBTree(root->_right, k, blackCount);
    }

    void _Inorder(Node* root)
    {
        if (root == nullptr) return;
        _Inorder(root->_left);
        cout << root->_kv.first << ' ';
        _Inorder(root->_right);
    }

    int _MaxHeight(Node* root)
    {
        if (root == nullptr) return 0;
        int leftHeight = _MaxHeight(root->_left);
        int rightHeight = _MaxHeight(root->_right);
        return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
    }

    int _MinHeight(Node* root)
    {
        if (root == nullptr) return 0;
        int leftHeight = _MinHeight(root->_left);
        int rightHeight = _MinHeight(root->_right);
        return leftHeight < rightHeight ? leftHeight + 1 : rightHeight + 1;
    }

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

        parent->_right = subRL;
        if (subRL) subRL->_parent = parent; // subRL有可能是空树，需要if判断

        Node* ppNode = parent->_parent; // 提前记录祖先，后面用来连接新的parent
        subR->_left = parent;
        parent->_parent = subR;

        if (parent == _root) // 如果parent就是根结点，那么新的根是subR
        {
            _root = subR;
            _root->_parent = nullptr;
        }
        else // 否则需要祖先来连接新的parent(即subR)，注意判断左右
        {
            if (parent == ppNode->_left)
            {
                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 (parent == _root)
        {
            _root = subL;
            _root->_parent = nullptr;
        }
        else
        {
            if (parent == ppNode->_left)
            {
                ppNode->_left = subL;
            }
            else
            {
                ppNode->_right = subL;
            }
            subL->_parent = ppNode;
        }
    }

private:
	Node* _root;
};
世真
关注
专栏目录
红黑树插入调整过程（一张图搞定）
Further_Y的博客
08-18 303
插入节点为z 父节点为z.p 祖父节点为z.p.p 叔叔节点为y（叔叔节点是插入节点祖父节点的另一个子节点） 插入操作： 插入节点置为红色，当插入位置为根节点时，改成黑色即可，插入位置的父节点为黑色时，直接插入。 当插入位置的父节点为红色时，分两种情况讨论 1、插入节点的父节点为祖父节点的左节点 此处再分三种情况 1.1叔叔节点为红色（y.color==red） 将父节点和叔叔节点置为黑色z.p=black,y...
游戏行业之红黑树（c++详细）
qq_48432584的博客
10-23 903
红黑树之c++实现
红黑树插入操作分析及代码实现
踏雁寻花
03-19 1763
首先说一下红黑树的五个性质： 1、每个结点要么是红色的，要么是黑色的； 2、根结点是黑色的； 3、每个叶结点，即空结点(NIL)是黑色的； 4、如果一个结点是红色的，那么它的两个子结点都是黑色的； 5、对每个结点，从该结点到其子结点的所有路径上包含相同数目的黑结点。 在对红黑树插入的时候，我们一般都会插入红色的结点，红黑树的插入主要有这几种情况： 1、插入的是根结点；
红黑树的实现原理
weixin_30376163的博客
09-01 316
注:本文所有内容均翻译自维基百科，部分内容为原创。 强烈建议阅读文章末尾的参考资料。 一、概述 红黑树是自平衡的二叉搜索树，是计算机科学中的一种数据结构。 平衡是指所有叶子的深度基本相同(完全相等的情况并不多见,所以只能趋向于相等) 。 二叉搜索树是指,节点最多有两个儿子，且左子树中所有节点都小于右子树。 树中节点有改动时,通过调整节点顺序（旋转）,重新给节点染色,使节点满足某种特...
红黑树插入代码实现（框架）
m0_51641706的博客
05-21 392
前言：个人观点，所谓手撕红黑树插入，就是记性好而已，理解并背下框架即可。插入代码量在200行左右 红黑树特征 root是黑色的 若一个节点是红色的，则它两个孩子是黑色的。（没有连续的红节点） ps：黑色节点可以连续 每条路径的黑色节点数量相等（一条路径指从root到某一个叶子节点） 最长路径不超过最短路径的2倍 红黑树插入流程 这是总体流程，如果可以看着这张图写出红黑树插入，后面就不用看了。 ps:强调两点 1.插入的节点一定是红颜色的，因为要保证每条路径的黑色节点个数相同，如果插入了一个黑色的节.
C++红黑树
~
03-26 6722
C++红黑树零、前言一、红黑树的概念及性质二、红黑树结点的定义三、红黑树的插入操作1、变色处理2、单旋+变色3、双旋+变色4、插入实现四、红黑树的验证五、红黑树的删除六、红黑树与**AVL**树的比较 零、前言 本章继AVL树后继续讲解学习C++中另一个二叉搜索树–红黑树 一、红黑树的概念及性质 概念： 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长
IT笔试面试--红黑树详细解析，代码+图解
04-14
在 C++ STL 中，很多部分（包括 set, multiset, map, multimap）应用了红黑树的变体（SGI STL 中的红黑树有一些变化，这些修改提供了更好的性能，以及对 set 操作的支持）。 红黑树的基本性质有五条： 1. 节点是...
数据结构-史上最强图解红黑树
02-06
红黑树是一种自平衡二叉搜索树，在实际应用中，它广泛用于Linux内核、Java的TreeMap和TreeSet数据结构以及C++的STL中。红黑树的设计旨在保持树的平衡，但是与AVL树不同，它追求的不是绝对的平衡，而是通过放弃一定的...
红黑树的插入操作实现与代码分析
红黑树的特点在于它能够保持良好的平衡，确保插入、删除等操作的最坏情况时间复杂度为O(log n)，从而保证了基本动态集合操作的高效性。 ## 1.1 什么是红黑树 红黑树是一种二叉查找树，它具有以下特性： - 每个节点...
数据结构之二叉搜索树详解（附C++代码实现查找、插入、删除操作）
hestyle的博客
04-18 1651
  最近在分析分析红黑树时，感觉上来就挑最难的树结构之一进行分析，难度太大，所以特意写这篇二叉搜索树分析的博客作为铺垫。那么为啥挑二叉搜索树进行分析捏？其实红黑树也是一种更为复杂的二叉搜索树，建议阅读一下我的另外一篇博客 数据结构之二叉树、AVL树、红黑树、Trie树、B树、B+树、B*树浅析 。为了帮助大家理解红黑树，先写这篇博客分析二叉搜索树。下面将主要分析二叉搜索树的查找、插入、删除三种操作...
红黑树的C++实现（只实现插入操作）
11-04
实现了红黑树的插入操作，删除操作太复杂未实现。数据量比较大，根据需要可在main中修改测试数据
红黑树的调整代码实现
m0_50619372的博客
06-27 162
红黑树的操作和其他树形结构一样，包括查找、插入、删除等。查找过程和二叉查找树一样，比较简单，这里不再赘述。这里着重介绍插入和删除操作。 调整策略 定义空节点 利用更改函数的属性，使他在函数之前执行。空节点颜色定义为黑色。 旋转操作 ： 旋转操作分为左旋和右旋 左旋 ： 以某个节点作为支点（旋转节点），其右子节点变为旋转节点的父节点，右子节点的左子节点变为旋转节点的右子节点 右旋： 以某............
红黑树及插入代码
IS_MOKE的博客
05-20 243
红黑树在插入任何一个节点之前就已经是红黑树了，用数学的归纳法，所以插入一个节点只能是红的（红色不改变黑高）把代码中的所有x改为y，y改为x，left改为right，right改为left；红黑树没有对相同的节点处理：对于业务场景丢弃或者是加一个eps。场景：hashmap、cfs、epoll、定时器、nginx。强查找：红黑树、hash、b/b++树、跳表。红黑树性质被破坏时，就会产生旋转。插入的所有的值都会在最底层。
C语言经典算法之红黑树的调整（伪代码）
最新发布
weixin_56154577的博客
02-14 778
在C语言中实现红黑树时，插入和删除操作后需要进行特定的调整以保持红黑树的性质。
红黑树insert操作
长期更新自学笔记
09-13 309
这样就保持了局部和原来一样的红黑树的性质，所以全局也是保持了性质，调整完成！其实这种情况很好解决，把B和C旋转到一条线上，就可以使用情况2的方法解决了。在情况3中，使用交换颜色和右旋转的方法，也会产生连续两个红色节点的问题。
红黑树插入操作和删除的代码
Faded0104的博客
07-15 393
头文件：RBTree.h #pragma once typedef int Type; typedef enum{RED = 0,BLACK}COLOR; typedef struct RBNode { COLOR color; Type data; struct RBNode *parent; struct RBNode *leftChild; struct RBNode *r
红黑树调整情景规则
cooling_time的博客
05-05 225
前提：插入节点使用红色。 设置：祖父节点为PP，父节点为P，叔叔节点为U，插入节点为I。 1. 红黑树为空树 操作：直接插入。 2. 插入的key已经存在 操作：更新当前节点的值为插入节点的值。 3. 插入节点的父节点为黑色 操作：由于插入节点是红色，不影响红黑树自平衡，直接插入即可不需要自平衡 4. 插入节点为红节点。 4.1 U节点存在并且为红色 （黑红红） 操作 ：将PP节点和P节...
红黑树的添加与调整算法
qq_42331828的博客
05-29 372
文章目录一、红黑树的应用二、红黑树的实现红黑树的性质红黑树的定义二叉树的旋转节点的添加红黑树的调整 一、红黑树的应用 例如map的底层实现，nginx，定时器，以及cfs cfs就是用红黑树存储进程的集合，把调度的时间，作为一个key值，每一次从他的左下角这棵树开始查找。 还有我们的内存管理，是用一颗红黑树树去管理的，红黑树会去自动平衡，树高会降低，更利于查找，不会出现一条树的情况（链表） 一块大内存，分小内存，会把那些内存块用红黑树去存储，一块内存有两种存储方法，一种是以起始位置加长度，第二种用开始位置
红黑树是什么?红黑树如何调整?
Strangerrainyday的博客
09-03 825
概述; 红黑树（Red Black Tree） 是一种自平衡二叉查找树,是在计算机科学中用到的一种数据结构,典型的用途是实现关联数组. 红黑树是在1972年由Rudolf Bayer发明的,当时被称为平衡二叉B树（symmetric binary B-trees）.后来,在1978年被 Leo J. Guibas 和 Robert Sedgewick 修改为如今的“红黑树”. 红黑树是一种特化的AVL树（平衡二叉树）,都是在进行插入和删除操作时通过特定操作保持二叉查找树的平衡,从而获得较高的查找性能. 它
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

世真

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值