探索数据结构：红黑树的分析与实现

已于 2024-08-19 21:00:58 修改
阅读量754 收藏 20
点赞数 11
分类专栏： 数据结构与算法：C/C++全解析 文章标签： 数据结构 c++ 开发语言 红黑树 红黑树的插入 红黑树的删除
于 2024-08-19 21:00:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Bettysweetyaaa/article/details/141334734
版权

✨✨ 欢迎大家来到贝蒂大讲堂✨✨

🎈🎈养成好习惯，先赞后看哦~🎈🎈

所属专栏：数据结构与算法
贝蒂的主页：Betty’s blog

1. 红黑树的介绍

1.1. 红黑树的引入

我们前面学习了AVL树，知道其本质是通过旋转操作来确保每个节点的左右子树高度差不超过 1，以此解决数据有序或接近有序时二叉搜索树退化为单边树而导致查找效率低下的问题。然而，当插入数据量过大时，频繁的旋转操作同样会使效率降低。为应对这一问题，就有人提出了一种更为特殊的树——红黑树。

红黑树是一种自平衡的二叉查找树，查找效率高。它由Rudolf Bayer于 1978 年发明，当时被称为平衡二叉B树。后来，在 1978 年，Leo J. Guibas 和 Robert Sedgewick对其进行了修改，形成了如今的红黑树。

1.2. 红黑树的特点

首先，红黑树属于二叉搜索树，其特点是在每个节点额外增加了一个存储位用于记录节点的颜色，该颜色可以是 RED，也可以是 BLACK。 并且红黑树通过对任意一条从根到叶子的简单路径上颜色的约束，能够保证最长路径不会超过最短路径的二倍，从而实现近似平衡，减少旋转的效果。其具体特点如下：

  1. 节点颜色只有黑色与红色两种颜色。
  2. 根节点一定是黑色。
  3. 空节点null一定为黑色，并且在红黑树中认为null节点才是叶子节点。
  4. 红色节点的子节点和父节点一定为黑色。
  5. 从任一节点到叶子节点的所有路径都包含相同数目的黑色节点。

img

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

具体来说，根据上述规则可以得出最短路径即为全是黑节点的路径，最长路径则是一个红节点接着一个黑节点。当从根节点到叶子节点的路径上黑色节点数量相同时，最长路径恰好是最短路径的两倍。

2. 红黑树的功能

以下是红黑树常见的功能：

  1. 红黑树的插入。
  2. 红黑树的查找。
  3. 红黑树的删除。

3. 红黑树的结构

3.1. 红黑树的节点

红黑树的节点本质与二叉搜索树的节点差不多，所以肯定有三个成员变量：左子树_left，右子树_right，键值_kv，并且键值我们采用KV模型的形式。并且还有一个表示节点颜色的变量_col，以及一个父节点_parent。并且为了增加代码的可读性，我们可以定义一个枚举来表示颜色。当然为了适配不同的类型，我们同样需要定义一个模版.。

template<class K,class V>
struct RBTreeNode
{
	RBTreeNode(const pair<K,V>& kv = pair<K,V>(), Color col = RED)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _kv(kv)
		, _col(col)//默认为红节点
	{}
	RBTreeNode<K, V>* _left;//左子树
	RBTreeNode<K, V>* _right;//右子树
	RBTreeNode<K, V>* _parent;//父节点
	pair<K, V> _kv;//键值
	Color _col;//颜色
};

为什么插入新节点的颜色默认是红色而不是黑色呢？

  • 若插入的是黑色节点，会导致插入路径的黑色节点数量增加，破坏原每条路径黑色节点数量相同的平衡特性，需要对所有路径进行调整，非常麻烦。
  • 若插入节点为红色，则需分情况讨论。当插入节点的父节点为黑色时，不会违反红黑树规则，无需处理。而当插入节点的父节点为红色时，由于红黑树不能有连续的红色节点，此时就需要进行调整。但是因为只需调整该路径，所以明显更简单。

综上所述，红黑树插入节点默认设为红色能在一定程度上减少违反规则的情况，同时降低调整树结构的复杂性。

3.2. 红黑树

然后我们就可以通过节点来定义红黑树，并将根节点初始化为空。

template<class K,class V>
class RBTree
{
	typedef RBTreeNode<K, V> Node;
public:
	//...具体功能
private:
	Node* _root = nullptr;//根节点
};

4. 红黑树的初始化与销毁

4.1. 构造函数/拷贝构造/赋值重载

首先我们直接定义一个无参的构造函数，因为我们在定义拷贝构造之后编译器就不会在生成默认的构造函数了。

RBTree()
{}

之后我们可以利用递归来实现一个拷贝构造函数。

RBTree(const RBTree<K, V>&t)
{
    _root = copy(t._root);
}
Node* copy(Node* root)
{
    // 如果原始节点为空，直接返回空指针
    if (root == nullptr)
    {
        return nullptr;
    }
    // 为新节点分配内存并拷贝原始节点的值
    Node* newnode = new Node(root->_kv);
    // 递归拷贝左子树
    newnode->_left = copy(root->_left);
    // 递归拷贝右子树
    newnode->_right = copy(root->_right);
    // 将新节点的父节点指针置为空
    newnode->_parent = nullptr;
    // 拷贝原始节点的颜色信息
    newnode->_col = root->_col;
    // 如果新节点的左子节点存在，设置其父节点为新节点
    if (newnode->_left)
    {
        newnode->_left->_parent = newnode;
    }
    // 如果新节点的右子节点存在，设置其父节点为新节点
    if (newnode->_right)
    {
        newnode->_right->_parent = newnode;
    }
}

最后我们通过一个简单的方式实现赋值重载——通过形参调用拷贝构造出一个临时变量，然后交换this所指向的变量，这样原本this所指向的对象出了作用域就会销毁，间接实现了实现赋值重载。

RBTree<K, V> operator =(const RBTree<K, V> t)
{
    this->swap(_root, t._root);
    return *this;
}

4.2. 析构函数

析构函数需要借助递归释放所有节点，而为了方便我们传参我们可以定义子函数来帮助我们解决。

~RBTree()
{
    Destroy(_root);
}
void Destroy(Node*& root)
{
	if (root == nullptr)
	{
		return;
	}
	//递归销毁左子树
	Destroy(root->_left);
	//递归销毁右子树
	Destroy(root->_right);
	//销毁根节点
	delete root;
	root = nullptr;
}

5. 红黑树的功能实现

