红黑树的详细实现(C++)

【C++详解】——红黑树 本文介绍了红黑树的概念、性质,详细解释了红黑树插入节点的过程。 阅读详情
AI摘要

本文详细介绍了红黑树的概念,它是自平衡的二叉搜索树,通过颜色规则确保树的平衡性。文章涵盖了插入、删除操作的调整过程,以及红黑树与AVL树的比较。红黑树在STL容器中的应用和其实现都被深入剖析。

红黑树概念(concept)

树型结构主要用于搜索,一直是科学领域的重要演算法,当中探讨了树可能遇到的问题:树的成长可能偏向于一边,也就是不平衡现象。

二叉树是常见且广泛使用的一种树,面临其可能退化成链表的潜藏缺点,在使用上难免让人担心其效率。此外,在一些应用上,可能不希望这样的不平衡的可能性发生。所以具有自动平衡左右数量分布效果的演算算法早在 1962 年被提出,称为 AVL 树。这种平衡成长的二叉搜索树被称为自平衡二叉搜索树。

接下来,介绍同为自平衡二叉搜索树的红黑树对平衡性的要求比 AVL 树还要宽松。红黑树是利用节点颜色来检查二叉树每条路径的高度是否差不多,因为发明者定下了以下规则:

  1. 树上的每个结点(node) 只能是 红色 或 黑色。

  2. 根节点(root) 一定是黑色。

  3. 叶子节点(leaf) 一定是 黑色 的 空值节点 (NULL)。

  4. 任一路径上不能有两个连续的红色。注意:黑色节点的子节点颜色没有限制。

  5. 从任何节点出发,其下至叶节点所有路径的黑色节点数目相同。

满足上述的二叉树,相比一般的二叉树更能保持平衡性,往后套用二叉树的算法来查找时能更快速、方便的到达目的地,套用算法的时间复杂度为 O(logn),因为红黑树保证最长路径不会超过最短路径的两倍(由规则 4 和规则 5)。原因是:当某条路径最短时,这条路径必然都是由黑色节点构成。当某条路径长度最长时,这条路径必然是由红色和黑色节点相间构成(规则4限定了不能出现两个连续的红色节点)。而规则5又限定了从任一节点到其每个叶子节点的所有路径必须包含相同数量的黑色节点。此时,在路径最长的情况下,路径上红色节点数量 = 黑色节点数量。该路径长度为两倍黑色节点数量,也就是最短路径长度的 2 倍。

如下是一个红黑树示例图:

红黑树的详细实现-图1

注意:null 节点是指每个叶节点都有两个空的并且颜色为黑的 NULL 节点,一般在示例图中需要它的时候就可以把它看成两个黑色的节点,不需要的时候可以忽视它。

红黑树与AVL的比较:

红黑树和 AVL 树的算法时间复杂度相同,但红黑树不追求完全平衡,换来的是增删节点时转转次数的降低,任何不平衡都会在三次旋转之内解决,但AVL是严格平衡树,旋转次数比红黑树多。插入节点失衡时,AVL 和 RBTree 都是最多两次旋转实现复衡 (O(1)),但删除节点失衡时,AVL 需要维护从被删除节点到根节点路径上所有节点的平衡 (O(logN)),而红黑树最多只需要 3 次 (O(1)),所以 RBTree 在内容极多时优于 AVL,RBTree 的功能、性能、空间开销综合更好。红黑树有着良好的稳定性和完整的功能,性能表现也很不错,综合实力强,在 STL 的 set 和 map 等容器中被优先使用。

因为红黑树也是一种二叉树,所以例如:插入结点、删除结点、查询结点等针对红黑树的操作与二叉树的操作前段演算法相同,只是在每次操作完后可能会让树的结构改变而可能无法满足红黑树的规则,进而可能不具有平衡的性质。为了在操作后仍是一颗红黑树,需要通过变色和旋转调整来满足红黑树的规则。

红黑树插入(Insertion)

在新增的操作上,新插入的节点一律为红色,因此如果插入的节点着色为黑色,那必然有可能导致某条路径上的黑色节点数量大于其他路径上的黑色节点数量,因此默认插入的节点必须是红色的,目的是希望红黑树维持上面规则5的约束,也就是任一根节点到叶子节点黑色节点数目相同,但是也可能违反出了规则5外的其他规则,所以做完二叉树新增操作后,需要以新增的节点开始向上检查红黑树是否符合各项规则。

首先先明确以下各个节点的叫法:

红黑树的详细实现-图2

红黑树的插入会有以下几种情况,因为不同情况会采取不同的修正过程:

  • 情况1:当红黑树为空树时,新插入红色节点成为根节点,必须将其变成黑色。

红黑树的详细实现-图3

  • 情况2:插入新的红色节点的父节点为黑色,并不会影响红黑树的平衡,直接插入即可。

红黑树的详细实现-图4

  • 情况3:插入的新的红色节点的父节点是红色,若叔叔结点为红色,则祖父结点一定为黑色,将祖父结点变为红色,而父节点和叔叔结点变为黑色。因为红色结点上移,出现连续的红色节点,形成了情况4,这将再情况4中说明。

红黑树的详细实现-图5

  • 情况4:插入的新的红色节点的父节点是红色,如果叔叔节点是黑色,且新的节点在父节点右边,则先以父节点进行左旋转,形成了情况5,在情况5中处理。

红黑树的详细实现-图6

  • 情况5:插入新的红色节点的父节是红色 ,如果叔叔节点是黑色,且新节点在父节点左边,则先将父节点变成黑色,但是违反了规则5(黑色节点数目不相同),必须再将祖父节点变成红色,以祖父节点进行右旋(直觉上,节点F的左边路径会多一个黑色节点,可以通过右旋把黑色转掉)。

红黑树的详细实现-图7注意:以上都在讨论新插入的红色节点的父节点是红色,且父节点是祖父节点的左分支情况,如果是在右分支,其处理是镜像的,只需要左右互换一下就可以了。

红黑树删除(Deletion)

首先要了解 AVL 的删除操作:

  1. 如果删除的是叶子节点,可以直接删除。

  2. 如果被删除的元素有一个子节点,可以将子节点直接移动到被删除元素的位置。

  3. 如果有两个子节点,这时候就可以把被删除的元素的右分支的最小点(也就是被删除元素左分支的最左边节点)和被删除的元素互换,然后再将被删除元素删除。

但是红黑树加入颜色后,被删除元素和后继元素互换只是值互换,并不是互换颜色。

红黑树的删除操作上,删除一个节点可能会违反规则,需要向上检查红黑树是否符合各项规则,修正红黑树可能会有以下几种情况:

  • 情况1:当被删除节点为黑且为根节点时,直接删除。

  • 情况2:被删除的是红色的节点,不违反任何规则,直接删除。

  • 情况3:被删除的节点是黑色,但是递补上来的节点是红色,直接将该递补上来的节点变为黑色即可。

红黑树的详细实现-图8

情况4:被删除的节点为黑色,且兄弟节点为红色,需要将兄弟节点变为黑色,父节点变为红色,再以父节点进行左旋。形成了情况5,在情况5中处理。

红黑树的详细实现-图9

情况5:被删除的节点为黑色,若兄弟节点为黑色,且兄弟的左孩子节点与右孩子节点都是黑色时,这时如果父节点为红色,将兄弟节点变为红色,父节点变为黑色即可。

红黑树的详细实现-图10

情况6:被删除的节点为黑色,且兄弟节点为黑色,兄弟节点的左孩子节点为红色,这时需要把兄弟节点变为红色,兄弟节点的左孩子节点变为黑色,再以兄弟节点进行右旋操作。形成了情况7,在情况7中处理。

红黑树的详细实现-图11

情况7:被删除的节点为黑色,且兄弟节点为黑色,兄弟节点的右孩子节点为红色,这时需要把兄弟节点变为父节点的颜色,并把父节点和兄弟节点的右孩子节点变为黑色,再以父节点进行左旋即可。

红黑树的详细实现-图12

注意:以上都在讨论删除红黑树的一个节点,且被删除节点是父节点左分支情况,如果是在右分支上,其处理是镜像的。

红黑树的总结(Conclusion)