不论是红黑树的插入还是删除操作都需要用到旋转操作，如果你还不知道旋转操作的具体内容可以先看看这篇文章——AVL树。当然具体的旋转操作也看到也有细微的区别，因为红黑树并不存在平衡因子，但是主体思路肯定不会改变。

5.1. 红黑树的插入

向红黑树进行插入，首先是先找到需要插入的位置，这个逻辑与二叉搜索树类似，这里就不在赘述。找到之后插入默认的红节点，此时就可以分为五种情况来讨论：

为了方便叙述，我们首先假设插入节点为cur，其父节点为parent，其父节点的兄弟节点为uncle，其父节点的父节点为grandfather。

其中下面图示抽象的情况可能是红黑树整体，也可能是红黑树的某个子树。

5.1.1. 情况一

第一种情况就是第一次插入，也就是插入根节点，此时根据性质1我们只需要将对应颜色从RED改为BLACK即可。

5.1.2. 情况二

第二种情况就是插入节点的父节点是黑节点，符合红黑树的定义，所以此时也不需要做任何调整，直接插入即可。

5.1.3. 情况三

第三种情况就是插入节点的父节点parent是红节点，其父节点的兄弟节点uncle也为红节点，并且祖父节点grandfather是黑节点。如下图：

并且为了方便我们之后的null节点不画出，默认存在。其中a，b，c，d，e五颗子树中黑色节点数量都相同。

img

这种情况的调整方法也很简单，直接将parent与uncle变为黑色，grandfather变为红色即可。

img

当然镜像对称后调整方式也是同理，所以这里就不在赘述。

注意：祖父节点grandfather可能不是根节点，当祖父节点parent变为红色节点时可能会引起上面节点的冲突(祖父节点的父节点也为红色)，这时就需要循环调整。并且如果祖父节点grandfather是根节点，该调整方法会将根节点变为红节点，所以这时需要将根节点改回黑节点。

img

5.1.4. 情况四

第四种情况严格来说又可以分为两种情况：一种是cur为红色，parent也为红色，grandfather也为黑色，但是uncle不存在。如下图：

其中a，b，c三颗子树中除了null外没有黑色节点。

img

还有一种是cur为红色，parent也为红色，grandfather也为黑色，uncle存在且为黑色·。如下图：

其中a，b，c三颗子树中黑色节点的数量比d，e两棵子树黑色节点的数量多1。

img

当然这种情况肯定不是新插入红色节点造成的，因为一旦cur是新插入节点，那么a，b两棵子树高度为0，没有任何节点，肯定无法满足黑色节点数量比c，d，e多1这个条件。所以这种情况肯定是子树从情况三变换得来的。

针对以上两种情况我们都先右单旋，再将parent变为黑色，grandfather变为红色。当然镜像对称后调整方式也是同理，将旋转改为左单旋转即可，所以这里就不在赘述。

img

img

并且调整完毕后该子树的根节点是黑节点，所以也并不需要往上调整。

5.1.5. 情况五

最后一种情况与第四种情况条件相同：就是cur为红色，parent也为红色，grandfather也为黑色，uncle不存在/存在且为黑色。只不过插入节点位置有所区别。

其中a，b，c三颗子树中除了null外没有黑色节点。

img

其中a，b，c三颗子树中黑色节点的数量比d，e两棵子树黑色节点的数量多1。同样与情况四相同，这种情况不可能是插入造成的，一定是由情况三变化而来。

img

针对以上两种情况我们都先左右双旋，最后将cur变为黑色，grandfather变为红色。当然镜像对称后调整方式也是同理，将旋转改为右左双旋即可，所以这里就不在赘述。

img

img

并且调整完毕后该子树的根节点是黑节点，所以也并不需要往上调整。

默认插入节点为红色，最后我们对插入操作总结如下：

  1. 情况一：新插入的节点为根节点，将其颜色设置为黑色。
  2. 情况二：新插入节点的父节点为黑色，无需调整。
  3. 情况三：父节点和叔父节点均为红色，将父节点和叔父节点改为黑色，祖父节点改为红色，然后以祖父节点为当前节点继续进行调整，如果祖父节点是根节点则停止调整并将其改为黑色。
  4. 情况四：父节点为红色，叔父节点不存在/存在为黑色，当前节点是父节点的左子节点且父节点又是祖父节点的左子节点/当前节点是父节点的右子节点且父节点又是祖父节点的右子节点。先进行左单旋/右单旋，然后将父节点改为黑色，祖父节点改为红色。
  5. 情况五：父节点为红色，叔父节点不存在/存在为黑色，当前节点是父节点的左子节点且父节点又是祖父节点的右子节点/当前节点是父节点的右子节点且父节点又是祖父节点的左子节点。先进行左右双旋/右左双旋，然后将当前节点改为黑色，祖父改为红色。
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);
    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
            {
                //情况四：叔叔不存在/存在且为黑，且cur在parent的左侧
                if (cur == parent->_left)
                {
                    //     g  
                    //   p   u
                    // c 
                    RotateR(grandfather);
                    parent->_col = BLACK;
                    grandfather->_col = RED;
                }
                else//情况五：叔叔不存在 / 存在且为黑，cur在parent的右侧
                {
                    //     g
                    //   p   u
                    //     c
                    RotateLR(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
            {
                //情况四：叔叔不存在/存在且为黑，且cur在parent的左侧
                if (cur == parent->_right)
                {
                    //    g
                    //  u   p
                    //        c
                    RotateL(grandfather);
                    parent->_col = BLACK;
                    grandfather->_col = RED;
                }
                else // 情况五：叔叔不存在 / 存在且为黑，cur在parent的右侧
                {
                    //    g
                    //  u   p
                    //    c
                    RotateRL(grandfather);
                    cur->_col = BLACK;
                    grandfather->_col = RED;
                }
                //这时该子树的根节点变为黑色，不需要继续调整
                break;
            }
        }
        
    }
    //防止情况三改到根节点变为红色
    _root->_col = BLACK;
    return true;
}
void RotateR(Node* parent)
{
    Node* cur = parent;
    Node* subL = parent->_left;
    Node* subLR = subL->_right;
    parent->_left = subLR;
    if (subLR)
        subLR->_parent = parent;
    subL->_right = parent;
    Node* ppNode = parent->_parent;
    parent->_parent = subL;
    if (parent == _root)
    {
        _root = subL;
        _root->_parent = nullptr;
    }
    else
    {
        if (ppNode->_left == parent)
        {
            ppNode->_left = subL;
        }
        else
        {
            ppNode->_right = subL;
        }
        subL->_parent = ppNode;
    }
}
void RotateL(Node* parent)
{
    Node* subR = parent->_right;
    Node* subRL = subR->_left;
    parent->_right = subRL;
    if (subRL)
        subRL->_parent = parent;

    subR->_left = parent;
    Node* ppNode = parent->_parent;

    parent->_parent = subR;

    if (parent == _root)
    {
        _root = subR;
        _root->_parent = nullptr;
    }
    else
    {
        if (ppNode->_right == parent)
        {
            ppNode->_right = subR;
        }
        else
        {
            ppNode->_left = subR;
        }
        subR->_parent = ppNode;
    }
}
void RotateLR(Node* parent)
{
    RotateL(parent->_left);
    RotateR(parent);
}
void RotateRL(Node* parent)
{
    RotateR(parent->_right);
    RotateL(parent);
}

5.2. 红黑树的查找

红黑树的查找的逻辑本质与二叉搜索树的查找逻辑相同，所以这里就不在赘述。

Node* Find(const K& val)
{
    Node* cur = _root;
    while (cur)
    {
        if (cur->_kv.first > val)
        {
            //左子树中查找
            cur = cur->_left;
        }
        else if (cur->_kv.first < val)
        {
            //右子树中查找
            cur = cur->_right;
        }
        else
        {
            //找到了
            return cur;
        }
    }
    return nullptr;
}

5.3. 红黑树的删除

删除红黑树的逻辑明显比插入逻辑更加复杂，但是总体逻辑又与AVL树与二叉搜索树类似，首先第一步找到待删除节点，如果待删除节点的左右子树都不为空，可以采用伪删除法，即寻找到左子树的最右节点(左子树的最大值)，或者是右子树的最左节点(右子树的最小值)，然后赋值，转换为在其左子树或者右子树删除节点，保证待删除节点的左右子树至少有一个为空。第二步进行调整，删除该节点可能会破坏红黑树的性质所以这时需要调整。第三步删除节点并重新链接。

第一步与第三步都非常简单，我们接下来重点讨论第三步。

为了方便描述我们将待删除节点称为delete，其父节点称为parent，其兄弟节点称为brother，其兄弟节点的左右节点分别称为broLeft与broRight。

看图需知：

  1. 如果parent为蓝色，表示parent可能为黑色也可能为红色。
  2. 如果broLeft或broRight为蓝色，表示broLeft或broRight可能为黑色也可能为红色，也可能为null节点。
  3. 如果broLeft或broRight为黑色，表示broLeft或broRight可能为黑色也可能为null节点。
  4. 绿色长方形表示高度未知的子树，也可以为null节点。

下面图示我们将按照delete节点在parent节点左侧的形式讨论，根据镜像对称delete节点在parent节点右侧只需对称操作即可，所以这里就不在赘述。

首先如果delete节点为红色，因为至少有一个空节点，那么另一个子节点既不能为红色也不可能为黑色，此时直接删除即可。

其次如果delete节点为黑色，且有一个孩子节点，那么这个孩子节点一定为红色，(parent与brother不都为红色)否则会破坏性质5。这种情况也只需重新链接不需要调整，然后将该孩子节点改为黑色。

imgimg

接下来我们将讨论delete节点为黑色且没有孩子节点的情况。

  1. 情况一：兄弟节点为红色。

因为兄弟节点为红色，其父节点一定为黑色，所以对于这种情况我们只需要对parent节点进行一次左旋转，再将brother变为黑色，parent变为红色。再重新更新brother节点，继续分析原删除节点delete，将情况一转换为情况二，三，四。

img

img

  1. 情况二：兄弟节点为黑色，且其左右孩子为空或者都为黑色。

对于这种情况我们需要将brother变为红色，然后根据parent节点颜色继续分析，如果parent节点为红色，只需要将其变为黑色即可，调整结束；如果parent节点为黑色，那么delete节点被删除后，原来该子树有两个黑色节点变为一个，性质5被破坏，将parent节点当做删除节点往上更新或者遇见根节点直接停止，将情况二转换为情况一，二，三，四。

img

img

  1. 情况三：兄弟节点为黑色，且其左孩子是红色结点，右孩子是黑色结点或为空。

这种情况一定不是第一次调整，因为如果是第一次调整此时根本不平衡。对应这种情况我们需要对brother节点进行一次右单旋，然后再将brother结点变为红色，broLeft变为黑色，最后更新brother节点，再对delete节点进行调整，情况三就转换成了情况四。

img

img

  1. 情况四：兄弟节点为黑色，且其右孩子是红色结点。

对于这种情况我们先将parent节点进行一次左单旋，然后将parent的颜色赋值给brother，再将parent的颜色变为黑色，最后将broRight变为黑色，此时红黑树的调整一定结束。

img

img

最后删除节点如果是根节点直接删除再将左子树或者右子树的根节点变黑，当做新的根节点。如果没有左右子树都为空，那就将根节点_root置为空。

最后我们来总结

  1. 如果删除节点为红色，直接删除。
  2. 如果删除节点为黑色且有一个子节点，直接删除再链接，并将该子节点改为黑色。
  3. 如果删除节点为黑色且没有子节点，可以分为以下四种情况：
  • 情况一：兄弟节点为红色。先对parent左单旋，再将brother变为黑色，将parent变为红色，再对待删除结点delete进行情况分析，情况一就转换成了情况二、三或四。
  • 情况二：兄弟节点为黑色，且其左右孩子为空或者都为黑色。我们直接将brother变成红色，若parent是红色，将parent变为黑色后调整结束；若parent是黑色，则需将parent结点当作下一次调整时的结点进行分析直至根节点，情况二就转换成了情况一，二、三或四。
  • 情况三：兄弟节点为黑色，且其左孩子是红色结点，右孩子是黑色结点或为空。先将brother右单旋，再将brother变为红色，broLeft变为黑色，再对待删除结点delete进行情况分析，将情况三转换成情况四。
  • 情况四：兄弟节点为黑色，且其右孩子是红色结点。先将parent左单旋，然后将parent的颜色赋值给brother，再将parent变为黑色，最后将brotRight变为黑色，此时红黑树的调整一定结束。

思考题：为什么删除节点为黑色且没有子节点的四种情况的调整方法一定能使红黑树调整成功？