红黑树的步骤是可以推导出来的,因为把一个平衡但通过插入或删除操作破坏了平衡的红黑树再次平衡,通过转转和变色使其符合红黑树的 5 条规则,旋转操作是为了符合二叉树左小右大的性质,交换颜色是为了保持红黑树的 5 条性质。时刻记得红黑树的一切操作是为了上面的5条规则。

红黑树的实现(Implement)

红黑树的节点类型定义如下:

template <typename Type>
struct RBTNode
{
    Color color;     //颜色
    Type key;        //关键字
    RBTNode *left;   //左孩子
    RBTNode *right;  //右孩子
    RBTNode *parent; //父结点
};

下面给出红黑树的 C++ 完整实现代码:

#include <iostream>
#include <assert.h>

using namespace std;

typedef enum
{
    RED = 0,
    BLACK
} Color;

//红黑树结点类型
template <typename Type>
struct RBTNode
{
    Color color;     //颜色
    Type key;        //关键字
    RBTNode *left;   //左孩子
    RBTNode *right;  //右孩子
    RBTNode *parent; //父结点
};

//红黑树类型
template <typename Type>
class RBTree
{
public:
    //构造函数
    RBTree()
    {
        Nil = BuyNode();
        root = Nil;
        Nil->color = BLACK;
    }
    //析构函数
    ~RBTree()
    {
        destroy(root); //销毁创建的非Nil结点
        delete Nil;    //最后删除Nil结点
        Nil = NULL;
    }

    //中序遍历
    void InOrder() { InOrder(root); }

    //插入
    //1.BST方式插入
    //2.调整平衡
    bool Insert(const Type &value)
    {
        RBTNode<Type> *pr = Nil; //pr用来记住父节点
        RBTNode<Type> *s = root; //定义变量s指向根
        while (s != Nil)
        {
            if (value == s->key)
            {
                return false;
            }
            pr = s; //每次记住s的父节点
            if (value < s->key)
            {
                s = s->left;
            }
            else
            {
                s = s->right;
            }
        }
        //循环后s==Nil
        s = BuyNode(value); //申请结点
        if (pr == Nil)      //如果父节点pr是根节点,第一次root指向Nil,所以pr==Nil
        {
            root = s;
            root->parent = pr;
        }
        else //如果父节点不是根节点
        {
            if (value < pr->key)
            {
                pr->left = s;
            }
            else
            {
                pr->right = s;
            }
            s->parent = pr; //设置新结点s的父节点
        }
        //调整平衡
        Insert_Fixup(s);
        return true;
    }

    //删除key结点(先查找,再调用内部删除)
    void Remove(Type key)
    {
        RBTNode<Type> *t;
        if ((t = Search(root, key)) != Nil)
        {
            Remove(t);
        }
        else
        {
            cout << "Key is not exist." << endl;
        }
    }

    //中序遍历打印结点详细的结点颜色
    void InOrderPrint() { InOrderPrint(root); }

protected:
    //申请结点结点,将结点的颜色初始化为红色,初始化结点的关键字,其他的初始化为空
    RBTNode<Type> *BuyNode(const Type &x = Type())
    {
        RBTNode<Type> *s = new RBTNode<Type>();
        assert(s != NULL);
        s->color = RED;
        s->left = s->right = s->parent = Nil;
        s->key = x;
        return s;
    }

    //中序遍历
    void InOrder(RBTNode<Type> *root)
    {
        if (root != Nil)
        {
            InOrder(root->left);
            cout << root->key << " ";
            InOrder(root->right);
        }
    }

    /* 左转,对z结点左转
     *       zp                 zp
     *       /                  /
     *     z                   y
     *    / \      ===>       / \
     *   lz  y               z   ry
     *      / \             / \
     *     ly  ry          lz  ly  
     */
    void LeftRotate(RBTNode<Type> *z)
    {
        RBTNode<Type> *y = z->right; //用y指向要转动的z结点
        z->right = y->left;
        if (y->left != Nil) //y所指结点的左结点不为空
        {
            y->left->parent = z;
        }
        y->parent = z->parent;
        if (root == z) //z就是根节点
        {
            root = y;
        }
        else if (z == z->parent->left) //z在左结点
        {
            z->parent->left = y;
        }
        else //z在右结点
        {
            z->parent->right = y;
        }
        y->left = z;
        z->parent = y;
    }

    /* 右转,对z结点进行右转
    *         zp               zp
    *        /                 /
    *       z                 y
    *      / \    ===>       / \
    *     y   rz           ly   z   
    *    / \                   / \
    *   ly  ry                ry  rz
    */
    void RightRotate(RBTNode<Type> *z)
    {
        RBTNode<Type> *y = z->left;
        z->left = y->right;
        if (y->right != Nil)
        {
            y->right->parent = z;
        }
        y->parent = z->parent;
        if (root == z) //如果z是根结点
        {
            root = y;
        }
        else if (z == z->parent->left) //z在左结点
        {
            z->parent->left = y;
        }
        else //z在右结点
        {
            z->parent->right = y;
        }
        y->right = z;
        z->parent = y;
    }

    //插入后的调整函数
    void Insert_Fixup(RBTNode<Type> *s)
    {
        RBTNode<Type> *uncle;           //叔结点(父结点的兄弟结点)
        while (s->parent->color == RED) //父节点的颜色也为红色
        {
            if (s->parent == s->parent->parent->left) //父节点是左结点
            {
                uncle = s->parent->parent->right;

                if (uncle->color == RED) //叔结点为红色
                {
                    //父节点和叔结点都变为黑色
                    s->parent->color = BLACK;
                    uncle->color = BLACK;
                    //祖父结点变为红色
                    s->parent->parent->color = RED;
                    //将s指针指向祖父结点,下一次循环继续判断祖父的父节点是否为红色
                    s = s->parent->parent;
                }
                else //没有叔结点,或叔结点为黑色(经过多次循环转换,叔结点可能为黑)
                {
                    if (s == s->parent->right) //如果调整的结点在右结点
                    {
                        s = s->parent; //先将s指向s的父结点
                        LeftRotate(s); //再左转
                    }
                    //如果调整的结点在左结点,将s的父节点变为黑色,将祖父的结点变为红色,将s的祖父结点右转
                    s->parent->color = BLACK;
                    s->parent->parent->color = RED;
                    RightRotate(s->parent->parent);
                }
            }
            else
            {
                if (s->parent == s->parent->parent->right) //父节点是右结点
                {
                    uncle = s->parent->parent->left;
                    if (uncle->color == RED) //叔结点为红色
                    {
                        //父节点和叔结点都变为黑色
                        s->parent->color = BLACK;
                        uncle->color = BLACK;
                        //祖父结点变为红色
                        s->parent->parent->color = RED;
                        //将s指针指向祖父结点,下一次循环继续判断祖父的父节点是否为红色
                        s = s->parent->parent;
                    }
                    else //没有叔结点,或叔结点为黑色(经过多次循环转换,叔结点可能为黑)
                    {
                        if (s == s->parent->left) //如果调整的结点在左结点
                        {
                            s = s->parent;  //先将s指向s的父结点
                            RightRotate(s); //再右转
                        }
                        //如果调整的结点在右结点,将s的父节点变为黑色,将祖父的结点变为红色,将s的祖父结点右转
                        s->parent->color = BLACK;
                        s->parent->parent->color = RED;
                        LeftRotate(s->parent->parent);
                    }
                }
            }
        }
        root->color = BLACK; //最后始终将根节点置为黑色
    }

    //查找key结点
    RBTNode<Type> *Search(RBTNode<Type> *root, Type key) const
    {
        if (root == Nil) //root为空,或key和根的key相同
        {
            return Nil;
        }

        if (root->key == key)
        {
            return root;
        }
        if (key < root->key)
        {
            return Search(root->left, key);
        }
        else
        {
            return Search(root->right, key);
        }
    }