我们知道这四种调整方法一共有三个"出口"，分别为：(1)情况二调整后parent为红色，(2)情况二parent为黑色调整到根节点，(3)调整完情况四。所以问题就成功转换为经过任意三个"出口"结束之后，为什么红黑树一定调整成功。

  1. 如果从1号"出口"结束：一个子节点被删除后，因为使parent变为黑色，另一个子节点变为红色，所以此时这颗子树的路径上的黑色节点数没减少，调整成功。
  2. 如果从2号"出口"结束：一定是只经过情况二，因为如果是从情况一转换过来的情况二，那parent一定是红色就会从1号"出口"结束。如果只经过情况二那么每次操作都会使上层的一颗子树(非父节点所在子树)黑色节点数减一，最后更新到根节点整颗红黑树根节点到叶子节点的黑色节点数比原来少1，调整成功。
  3. 如果从3号"出口"结束：经过第四种调整方式，被删除一侧的黑色节点数增一，无论是从第一，二，三删除节点后都会使被删除一侧减一，所以经过情况四调整成功。

思考题：为什么删除节点为黑色且没有子节点的四种情况的调整方法不会造成死循环？

因为情况三一定会被转换为情况四，情况四一定会调整成功，所以情况三与情况四一定不会死循环。而情况一与情况二也可能转换为情况三与情况四这时也不会死循环。但会不会出现情况一与情况二一直互相循环的情况呢？其实不会的，因为一旦从情况一转换为情况二，此时父节点parent为红色，一定会结束。

//删除函数
bool Erase(const K& key)
{
    //(一)找到删除节点
    Node* cur = Find(key);
    //未找到返回false
    if (cur == nullptr)
    {
        return false;
    }
    //记录父节点
    Node* parent = cur->_parent;
    //用于标记实际的待删除结点及其父结点
    Node* delParent = nullptr;
    Node* delCur = nullptr;
    if (cur->_left == nullptr) //待删除结点的左子树为空
    {
        if (cur == _root) //待删除结点是根结点
        {
            _root = _root->_right; //让根结点的右子树作为新的根结点
            if (_root)
            {
                _root->_parent = nullptr;
                _root->_col = BLACK; //根结点为黑色
            }
            delete cur; //删除原根结点
            return true;
        }
        else
        {
            delParent = parent; //标记实际删除结点的父结点
            delCur = cur; //标记实际删除的结点
        }
    }
    else if (cur->_right == nullptr) //待删除结点的右子树为空
    {
        if (cur == _root) //待删除结点是根结点
        {
            _root = _root->_left; //让根结点的左子树作为新的根结点
            if (_root)
            {
                _root->_parent = nullptr;
                _root->_col = BLACK; //根结点为黑色
            }
            delete cur; //删除原根结点
            return true;
        }
        else
        {
            delParent = parent; //标记实际删除结点的父结点
            delCur = cur; //标记实际删除的结点
        }
    }
    else //待删除结点的左右子树均不为空
    {
        //替换法删除
        //寻找待删除结点右子树当中key值最小的结点作为实际删除结点
        Node* minParent = cur;
        Node* minRight = cur->_right;
        while (minRight->_left)
        {
            minParent = minRight;
            minRight = minRight->_left;
        }
        cur->_kv = minRight->_kv; //将待删除结点的键值改为minRight的键值
        delParent = minParent; //标记实际删除的父节点
        delCur = minRight; //标记实际删除的结点
    }
    //记录待删除结点及其父结点，便于后面删除
    Node* del = delCur;
    Node* delP = delParent;
    //(二)调整红黑树
    AdjustRBTree(delCur, delParent);
    //(三)进行实际删除
    DeleteNode(del, delP);
    return true;
}
void DeleteNode(Node* del, Node* delP)
{
    if (del->_left == nullptr) //实际删除结点的左子树为空
    {
        if (del == delP->_left) //实际删除结点是其父结点的左孩子
        {
            delP->_left = del->_right;
            //指向父节点
            if (del->_right)
                del->_right->_parent = delP;
        }
        else //实际删除结点是其父结点的右孩子
        {
            delP->_right = del->_right;
            if (del->_right)
                del->_right->_parent = delP;
        }
    }
    else //实际删除结点的右子树为空
    {
        if (del == delP->_left) //实际删除结点是其父结点的左孩子
        {
            delP->_left = del->_left;
            if (del->_left)
                del->_left->_parent = delP;
        }
        else //实际删除结点是其父结点的右孩子
        {
            delP->_right = del->_left;
            if (del->_left)
                del->_left->_parent = delP;
        }
    }
    delete del; //实际删除结点
}
void AdjustRBTree(Node* delCur, Node* delParent)
{
    if (delCur->_col == BLACK) //删除的是黑色结点
    {
        if (delCur->_left) //待删除结点有一个红色的左孩子（不可能是黑色）
        {
            delCur->_left->_col = BLACK; //将这个红色的左孩子变黑即可
        }
        else if (delCur->_right) //待删除结点有一个红色的右孩子（不可能是黑色）
        {
            delCur->_right->_col = BLACK; //将这个红色的右孩子变黑即可
        }
        else //待删除结点的左右均为空
        {
            while (delCur != _root) //可能一直调整到根结点
            {
                if (delCur == delParent->_left) //待删除结点是其父结点的左孩子
                {
                    Node* brother = delParent->_right; //兄弟结点是其父结点的右孩子
                    //情况一：brother为红色
                    if (brother->_col == RED)
                    {
                        delParent->_col = RED;
                        brother->_col = BLACK;
                        RotateL(delParent);
                        //需要继续处理
                        brother = delParent->_right; //更新brother
                    }
                    //情况二：brother为黑色，且其左右孩子都是黑色结点或为空
                    if (((brother->_left == nullptr) || (brother->_left->_col == BLACK))
                        && ((brother->_right == nullptr) || (brother->_right->_col == BLACK)))
                    {
                        brother->_col = RED;
                        if (delParent->_col == RED)
                        {
                            delParent->_col = BLACK;
                            break;
                        }
                        //需要继续处理
                        delCur = delParent;
                        delParent = delCur->_parent;
                    }
                    else
                    {
                        //情况三：brother为黑色，且其左孩子是红色结点，右孩子是黑色结点或为空
                        if ((brother->_right == nullptr) || (brother->_right->_col == BLACK))
                        {
                            brother->_left->_col = BLACK;
                            brother->_col = RED;
                            RotateR(brother);
                            //需要继续处理
                            brother = delParent->_right; //更新brother
                        }
                        //情况四：brother为黑色，且其右孩子是红色结点
                        brother->_col = delParent->_col;
                        delParent->_col = BLACK;
                        brother->_right->_col = BLACK;
                        RotateL(delParent);
                        break; //情况四执行完毕后调整一定结束
                    }
                }
                else //delCur == delParent->_right //待删除结点是其父结点的右孩子
                {
                    Node* brother = delParent->_left; //兄弟结点是其父结点的左孩子
                    //情况一：brother为红色
                    if (brother->_col == RED) //brother为红色
                    {
                        delParent->_col = RED;
                        brother->_col = BLACK;
                        RotateR(delParent);
                        //需要继续处理
                        brother = delParent->_left; //更新brother
                    }
                    //情况二：brother为黑色，且其左右孩子都是黑色结点或为空
                    if (((brother->_left == nullptr) || (brother->_left->_col == BLACK))
                        && ((brother->_right == nullptr) || (brother->_right->_col == BLACK)))
                    {
                        brother->_col = RED;
                        if (delParent->_col == RED)
                        {
                            delParent->_col = BLACK;
                            break;
                        }
                        //需要继续处理
                        delCur = delParent;
                        delParent = delCur->_parent;
                    }
                    else
                    {
                        //情况三：brother为黑色，且其右孩子是红色结点，左孩子是黑色结点或为空
                        if ((brother->_left == nullptr) || (brother->_left->_col == BLACK))
                        {
                            brother->_right->_col = BLACK;
                            brother->_col = RED;
                            RotateL(brother);
                            //需要继续处理
                            brother = delParent->_left; //更新brother
                        }
                        //情况四：brother为黑色，且其左孩子是红色结点
                        brother->_col = delParent->_col;
                        delParent->_col = BLACK;
                        brother->_left->_col = BLACK;
                        RotateR(delParent);
                        break; //情况四执行完毕后调整一定结束
                    }
                }
            }
        }
    }
}