    /* 将u的子节点指向u的指针改变指向v,将v的父节点指针改变为指向u的父节点
     *      up
     *        \
     *         u
     *        / \
     *      ul   ur
     *     / \
     *    v  ulr
     *     \
     *     rv
     */
    void Transplant(RBTNode<Type> *u, RBTNode<Type> *v)
    {
        if (u->parent == Nil) //u的父节点为空
        {
            root = v; //直接令根root为v
        }
        else if (u == u->parent->left) //u父节点不为空,且u在左子树
        {
            u->parent->left = v;
        }
        else //u在右子树
        {
            u->parent->right = v;
        }
        v->parent = u->parent;
    }

    /* 找到最左结点(最小)
     *      xp
     *        \
     *         x
     *        / \
     *      xl   xr
     *     / \
     *   xll  xlr
     */
    RBTNode<Type> *Minimum(RBTNode<Type> *x)
    {
        if (x->left == Nil)
        {
            return x;
        }
        return Minimum(x->left);
    }

    //删除红黑树结点z
    void Remove(RBTNode<Type> *z)
    {
        RBTNode<Type> *x = Nil;
        RBTNode<Type> *y = z;    //y记住传进来的z结点
        Color ycolor = y->color; //
        if (z->left == Nil)      //z只有右孩子
        {
            x = z->right;
            Transplant(z, z->right);
        }
        else if (z->right == Nil) //z只有右孩子
        {
            x = z->left;
            Transplant(z, z->left);
        }
        else //右左孩子和右孩子
        {
            y = Minimum(z->right); //y是z右子树的的最左子树
            ycolor = y->color;
            x = y->right;
            if (y->parent == z) //z的右子结点没有左节点或为Nil
            {
                x->parent = y;
            }
            else //z的右子结点有左节点或为Nil
            {
                Transplant(y, y->right);
                y->right = z->right;
                y->right->parent = y;
            }
            Transplant(z, y);
            //改变指向
            y->left = z->left;
            z->left->parent = y;
            y->color = z->color;
        }
        if (ycolor == BLACK)
        {
            Remove_Fixup(x);
        }
    }

    //红黑树删除调整
    void Remove_Fixup(RBTNode<Type> *x)
    {
        while (x != root && x->color == BLACK) //当结点x不为根并且它的颜色不是黑色
        {
            if (x == x->parent->left) //x在左子树
            {
                RBTNode<Type> *w = x->parent->right; //w是x的兄结点

                if (w->color == RED) //情况1
                {
                    w->color = BLACK;
                    x->parent->color = RED;
                    LeftRotate(x->parent);
                    w = x->parent->right;
                }
                if (w->left->color == BLACK && w->right->color == BLACK) //情况2
                {
                    w->color = RED;
                    x = x->parent;
                }
                else
                {
                    if (w->right->color == BLACK) //情况3
                    {
                        w->color = RED;
                        w->left->color = BLACK;
                        RightRotate(w);
                        w = x->parent->right;
                    }
                    //情况4
                    w->color = w->parent->color;
                    w->parent->color = BLACK;
                    w->right->color = BLACK;
                    LeftRotate(x->parent);
                    x = root; //结束循环
                }
            }
            else //x在右子树
            {
                RBTNode<Type> *w = x->parent->left;
                if (w->color == RED) //情况1
                {
                    w->parent->color = RED;
                    w->color = BLACK;
                    RightRotate(x->parent);
                    w = x->parent->left;
                }
                if (w->right->color == BLACK && w->right->color == BLACK) //情况2
                {
                    w->color = RED;
                    x = x->parent;
                }
                else
                {
                    if (w->left->color == BLACK) //情况3
                    {
                        w->right->color = BLACK;
                        w->color = RED;
                        LeftRotate(w);
                        w = x->parent->left;
                    }
                    //情况4
                    w->color = x->parent->color;
                    x->parent->color = BLACK;
                    w->left->color = BLACK;
                    RightRotate(x->parent);
                    x = root; //结束循环
                }
            }
        }
        x->color = BLACK;
    }

    //销毁红黑树
    void destroy(RBTNode<Type> *&root)
    {
        if (root == Nil)
        {
            return;
        }
        if (root->left != Nil)
        {
            destroy(root->left);
        }
        if (root->right != Nil)
        {
            destroy(root->right);
        }
        delete root;
        root = NULL;
    }

    //中序遍历打印结点详细的结点颜色
    void InOrderPrint(RBTNode<Type> *node)
    {
        if (node == Nil)
        {
            return;
        }
        if (node->left != NULL)
        {
            InOrderPrint(node->left);
        }
        cout << node->key << "(" << ((node->color == BLACK) ? "BLACK" : "RED") << ")"
             << " ";
        if (node->right != Nil)
        {
            InOrderPrint(node->right);
        }
    }

private:
    RBTNode<Type> *root; //根指针
    RBTNode<Type> *Nil;  //外部结点,表示空结点,黑色的
};

int main(int argc, char *argv[])
{
    RBTree<int> rb;

    int arr[] = {10, 7, 8, 15, 5, 6, 11, 13, 12};
    int n = sizeof(arr) / sizeof(int);
    for (int i = 0; i < n; i++)
    {
        rb.Insert(arr[i]);
    }

    rb.InOrder();
    cout << endl;
    rb.InOrderPrint();
    cout << endl;
    rb.Remove(10);
    rb.InOrder();
    cout << endl;
    rb.Remove(21);
    return 0;
}

【C++】红黑树(Red Black Tree) 红黑树的一些操作 阅读详情

相关推荐

【红黑树】的详细实现(C++)附代码

红黑树的介绍 红黑树(Red-Black Tree,简称R-B Tree),它一种特殊的二叉查找树。 红黑树是特殊的二叉查找树,意味着它满足二叉查找树的特征:任意一个节点所包含的键值,大于等于左孩子的键值,小于等于右孩子的键值。 除了具备该特性之外,红黑树还包括许多额外的信息。红黑树的每个节点上都有存储位表示节点的颜色,颜色是红(Red)或黑(Black)。 红黑树一棵在每个结点上增加了一个存储位来表示结点颜色(红色RED或黑色BLACK)的二叉搜索树。 二叉搜索树简单的说就是:对树中任何结点x,其左

Linuxhus的博客 2560

c++——红黑树

愿你终将与重要的人重逢!

Britney_dark的博客 5107

老服务器焕新记:在Dell R730上折腾Nvidia K80显卡的完整记录(含Anaconda环境配置)

本文详细记录了在Dell R730服务器上为Nvidia K80计算卡安装驱动、配置CUDA及Anaconda环境的完整过程。文章重点解决了老旧硬件与CentOS 7系统的兼容性问题,提供了从BIOS设置、驱动版本精准匹配到Python机器学习环境搭建的实战指南,旨在帮助读者低成本挖掘旧服务器的GPU计算潜力。

weixin_29197835的博客 504

红黑树(C++实现)

红黑树(C++实现)

2021dragon的博客 1万+

PySpark 本地开发环境搭建与实践

本文详细介绍了 PySpark 本地开发环境的搭建过程,包括 JDK、Hadoop、Anaconda、PySpark 的安装以及 Pycharm 工程的创建。同时,深入讲解了代码编写、本地开发案例(如 WordCount、处理特殊分隔符、读取 hdfs 数据、获取外部变量)、Spark 程序的监控和 local 模式下结果文件数量问题等内容。通过掌握这些知识和技能,读者可以在 Windows 本地环境中高效地进行 PySpark 开发,处理大规模数据,解决实际业务中的数据分析和处理问题。

天冬忘忧的博客 3016

基于COMSOL电弧动态仿真模型优化:高收敛性可修改吹弧方案解析

在多物理场耦合分析中,电弧动态仿真历来是数值稳定性的难点:温度从室温跃升至数万开尔文,电导率随温度呈数量级跳变,流动、传热与电磁场相互牵制,极易引发求解器不收敛或初始值不一致等问题。如何构建高收敛性的数值模型,成为开关设备灭弧性能优化的重要技术基础。通过合理的几何简化、全耦合求解器配置、辅助扫描初始化策略以及参数化建模手段,可以实现对吹弧方案的灵活调整与批量寻优,从而系统性评估气流速度、喷口形状、触头间距等关键因素对熄弧性能的影响。这类仿真方法广泛应用于断路器、接触器等高压电器产品研发,为灭弧室结构设计提供

weixin_29758911的博客 350

C++:红黑树