6. 判断是否为红黑树

判断是否为红黑树首先得判断是否为二叉搜索树，然后判断是否满足红黑树的性质。

判断是否满足红黑树的性质，首先判断根节点是否为黑色。然后统计一条路径的节点个数，最后通过递归判断是否有连续的红色节点，以及每条路径的黑色节点是否相同。

bool IsRBTree()
{
    if (_root->_col == RED)
    {
        cout << "根节点为红节点" << endl;
        return false;
    }
    //从根节点到叶节点的黑色节点数
    int refNum = 0;
    Node* cur = _root;
    while (cur)
    {
        if (cur->_col == BLACK)
        {
            ++refNum;
        }

        cur = cur->_left;
    }

    return Check(_root, 0, refNum) && isValidBST();
}
//判断是否为二叉搜索树
bool isValidBST()
{
    return _isValidBST(_root, LONG_MIN, LONG_MAX);
}
bool _isValidBST(Node* root, long long lower, long long upper)
{
    if (root == nullptr)
    {
        return true;
    }
    if (root->_kv.first <= lower || root->_kv.first >= upper)
    {
        return false;
    }
    bool left = _isValidBST(root->_left, lower, root->_kv.first);
    bool right = _isValidBST(root->_right, root->_kv.first, upper);
    return left && right;
}
bool Check(Node* root, int blackNum, int refNum)
{
    if (root == nullptr)
    {
        //判断黑色节点数是否相同
        if (refNum != blackNum)
        {
            cout << "存在黑色节点的数量不相等的路径" << endl;
            return false;
        }

        return true;
    }
    //判断是否存在连续的红色节点
    if (root->_parent && root->_col == RED && root->_parent->_col == RED)
    {
        cout << root->_kv.first << "存在连续的红色节点" << endl;
        return false;
    }

    if (root->_col == BLACK)
    {
        blackNum++;
    }

    return Check(root->_left, blackNum, refNum)
        && Check(root->_right, blackNum, refNum);
}

7. 复杂度分析

对于红黑树的插入、查找和删除操作，其时间复杂度和空间复杂度分析如下：
时间复杂度：

  • Insert操作：平均和最坏情况下的时间复杂度均为 O ( log ⁡ n ) O(\log n) O(logn)。插入过程中需要调整红黑树的性质，可能涉及到旋转操作，但这些操作的时间是常数级，而查找插入位置的过程类似于二叉搜索树，时间复杂度为 O ( log ⁡ n ) O(\log n) O(logn)。
  • Find操作：平均和最坏情况下的时间复杂度均为 O ( log ⁡ n ) O(\log n) O(logn)。与二叉搜索树的查找过程类似，通过比较键值逐渐缩小搜索范围，每次比较都能将范围缩小一半。
  • Erase操作：平均和最坏情况下的时间复杂度均为 O ( log ⁡ n ) O(\log n) O(logn)。删除节点时需要查找节点位置，然后根据红黑树的性质进行调整和可能的旋转操作，这些操作的时间复杂度与插入操作相似。

空间复杂度：

  • Insert操作：空间复杂度为 O ( 1 ) O(1) O(1)。在插入过程中，主要的额外空间消耗在于创建新节点以及存储一些临时变量，如指针等，这些空间消耗是常数级的。
  • Find操作：空间复杂度为 O ( 1 ) O(1) O(1)。寻找过程中仅使用了少量的固定数量的指针和临时变量，没有额外的大规模空间分配。
  • Erase操作：空间复杂度为 O ( 1 ) O(1) O(1)。删除操作中的主要空间消耗在于存储临时变量和指针，不会动态分配大规模的额外空间。

8.源码