1.红黑树的概念红黑树,是一种二叉搜索树,但在每个结点上增加一个存储位表示结点的颜色,可以是Red或Black。通过对任何一条从根到叶子的路径上各个结点着色方式的限制,红黑树确保没有一条路径会比其他路径长出俩倍,因而是接近平衡的。(最长的路径不超过最短路径的2倍,近似平衡)2.红黑树的性质1.每个结点不是红色就是黑色2.根节点是黑色的3. 如果一个节点是红色的,则它的两个孩子结点是黑色的(没有连续的红色节点)

zhang_si_hang的博客 2220

华大 HC32F460 DMA数据传输实战:从配置到中断处理的完整指南

本文提供了华大半导体HC32F460微控制器DMA(直接内存访问)功能的完整实战指南。详细解析了DMA的配置流程、中断处理机制以及软件与硬件触发方式,并附有实验代码示例。通过合理使用DMA进行数据传输,可以显著解放CPU资源,提升嵌入式系统的实时性与运行效率。

weixin_29194255的博客 255

红黑树(c++)实现

我们这里直接实现K V模型的红黑树,为了方便后序的旋转操作,将红黑树的结点定义为三叉链结构,除此之外还新加入了一个成员变量,用于表示结点的颜色.RED,BLACK,_kv(kv),_col(RED){}为什么构造结点时,默认将结点的颜色设置为红色?当我们向红黑树插入结点时,若我们插入的是黑色结点,那么插入路径上黑色结点的数目就比其他路径上黑色结点数目多了一个,即破坏了红黑树的性质四,此时我们就需要对红黑树进行调整.

m0_70657810的博客 1092

NotebookLM平替实测:用Open Notebook+Ollama零成本搭建私有AI知识库

本文提供了一份详细的实战指南,教你如何利用Open Notebook与Ollama,在本地零成本搭建一个功能强大且完全私有的AI知识库。通过Docker容器化部署,实现数据绝对安全、模型自由选择与离线运行,是NotebookLM等云端工具的绝佳平替方案,尤其适合注重数据隐私的教育工作者、研究者及小团队。

weixin_29052717的博客 515

威纶通触摸屏与S7-1200 PLC通讯避坑指南:从TIA Portal配置到EasyBuilder Pro实战

本文详细解析了威纶通触摸屏与S7-1200 PLC通讯的完整流程与常见问题。从TIA Portal的安全设置、IP规划,到EasyBuilder Pro中的设备配置、数据地址映射,再到高级功能如报警、趋势图的实现,提供了一套从零到精通的实战避坑指南,帮助工程师高效稳定地完成项目集成。

weixin_29250403的博客 802

红黑树的简单实现(C++)

红黑树是一种二叉搜索树,但是在每个结点上增加一个表示该点颜色的存储位,可以是Red或者Black,通过对任何一条从根到叶子的路径上各个结点着色方式的限制,红黑树确保没有一条路径会比其他路径长出两倍,相对于AVL树来说,红黑树是平衡。

学习日记 1019

基于STM32设计的智能水产养殖系统(华为云IOT)(152)

当前设计的智能水产养殖系统主控芯片采用STM32F103RCT6,可以实现对水位、水温、水混浊度和PH值等参数的监测和控制,并且支持定时投喂功能。通过连接华为云物联网平台,将传感器数据上传到服务器,并通过Qt设计的Android手机APP来获取设备上传的数据,从而实现对养殖环境的远程监测和控制。

8830

【红黑树】的详细实现(C++)

红黑树的介绍 红黑树(Red-Black Tree,简称R-B Tree),它一种特殊的二叉查找树。红黑树是特殊的二叉查找树,意味着它满足二叉查找树的特征:任意一个节点所包含的键值,大于等于左孩子的键值,小于等于右孩子的键值。除了具备该特性之外,红黑树还包括许多额外的信息。红黑树的每个节点上都有存储位表示节点的颜色,颜色是红(Red)或黑(Black)。 红黑树一棵在...

dielu7895的博客 253

【人工智能时代】-什么是MCP?本地如何开发MCP Server

MCP(Model Context Protocol)全称模型上下文协议,是由 Anthropic 推出的一种开放标准,旨在统一大型语言模型(LLM)与外部数据源和工具之间的通信协议。掌握更多的信息控制更多的工具在没有联网搜索之前,大模型的数据来源只有训练数据的时候以及推理我们告诉他的东西。所以后来的rag、知识库都是让AI掌握更多的信息,而MCP的出现是为了让大模型控制更多的工具,赋予更多能力。在本篇文章中,基于 Python 完成了一个简单的 MCP Server 的开发。

xiaoli8748的专栏 1994

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

红黑树实现源码(C++)

本文展示红黑树的源码,源码是作者由linux内核代码封装成C++类,然后再次封装成API函数的方式。 RBTree.h和RBTree.cpp是用c++类的方式实现了红黑树的封装,RbtAPI.h、RbtAPI.cpp实现了二次封装,更方便开发人员直接使用。 1、RBTree.h #ifndef RBTREE_H #define RBTREE_H #include "RbtAPI.h" #define RB_RED 0 #define RB_BLACK 1 typedef struct r..

freeland008的专栏 1081

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

红黑树的部分实现(C++)

红黑树的部分功能实现

2401_83456040的博客 752

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

红黑树的模拟实现(C++)

红黑树的概念回顾 红黑树,是一种二叉搜索树,但在每个结点上增加一个存储位表示结点的颜色,可以是Red(红色)或Black(黑色)。通过对任何一条从根到叶子的路径上各个结点着色方式的限制,红黑树确保没有一条路径会比其他路径长出俩倍,因而是接近平衡的。 见图 引发的疑问: 如何保证没有一条路径会比其他路径长出俩倍呢? 红黑树的性质 ...

qq_42591783的博客 575

数据结构初阶——红黑树的实现(C++)

红黑树是一种近似平衡的二叉搜索树,通过红黑节点和特定规则维持平衡。其核心性质包括:根节点为黑色、红色节点的子节点必须为黑色、从任一节点到叶节点的路径包含相同数量黑色节点。实现时默认新节点为红色,插入后通过变色和旋转(单旋或双旋)调整平衡。与严格平衡的AVL树相比,红黑树牺牲部分平衡性换取更高效的插入删除操作,实际应用更广泛。验证红黑树需检查二叉搜索树性质及红黑特性。红黑树整体实现包含节点定义、插入、旋转、查找等操作,复杂度为O(logN)。

2301_80065652的博客 2016

红黑树的介绍以及代码实现(C++)

红黑树简单介绍红黑树是一种满足: 根是黑色的 红色边必须为左子树,且不能有两条连续红边 不存在一个节点有2条红边 根节点到空节点的黑边相等 红黑树是一种大致平衡的二叉树,所以在插入、删除和查找操作时能保证在最坏的情况下时间复杂度为O(lgn)。 二叉搜索树在最坏情形下(当插入的元素是递增的时候),时间复杂度为O(n)。 所以红黑树在linux内核、构造关联数组等被大量使用。查找这个没什么好说,和

dawning 2737

数据结构:红黑树的插入实现(C++)

以上就是我对于红黑树插入实现的总结。!!

li209779的博客 980

模拟实现红黑树超详解(C++)

模拟实现红黑树,包括了红黑树的插入删除,正向迭代器和反向迭代器(两万字详解)

m0_67430750的博客 584

红黑树详解及代码实现(C++)

红黑树的简介和代码实现 包括旋转变色画图讲解

m0_59074850的博客 743

红黑树的实现(C++)

这是做数据结构的副产品。挺麻烦的一个东西,记录下来,以备以后只需。红黑树的规则我不说太多,网上的资料太多。代码之中,了无秘密:/********************************************************************Filename: RBTree.hCreatedTime:2008/06/20 10:55

但是 1153
上一篇: 解决VMware安装Windows11报错:这台电脑无法运行 Windows 11,这台电脑不符合安装此版本的 Windows 所需的最低系统要求。
下一篇: 使用火焰图(FlameGraph)分析程序性能
code_peak
博客等级 码龄5年 403粉丝 67原创
评论 3
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

code_peak

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

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

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

打赏作者

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

抵扣说明:

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

余额充值