#pragma once
#include<utility>
enum _col
{
	RED,//红色
	BLACK//黑色
};
template<class K,class V>
struct RBNode
{
	RBNode(const pair<K,V>& kv = pair<K,V>(), _col col = RED)
		:_left(nullptr)
		, _right(nullptr)
		, _parent(nullptr)
		, _kv(kv)
		, _col(col)//默认为红节点
	{}
	RBNode<K, V>* _left;//左子树
	RBNode<K, V>* _right;//右子树
	RBNode<K, V>* _parent;//父节点
	pair<K, V> _kv;//键值
	_col _col;//颜色
};
template<class K, class V>
class RBTree
{
	typedef RBNode<K, V> Node;
public:
	RBTree()
	{}
	RBTree(const RBTree<K, V>&t)
	{
		_root = copy(t._root);
	}
    RBTree<K, V> operator =(const RBTree<K, V> t)
    {
        this->swap(_root, t._root);
        return *this;
    }
    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);
        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
                {
                    //情况四：叔叔不存在/存在且为黑，且cur在parent的左侧
                    if (cur == parent->_left)
                    {
                        //     g  
                        //   p   u
                        // c 
                        RotateR(grandfather);
                        parent->_col = BLACK;
                        grandfather->_col = RED;
                    }
                    else//情况五：叔叔不存在 / 存在且为黑，cur在parent的右侧
                    {
                        //     g
                        //   p   u
                        //     c
                        RotateLR(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
                {
                    //情况四：叔叔不存在/存在且为黑，且cur在parent的左侧
                    if (cur == parent->_right)
                    {
                        //    g
                        //  u   p
                        //        c
                        RotateL(grandfather);
                        parent->_col = BLACK;
                        grandfather->_col = RED;
                    }
                    else // 情况五：叔叔不存在 / 存在且为黑，cur在parent的右侧
                    {
                        //    g
                        //  u   p
                        //    c
                        RotateRL(grandfather);
                        cur->_col = BLACK;
                        grandfather->_col = RED;
                    }
                    //这时该子树的根节点变为黑色，不需要继续调整
                    break;
                }
            }
            
        }
        //防止情况三改到根节点变为红色
        _root->_col = BLACK;
        return true;
    }
    void RotateR(Node* parent)
    {
        Node* cur = parent;
        Node* subL = parent->_left;
        Node* subLR = subL->_right;
        parent->_left = subLR;
        if (subLR)
            subLR->_parent = parent;
        subL->_right = parent;
        Node* ppNode = parent->_parent;
        parent->_parent = subL;
        if (parent == _root)
        {
            _root = subL;
            _root->_parent = nullptr;
        }
        else
        {
            if (ppNode->_left == parent)
            {
                ppNode->_left = subL;
            }
            else
            {
                ppNode->_right = subL;
            }
            subL->_parent = ppNode;
        }
    }
    void RotateL(Node* parent)
    {
        Node* subR = parent->_right;
        Node* subRL = subR->_left;
        parent->_right = subRL;
        if (subRL)
            subRL->_parent = parent;

        subR->_left = parent;
        Node* ppNode = parent->_parent;

        parent->_parent = subR;

        if (parent == _root)
        {
            _root = subR;
            _root->_parent = nullptr;
        }
        else
        {
            if (ppNode->_right == parent)
            {
                ppNode->_right = subR;
            }
            else
            {
                ppNode->_left = subR;
            }
            subR->_parent = ppNode;
        }
    }
    void RotateLR(Node* parent)
    {
        RotateL(parent->_left);
        RotateR(parent);
    }
    void RotateRL(Node* parent)
    {
        RotateR(parent->_right);
        RotateL(parent);
    }
    Node* Find(const K& val)
    {
        Node* cur = _root;
        while (cur)
        {
            if (cur->_kv.first > val)
            {
                //左子树中查找
                cur = cur->_left;
            }
            else if (cur->_kv.first < val)
            {
                //右子树中查找
                cur = cur->_right;
            }
            else
            {
                //找到了
                return cur;
            }
        }
        return nullptr;
    }

    //删除函数
    bool Erase(const K& key)
    {
        //(一)找到删除节点
        Node* cur = Find(key);
        //未找到返回false
        if (cur == nullptr)
        {
            return false;
        }
        //记录父节点
        Node* parent = cur->_parent;
        //用于标记实际的待删除结点及其父结点
        Node* delParent = nullptr;
        Node* delCur = nullptr;
        if (cur->_left == nullptr) //待删除结点的左子树为空
        {
            if (cur == _root) //待删除结点是根结点
            {
                _root = _root->_right; //让根结点的右子树作为新的根结点
                if (_root)
                {
                    _root->_parent = nullptr;
                    _root->_col = BLACK; //根结点为黑色
                }
                delete cur; //删除原根结点
                return true;
            }
            else
            {
                delParent = parent; //标记实际删除结点的父结点
                delCur = cur; //标记实际删除的结点
            }
        }
        else if (cur->_right == nullptr) //待删除结点的右子树为空
        {
            if (cur == _root) //待删除结点是根结点
            {
                _root = _root->_left; //让根结点的左子树作为新的根结点
                if (_root)
                {
                    _root->_parent = nullptr;
                    _root->_col = BLACK; //根结点为黑色
                }
                delete cur; //删除原根结点
                return true;
            }
            else
            {
                delParent = parent; //标记实际删除结点的父结点
                delCur = cur; //标记实际删除的结点
            }
        }
        else //待删除结点的左右子树均不为空
        {
            //替换法删除
            //寻找待删除结点右子树当中key值最小的结点作为实际删除结点
            Node* minParent = cur;
            Node* minRight = cur->_right;
            while (minRight->_left)
            {
                minParent = minRight;
                minRight = minRight->_left;
            }
            cur->_kv = minRight->_kv; //将待删除结点的键值改为minRight的键值
            delParent = minParent; //标记实际删除的父节点
            delCur = minRight; //标记实际删除的结点
        }
        //记录待删除结点及其父结点，便于后面删除
        Node* del = delCur;
        Node* delP = delParent;
        //(二)调整红黑树
        AdjustRBTree(delCur, delParent);
        //(三)进行实际删除
        DeleteNode(del, delP);
        return true;
    }
    void DeleteNode(Node* del, Node* delP)
    {
        if (del->_left == nullptr) //实际删除结点的左子树为空
        {
            if (del == delP->_left) //实际删除结点是其父结点的左孩子
            {
                delP->_left = del->_right;
                //指向父节点
                if (del->_right)
                    del->_right->_parent = delP;
            }
            else //实际删除结点是其父结点的右孩子
            {
                delP->_right = del->_right;
                if (del->_right)
                    del->_right->_parent = delP;
            }
        }
        else //实际删除结点的右子树为空
        {
            if (del == delP->_left) //实际删除结点是其父结点的左孩子
            {
                delP->_left = del->_left;
                if (del->_left)
                    del->_left->_parent = delP;
            }
            else //实际删除结点是其父结点的右孩子
            {
                delP->_right = del->_left;
                if (del->_left)
                    del->_left->_parent = delP;
            }
        }
        delete del; //实际删除结点
    }
    void AdjustRBTree(Node* delCur, Node* delParent)
    {
        if (delCur->_col == BLACK) //删除的是黑色结点
        {
            if (delCur->_left) //待删除结点有一个红色的左孩子（不可能是黑色）
            {
                delCur->_left->_col = BLACK; //将这个红色的左孩子变黑即可
            }
            else if (delCur->_right) //待删除结点有一个红色的右孩子（不可能是黑色）
            {
                delCur->_right->_col = BLACK; //将这个红色的右孩子变黑即可
            }
            else //待删除结点的左右均为空
            {
                while (delCur != _root) //可能一直调整到根结点
                {
                    if (delCur == delParent->_left) //待删除结点是其父结点的左孩子
                    {
                        Node* brother = delParent->_right; //兄弟结点是其父结点的右孩子
                        //情况一：brother为红色
                        if (brother->_col == RED)
                        {
                            delParent->_col = RED;
                            brother->_col = BLACK;
                            RotateL(delParent);
                            //需要继续处理
                            brother = delParent->_right; //更新brother
                        }
                        //情况二：brother为黑色，且其左右孩子都是黑色结点或为空
                        if (((brother->_left == nullptr) || (brother->_left->_col == BLACK))
                            && ((brother->_right == nullptr) || (brother->_right->_col == BLACK)))
                        {
                            brother->_col = RED;
                            if (delParent->_col == RED)
                            {
                                delParent->_col = BLACK;
                                break;
                            }
                            //需要继续处理
                            delCur = delParent;
                            delParent = delCur->_parent;
                        }
                        else
                        {
                            //情况三：brother为黑色，且其左孩子是红色结点，右孩子是黑色结点或为空
                            if ((brother->_right == nullptr) || (brother->_right->_col == BLACK))
                            {
                                brother->_left->_col = BLACK;
                                brother->_col = RED;
                                RotateR(brother);
                                //需要继续处理
                                brother = delParent->_right; //更新brother
                            }
                            //情况四：brother为黑色，且其右孩子是红色结点
                            brother->_col = delParent->_col;
                            delParent->_col = BLACK;
                            brother->_right->_col = BLACK;
                            RotateL(delParent);
                            break; //情况四执行完毕后调整一定结束
                        }
                    }
                    else //delCur == delParent->_right //待删除结点是其父结点的右孩子
                    {
                        Node* brother = delParent->_left; //兄弟结点是其父结点的左孩子
                        //情况一：brother为红色
                        if (brother->_col == RED) //brother为红色
                        {
                            delParent->_col = RED;
                            brother->_col = BLACK;
                            RotateR(delParent);
                            //需要继续处理
                            brother = delParent->_left; //更新brother
                        }
                        //情况二：brother为黑色，且其左右孩子都是黑色结点或为空
                        if (((brother->_left == nullptr) || (brother->_left->_col == BLACK))
                            && ((brother->_right == nullptr) || (brother->_right->_col == BLACK)))
                        {
                            brother->_col = RED;
                            if (delParent->_col == RED)
                            {
                                delParent->_col = BLACK;
                                break;
                            }
                            //需要继续处理
                            delCur = delParent;
                            delParent = delCur->_parent;
                        }
                        else
                        {
                            //情况三：brother为黑色，且其右孩子是红色结点，左孩子是黑色结点或为空
                            if ((brother->_left == nullptr) || (brother->_left->_col == BLACK))
                            {
                                brother->_right->_col = BLACK;
                                brother->_col = RED;
                                RotateL(brother);
                                //需要继续处理
                                brother = delParent->_left; //更新brother
                            }
                            //情况四：brother为黑色，且其左孩子是红色结点
                            brother->_col = delParent->_col;
                            delParent->_col = BLACK;
                            brother->_left->_col = BLACK;
                            RotateR(delParent);
                            break; //情况四执行完毕后调整一定结束
                        }
                    }
                }
            }
        }
    }
    ~RBTree()
    {
        Destroy(_root);
    }
    bool IsRBTree()
    {
        if (_root->_col == RED)
        {
            cout << "根节点为红节点" << endl;
            return false;
        }
        //从根节点到叶节点的黑色节点数
        int refNum = 0;
        Node* cur = _root;
        while (cur)
        {
            if (cur->_col == BLACK)
            {
                ++refNum;
            }

            cur = cur->_left;
        }

        return Check(_root, 0, refNum)&& isValidBST();
    }
    //判断是否为二叉搜索树
    bool isValidBST()
    {
        return _isValidBST(_root, LONG_MIN, LONG_MAX);
    }

private:
    bool _isValidBST(Node* root, long long lower, long long upper)
    {
        if (root == nullptr)
        {
            return true;
        }
        if (root->_kv.first <= lower || root->_kv.first >= upper)
        {
            return false;
        }
        bool left = _isValidBST(root->_left, lower, root->_kv.first);
        bool right = _isValidBST(root->_right, root->_kv.first, upper);
        return left && right;
    }
    bool Check(Node* root, int blackNum, int refNum)
    {
        if (root == nullptr)
        {
            if (refNum != blackNum)
            {
                cout << "存在黑色节点的数量不相等的路径" << endl;
                return false;
            }

            return true;
        }

        if (root->_parent && root->_col == RED && root->_parent->_col == RED)
        {
            cout << root->_kv.first << "存在连续的红色节点" << endl;
            return false;
        }

        if (root->_col == BLACK)
        {
            blackNum++;
        }

        return Check(root->_left, blackNum, refNum)
            && Check(root->_right, blackNum, refNum);
    }
    void Destroy(Node*& root)
    {
        if (root == nullptr)
        {
            return;
        }
        //递归销毁左子树
        Destroy(root->_left);
        //递归销毁右子树
        Destroy(root->_right);
        //销毁根节点
        delete root;
        root = nullptr;
    }


    Node* copy(Node* root)
    {
        // 如果原始节点为空，直接返回空指针
        if (root == nullptr)
        {
            return nullptr;
        }
        // 为新节点分配内存并拷贝原始节点的值
        Node* newnode = new Node(root->_kv);
        // 递归拷贝左子树
        newnode->_left = copy(root->_left);
        // 递归拷贝右子树
        newnode->_right = copy(root->_right);
        // 将新节点的父节点指针置为空
        newnode->_parent = nullptr;
        // 拷贝原始节点的颜色信息
        newnode->_col = root->_col;
        // 如果新节点的左子节点存在，设置其父节点为新节点
        if (newnode->_left)
        {
            newnode->_left->_parent = newnode;
        }
        // 如果新节点的右子节点存在，设置其父节点为新节点
        if (newnode->_right)
        {
            newnode->_right->_parent = newnode;
        }
    }

	Node* _root = nullptr;
};
Betty’s Sweet
关注
  • 11
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
数据结构与算法之美.zip
01-01
数据结构与算法是计算机科学的基础，对于理解和解决复杂问题至关重要。数据结构主要研究如何在计算机中组织和存储数据，以便...因此，无论是初学者还是经验丰富的开发者，都应该不断探索和实践数据结构与算法的知识。
深入探索数据结构技术：理论、实践与应用
热门推荐
聚焦于深度解析最新的编程语言特性、框架升级、架构设计、开发工具和最佳实践，涵盖Web前端（如Vue3, React, Angular等）、后端开发（如Node.js, Java, Python等）、移动端开发（iOS, Android原生及跨平台开发）
04-16 2万+
数据结构技术的学习是一个逐步深入的过程，需要理论与实践相结合，不断通过编程练习巩固所学知识。只有扎实掌握数据结构，才能在面对复杂数据处理问题时游刃有余，为软件开发、数据分析、算法设计等领域的专业发展打下坚实基础。希望通过本文的引导，读者能够系统地学习并掌握数据结构技术，不断提升自身的编程素养与问题解决能力。
探索高效数据结构：RB_Tree - 红黑树的C++实现
gitblog_00040的博客
05-26 328
探索高效数据结构：RB_Tree - 红黑树的C++实现 项目地址:https://gitcode.com/Neo-ZK/RB_Tree 1. 项目介绍 在软件开发中，高效的数据结构是性能优化的关键所在。RB_Tree 是一个开放源码的C++项目，它提供了一个完整的红黑树实现。这个项目旨在解决网络上关于红黑树教程普遍缺乏完整实现的问题。通过模板编程，RB_Tree 提供了高度灵活且易于使用的接口，...
探索数据结构：分支的世界之二叉树与堆
x3262551980的博客
07-04 1526
树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
探索数据结构：从基础到高级
努力是为了站在万人之中，成为别人的光
09-14 7502
数据结构是计算机科学和编程中的基础概念，它们用于组织和存储数据以便有效地进行操作和管理。本文将带您深入探讨数据结构，从基础的数组和链表到高级的树和图，以及它们在实际编程中的应用。
高职高专《数据结构》课程教学实践与探索.pdf
08-07
在《高职高专《数据结构》课程教学实践与探索》这一文档中，标题所提示的核心知识内容是“数据结构”和“教学实践与探索”，这是高职高专院校计算机专业及其相关专业的一门重要课程，对于培养学生分析问题和解决问题...
数据结构和算法分析 语言描述参考答案
03-17
4. 答案与源码：书中提供的解决方案和源代码涵盖了各种数据结构和算法的实现，例如排序（冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序等）、搜索（线性搜索、二分搜索、哈希搜索等）、图的遍历（深度...
数据结构与管理(九).pdf
08-07
由于提供的文件内容似乎是一段经过OCR扫描出错的乱码，无法准确获取内容的真实信息，我将基于标题“数据结构与管理(九).pdf”和标签“数据结构 数据分析 大数据 参考文献 专业指导”来构建相关知识点。 在IT行业中...
【数据结构】队列的实现
最新发布
weixin_74076508的博客
08-19 380
也许有同学想的可能是这样的结构体设计。
6. 数据结构—串的匹配算法
m0_68536532的博客
08-19 76
串模式匹配的BF算法、KMP算法(包括KMP优化) 以及两者的时间复杂度分析。
数据结构之---堆（2）
2301_81684056的博客
08-15 622
出堆是指将堆顶数据出堆。出堆完成后要保证剩余数据还是满足原来堆的性质。所以我们把堆顶数据和堆底最后一个数据交换，取出新堆底数据，之后通过向下调整算法将剩下的数据重新排列成一个堆。大堆经过出堆操作得出的数据是升序的小堆经过出堆操作得出的数据是降序的。
数据结构之树的存储结构
DKPT的博客
08-16 476
孩子链表表示法将树中所有节点存储在一个顺序表中，每个数据元素有两个域：数据域和存放该节点第一个孩子地址的指针域。同时，为树中每个节点构建一个单链表，链表中的节点也有两个域：存放该孩子节点在顺序表中的数组下标和指向下一个孩子的指针。对于完全二叉树，如果父节点的索引是i（假设从0开始计数），那么它的左子节点的索引是2i+1，右子节点的索引是2i+2。数组的第一个元素存储树的根节点。双亲表示法通过采用一维数组来存储树中的节点，其中每个节点被赋予一个结构体类型，包含数据域和父节点位置域（parent域）。
二叉树详解（1）
weixin_73077334的博客
08-15 1229
二叉树详解（1）
数据结构之排序（下）
qq_74336191的博客
08-15 655
​ 嗨！小伙伴们，咱们又见面啦，在上一篇数据结构之排序（上）中，我们学习了直接插入排序、冒泡排序和希尔排序，今天我们继续学习排序这一块，准备好了吗？Ready Go ! ! ! ​
【数据结构】PTA 带头结点的链式表操作集 C语言
2302_79596028的博客
08-19 118
其中List：创建并返回一个空的线性表；：返回线性表中X的位置。若找不到则返回ERROR；：将X插入在位置P指向的结点之前，返回true。如果参数P指向非法位置，则打印“Wrong Position for Insertion”，返回false；：将位置P的元素删除并返回true。若参数P指向非法位置，则打印“Wrong Position for Deletion”并返回false。
【每日刷题】Day100
2301_78022459的博客
08-14 2226
【每日刷题】Day100
数据结构——二叉树
2301_80373479的博客
08-16 1475
轻松学会二叉树
构建业务可观测性：统一数据结构的重要性
wj_wjs的博客
08-15 622
随着业务流程的日益复杂化和数据来源的多样化，如何有效地监控和分析这些数据，成为了企业提升竞争力的关键。观测云平台的统一数据结构，为企业提供了一个标准化的数据管理框架，有助于企业更好地遵守数据保护法规，保护客户数据的安全和隐私。通过建立统一的数据结构，企业能够确保不同来源和类型的数据在格式、定义和语义上的一致性，从而实现数据的无缝整合和高效分析。通过建立统一的数据结构，观测云平台使得不同部门能够使用相同的数据语言进行沟通，从而加强了跨部门的协作和信息共享。首先，统一数据结构为数据采集提供了标准化的框架。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Betty’s Sweet

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

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

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

打赏作者

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

抵扣说明：

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

余额充值