手撕红黑树(kv模型模拟)

news2024/11/24 5:06:03

目录

前言

一、相关概念

二、性质介绍

红黑树平衡说明

三、红黑树模拟(kv结构)

1、红黑树节点

2、红黑树插入

2、特殊处理情况

声明:

情况一:cur为红,p为红,g为黑,u存在,且uncle为红色

情况二:cur为红,p为红,g为黑,u不存在

情况三:cur为红,p为红,g为黑,u存在且为黑

总结

四、红黑树的验证

1、检查中序

2、检测红黑树性质

3、调试

五、红黑树的性能

1、测试函数

2、随机值测试

3、AVL,红黑树对比测试

管理随机数据

管理有序数据

总结

结束语

附录1(红黑树模拟代码)

附录2(红黑树测试代码)


前言

        本篇博客介绍红黑树结构,通过模拟红黑树的插入,来深入理解红黑树的结构以及调整规则。

一、相关概念

        红黑树,也是一种二叉搜索树,但在每个结点上增加一个存储位表示结点的颜色,可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制,红黑树确保没有一条路径会比其他路径长出两倍,因而是接近平衡的,特别注意不是和AVL一样的绝对平衡


二、性质介绍

(1). 每个结点不是红色就是黑色,只有两种颜色的节点

(2). 根节点是黑色的

(3). 如果一个节点是红色的,则它的两个孩子结点是黑色的(无连续红色节点

(4). 对于每个结点,从该结点到其所有后代叶结点的简单路径上,均 包含相同数目的黑色结点(核心

(5). 每个叶子结点都是黑色的(此处的叶子结点指的是空结点)

        满足上面的性质,红黑树就能保证:其最长路径中节点个数不会超过最短路径节点个数的两倍。(路径是指从根节点走到空节点的路程)

红黑树平衡说明

        我们可以通过分析极端情况(不一定存在)下的现象来得到上述结论,即最短路径为全是黑色黑色节点,最长路径为一黑一红节点排列,此时我们可以发现最长路径是最短路径的两倍长度,但最长路径与最短路径的极端情况不一定会出现,极端情况都满足则说明所有情况都是满足其最长路径中节点个数不会超过最短路径节点个数的两倍。


三、红黑树模拟(kv结构)

1、红黑树节点

        包含节点的父节点指针(方便对于红黑树进行符合其性质的调整),左孩子指针右孩子指针颜色属性节点数据

        注意对于新初始化的节点默认颜色为红色。本来这个树的每条路径黑色节点数是相同的,假设你选定黑色节点的话,无论黑色节点添加在哪里,新增节点的路径上的黑色节点会加一,红黑树要求每个路径黑色节点数相同,树中所有路径都会受到影响,大面积的影响处理起来非常困难。假设你选择的是一个红色节点,如果添加在黑色节点下面,则整棵树仍然满足性质,不需要改变,添加在红色节点下面才需要处理(不能连续出现红色节点),直解决当前路径下出现的问题,大大化简了对红黑树的调整过程。

2、红黑树插入

        由于红黑树仍然是一颗搜索二叉树,所以按照二叉搜索的树规则插入新节点,具体的插入规则之前文章有详解,本篇文章主要讲述红黑树结构及其节点调整原理,对于之前的只是就不在赘述。

        假定插入节点前,树满足红黑树性质,插入节点完成后,要保证其最长路径中节点个数不会超过最短路径节点个数的两倍我们就要使这棵树仍然保持有红黑树的性质,要对红黑树性质遭到波坏的插入情况进行相应的调整。

2、特殊处理情况

        插入位置的父亲节点是黑色节点,父亲节点为黑色,插入红色节点后,红黑树的性质仍然存在,不需要处理。

        插入位置的父亲节点是红色节点,有连续红色节点,需要特殊处理,维护整棵树以及每一颗子树的红黑树性质。

        由于插入节点前树是满足红黑树性质的,那么根节点不可能是红色的,此时一定存在爷爷节点,且原来没有连续红色节点,所以爷爷节点一定为黑色。由于处理可能会一直向上更新到根节点,所以采用循环处理(先知道,后面会解释)。而对于这种问题的处理,有着不同的情况与处理方法,关键在uncle节点

声明:

        在此之前,我们先统一几个变量,以及相关声明

(1)、cur为当前节点,

(2)、父节点,parent,简称p

(3)、祖父节点,grandfather,简称g

(4)、叔叔节点,uncle,简称u

        声明:我们无法列举出所有的树形结构,以为树的结构具有多样性,对于子树衍生情况非常多,无法针对每一种树形结构定制处理办法。但是我们可以总结某一大类(树形结构)的解决办法,在这种大类下不破坏红黑树性质而衍生出来的各种树形结构,都可以使用这种方法处理。所以以下情况均是树形结构的大类,在其基础上可以有树的衍生,但必须是不破坏红黑树性质的合理衍生。

情况一:cur为红,p为红,g为黑,u存在,且uncle为红色

        我们不能将cur变黑,这样的话就相当于是插入一个黑色节点,其弊端在上文中已阐述。

        解决办法:将parent,uncle变黑色,grandfather变红色,如下图

当前大类所代表的树当作一颗完整的树,或是一颗子树(g可能是根节点,也可能不是)。

        如果g节点是根节点,那么调整完成后,将g改成黑色节点,如果是子树,g仍然有父节点,那么调整完成后,将g改成黑色节点。并且继续向上处理,把grandfather节点当作cur节点继续向上更新。因为g原来是黑色的,根据红黑树性质推得,如果它有父节点,那么他的父节点一定是红色的,当我们最终将g节点变为红色,那么又会出现连续得红色的节点,与性质相冲突。需要我们继续把g节点当作cur节点来继续更新颜色,解决这颗树出现的问题。

        在极端情况下可能出现,一直更新到根节点的情况,这也是我们为什么我们把由采用循环条件处理的原因(后面还会详细解释)。

        连续向上更新举例:

补充:

循环条件的解释:

        1、只有cur的p节点为红色时,才需要特殊处理,维护红黑树性质。在不断向上更新的时候,如果cur的节点为黑色,就相当于在当前节点下,添加了一个黑色节点,这正是我们不需要特殊处理的情况,此时便退出循环。

        2、当更新到根节点时候,parent节点不存在也要退出循环。

特别注意: 这种情况下,不关心cur,parent的相对位置无论parent的左孩子还是右孩子,cur是左孩子还是右孩子,处理方法都一样

情况二:cur为红,p为红,g为黑,u不存在

当u不存在时,cur一定是新插入的节点

        如果cur不是新插入的节点,而是经过一次处理更新上来的红色节点,根据情况一的更新方法判断cur为节点的子树一定有黑色节点,这样的话无uncle的那条路径上的黑色节点数就会小于cur所在的路径上的黑色节点数,不满足性质4,所以可以确定cur就是新增节点

在这种情况下个根据p节点与cur节点所处相对位置的不同,又划分为四种子情况

(1)、p为g的左孩子,cur为p的左孩子

右旋g,g变红,p变黑

(2)、p为g的左孩子,cur为p的右孩子

左旋p,右旋g,cur变黑,g变红

(3)、p为g的右孩子,cur为p的左孩子

右旋p,左旋g,cur变黑,g变红

(4)、p为g的右孩子,cur为p的右孩子

左旋g,g变红,p变黑

(对于左右旋的具体方法参考本人博客《AVL树模拟》,有很详细的介绍)

经过上述处理,以上情况对应变化为下图:

情况三:cur为红,p为红,g为黑,u存在且为黑

        如果cur是新插节点,那么在插入之前这棵树就已经违反了性质4,如上图增加cur之前,p节点所在的路径与u节点所在的路径黑色节点数并不相同,所以这种猜想是错误的。我们可以断定这种情况不是插入节点得到的树的结构,p节点所在路径的黑色节点等于u节点所在路径的黑色节点数,那么可以知道cur的子树中的路径应该是有1个黑色节点即分别在a,b的衍生中有且只有一个黑色节点),推测为是其他结构下插入新节点后,向上更新产生的一种情况,简单来说就是cur节点在插入之前是黑色的,被更新成了红色产生的新情况。如下是一种该情况产生的举例,当然还有其他情况(左图的u,p节点的子节点位置插入新节点)

当cur,p所处的相对位置不同,对应的处理方式又会不同,这里分化为四种子情况:

(1)、p为g的左孩子,cur为p的左孩子

右旋g,g变红,p变黑

(2)、p为g的左孩子,cur为p的右孩子

左旋p,右旋g,cur变黑,g变红

(3)、p为g的右孩子,cur为p的左孩子

右旋p,左旋g,cur变黑,g变红

(4)、p为g的右孩子,cur为p的右孩子

左旋g,g变红,p变黑

        在这里我们模拟第一种和第二种子情况的变换,第三种第四种变换和第一种第二种变换呈对称变换,可以尝试自己画一下。

第一种子类型:

第二种子类型:

总结

        结合情况二与情况三,我们可以发现连续红色节点出现时,p,cur节点相对位置相同(即子情况相同),无论是大条件是uncle不存在,还是uncle为黑色,他们对应相同子情况的解决办法都是相同的,对于节点的变色方法也相同,于是我们将二者合二为一。即cur为红,p为红,g为黑,u存在且为黑或者uncle不存在为一种情况。当cur,p所处的相对位置不同,产生的不同的子情况方法也对应合并:

(1)、p为g的左孩子,cur为p的左孩子

右旋g,g变红,p变黑

(2)、p为g的左孩子,cur为p的右孩子

左旋p,右旋g,cur变黑,g变红

(3)、p为g的右孩子,cur为p的左孩子

右旋p,左旋g,cur变黑,g变红

(4)、p为g的右孩子,cur为p的右孩子

左旋g,g变红,p变黑

注意:

        在情况二和情况三合并的情况处理之后,我们可以发现以子树的根节点开始的路径,插入前后路径上的黑色节点保持不变,而且处理之后这颗子树的根是黑色的,并不破环整棵树的红黑树性质,于是到这里我们就不需要继续向上更新了,在这里就直接退出这颗树的特殊处理(退出循环)


四、红黑树的验证

1、检查中序

        判断是否为有序排列,红黑树本身就是一颗搜索二叉树,所以必须要满足中序为有序排列。但仅此并不能说明它是一颗红黑树,我们必须要验证其红黑树的性质

2、检测红黑树性质

1、检查根节点是不是黑色

2、检查是否存在连红,遍历检查每个红色节点的parent节点,如果存在parent为红,那么就存在连续红色节点

3、检查每条路径的黑色节点数:

(1)求最左路径黑色节点数作为基准值

(2)递归记录当前节点下路径的黑色节点数

(3)走到空节点的时候判断,与基准值比较,看黑色节点数是否相同

细节:

        1、如果根为红色,提前返回错误

        2、以根节点开始向下不断递归展开,展开得到树中的每一条路径,并且记录着每条路径的黑色节点数;在展开的过程中会遍历到每一个节点,所以对连续红色节点的检测也结合在递归过程中,不需要额外遍历一次去检查连续红色节点的问题。

        3、递归子函数中,增加对黑色节点记录的参数(这是从根节点到当前节点的黑色节点数),如果节点为黑色则要对其+1带到更下一层的递归。特别注意这里不能使用引用参数,否则下一层黑色节点的更新会影响到上一层的计数,那么上一层再向其他子树递归展开时计数就会错误。在这里我们希望的是下一层的黑色节点数增加不会影响到上一层

3、调试

        和AVL树调试相同,插入一个值后就判断一次平衡,找到最先不平衡的插入点。之后再设置对应断点,逐步调试去查找问题。


五、红黑树的性能

1、测试函数

        为了对红黑树的性能有直观体现,我们又增加了一些函数来反映出他的效率,如树的高度,节点个数,查找效率,旋转调整次数等等。

树的高度

节点个数

查找函数

旋转次数

2、随机值测试

        对于千万级数据,插入效率与比较效率还不错

3、AVL,红黑树对比测试

        向AVL分别插入一千万个数据,对比效率(随机值,有序值)

管理随机数据

1、红黑树高度略高与AVL

2、AVL插入效率略高于红黑树,但两者效率在一个层次(都是log_2 N)

3、查找,红黑树肯定吃亏,因为AVL对于平衡的要求更加严格

4、红黑树的优势主要在,大大减少了旋转次数

管理有序数据

如果插入的是有序值,AVL更好一点,但实际中很少插入有序数列,参考意义不大

总结

        红黑树和AVL树都是高效的平衡二叉树,增删改查的时间复杂度都是O(log_2 N),红黑树不追求绝对平衡,其只需保证最长路径不超过最短路径的2倍,相对而言,降低了插入和旋转的次数,所以在经常进行增删的结构中性能比AVL树更优,而且红黑树实现比较简单,所以实际运用中红黑树更多,更多应用的是红黑树!!!


结束语

        本篇文章的内容就到此结束了,希望通过这篇博客大家能有所收获,有什么内容不明白的,大家可以在评论去向我提问,我会一一回答,当然有什么错误或者有什么不足的地方,希望大家可以包容并指出,后续还会更新对于红黑树的具体应用,红黑树迭代器模拟,封装map与set,在博客《红黑树大能量——map,set模拟》中,希望大家可以持续关注,向每一位读者送上真诚的小花。

        

附录1(红黑树模拟代码)

#pragma once
enum Color { RED, BLACK };

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

    Node* _parent;
    Node* _left;
    Node* _right;
    Color _col;
    pair<K, V> _kv;

    RBTreeNode(const pair<K, V>& kv)
        :_parent(nullptr),
        _left(nullptr),
        _right(nullptr),
        _col(RED),//新插入节点为红色,初始化节点时,直接给红色
        //如果给黑色,会影响到所有路径
        _kv(kv)
    {}
};

template<class K, class V>
class 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 (kv.first > cur->_kv.first)
            {
                parent = cur;
                cur = cur->_right;
            }
            else if (kv.first < cur->_kv.first)
            {
                parent = cur;
                cur = cur->_left;
            }
            else
                return false;
        }
        //插入新节点,并且与parent进行链接
        cur = new Node(kv);
        if (kv.first < parent->_kv.first)
        {
            parent->_left = cur;
        }
        else
        {
            parent->_right = cur;
        }
        cur->_parent = parent;

        //父亲节点为黑色,插入成功,不需要处理(不进入循环)
        //if (parent->_col == BLACK)
        //    return true;
 

        //父亲节点为红色,有连续红色,需要特殊处理,此时一定存在爷爷节点

        Node* grandfather = nullptr; 
        Node* uncle = nullptr;
        while (parent && parent->_col == RED)
        {
            //父亲节点为红色,有连续红色,需要特殊处理,此时一定存在爷爷节点
            grandfather = parent->_parent;
            //一、parent在grandfather的左边,说明uncle在右边
            if (parent == grandfather->_left)
            {
                uncle = grandfather->_right;

                //1、uncle存在,且uncle为红色
                //parent,uncle变黑色,grandfather变红色,并且继续向上处理
                //*********   不关心uncle的方向   *******
                if (uncle && uncle->_col == RED)
                {
                    parent->_col = uncle->_col = BLACK;
                    grandfather->_col = RED;

                    //需要继续向上处理,直到退出循环;
                    cur = grandfather;
                    parent = cur->_parent;
                }
                //2、uncle不存在,或者uncle存在且为黑色,        利用旋转的方式处理,
                //**********   uncle左右位置不同,处理方式不同
                else
                {
                    //(1)cur是parent的左边,右旋grandfather,
                    // 变色:p变黑,g变红
                    //          g
                    //       p     u
                    //     c
                    if (cur == parent->_left)
                    {
                        RotateR(grandfather);
                        grandfather->_col = RED;
                        parent->_col = BLACK;
                    }

                    //(2)cur是parent的有右边,左旋parent,右旋grandfather
                    //变色: c变黑,g变红
                    //          g
                    //       p     u
                    //         c
                    else
                    {
                        RotateL(parent);
                        RotateR(grandfather);
                        grandfather->_col = RED;
                        cur->_col = BLACK;
                    }

                    //旋转后以grandfather为根的子树每条路径的黑色节点数与没插入之前相同,不影响其他路径,不继续向上处理,退出循环
                    //处理完根是黑的,直接退出;
                    break;
                }
            }
            //二、parent在grandfather的右边,说明uncle在左边
            else
            {
                uncle = grandfather->_left;

                //1、uncle存在,且uncle为红色
                //parent,uncle变黑色,grandfather变红色,并且继续向上处理
                //*********   不关心uncle的方向   *******
                if (uncle && uncle->_col == RED)
                {
                    parent->_col = uncle->_col = BLACK;
                    grandfather->_col = RED;

                    //需要继续向上处理,直到退出循环;
                    cur = grandfather;
                    parent = cur->_parent;
                }
                //2、uncle不存在,或者uncle存在且为黑色              利用旋转的方式处理
                //**********   uncle左右位置不同,处理方式不同
                else
                {
                    //(1)cur是parent的右边,左旋grandfather,
                    // 变色:p变黑,g变红
                    //          g
                    //       u     p
                    //               c
                    if (cur == parent->_right)
                    {
                        RotateL(grandfather);
                        grandfather->_col = RED;
                        parent->_col = BLACK;
                    }

                    //(2)cur是parent的左边,右旋parent,左旋grandfather
                    //变色: c变黑,g变红
                    //          g
                    //       u     p
                    //           c
                    else
                    {
                        RotateR(parent);
                        RotateL(grandfather);
                        grandfather->_col = RED;
                        cur->_col = BLACK;
                    }
                    //旋转后以grandfather为根的子树每条路径的黑色节点数与没插入之前相同,不影响其他路径,不继续向上处理,退出循环;
                    //处理完根是黑的,直接退出;
                    break;
                }
            }
        }
        //最后让根节点的颜色一定为黑色,不在循环里面单独判断是否为根节点
        _root->_col = BLACK;
        return true;
    }
    void RotateL(Node * parent)
    {
        Node* subR = parent->_right;
        Node* subRL = subR->_left;

        //处理parent与subRL新关系的链接
        parent->_right = subRL;
        //subRL不为空,其父节点指向parent
        if (subRL)
            subRL->_parent = parent;

        //处理parent与subR新关系的链接
        subR->_left = parent;
        Node* ppnode = parent->_parent;//保存旧parent的父亲节点与subR节点链接
        parent->_parent = subR;

        //处理parent的父亲节点与subR节点链接
        //parent可能是根节点
        if (_root == parent)
        {
            _root = subR;
            subR->_parent = nullptr;
        }
        else
        {
            if (parent == ppnode->_left)
                ppnode->_left = subR;
            else
                ppnode->_right = subR;
            subR->_parent = ppnode;
        }
        ++Rotatesize;
    }
    //右旋
    void RotateR(Node * 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;
            subL->_parent = nullptr;
        }
        else
        {
            if (ppnode->_left == parent)
            {
                ppnode->_left = subL;
            }
            else
            {
                ppnode->_right = subL;
            }
            subL->_parent = ppnode;
        }
        ++Rotatesize;
    }

    //中序遍历
    void Inorder()
    {
        _inorder(_root);
        cout << "end" << endl;
    }
    void _inorder(Node* root)
    {
        if (root == nullptr)
            return;
        _inorder(root->_left);
        cout << root->_kv.first << ":" << root->_kv.second << endl;
        _inorder(root->_right);
    }

    //红黑树规则测试
    //1、检查根节点是不是黑色
    //2、检查是否存在连红,遍历检查每个红色节点的parent节点,如果存在parent为红,那么就存在连红
    //3、检查每条路径的黑色节点数
    //(1)求最左路径黑色节点数作为基准值
    //(2)递归记录当前节点路径,黑色节点数
    //(3)走到空节点的时候判断,与基准值比较
    bool isBalance()
    {
        if (_root&&_root->_col == RED)
            return false;
        Node* cur = _root;
        int refblacknum = 0;
        while (cur)
        {
            if (cur->_col == BLACK)
            {
                ++refblacknum;
            }
            cur = cur->_left;
        }
            return check(_root, refblacknum, 0);
    }
    bool check(Node* root,int& refblacknum,int blacknum) //采用按值传参,下一层不影响上一层
    {
        if (root == nullptr)
        {
            if (blacknum == refblacknum)
            {
                return true;
            }
            cout << "黑色节点数不相等" << endl;
            return false;
        }
        if (root->_col == RED && root->_parent->_col == RED)
        {
            cout << root->_kv.first<<"有连续的红色节点" << endl;
            return false;
        }
        if (root->_col == BLACK)
            ++blacknum;
        return check(root->_left, refblacknum,blacknum) && check(root->_right, refblacknum, blacknum);
    }

    //求当前树的高度
    int Height()
    {
        return height(_root);
    }
    //求高度子函数
    int height(Node* root)
    {
        if (root == nullptr)
            return 0;
        int lefth = height(root->_left);
        int righth = height(root->_right);
        return lefth > righth ? lefth + 1 : righth + 1;
    }
    //树的节点个数
    size_t Size()
    {
        return _Size(_root);
    }
    size_t _Size(Node* root)
    {
        if (root == NULL)
            return 0;

        return _Size(root->_left)
            + _Size(root->_right) + 1;
    }


    //查找节点
    Node* Find(const K& key)
    {
        Node* cur = _root;
        while (cur)
        {
            if (cur->_kv.first < key)
            {
                cur = cur->_right;
            }
            else if (cur->_kv.first > key)
            {
                cur = cur->_left;
            }
            else
            {
                return cur;
            }
        }

        return NULL;
    }
    int GetRotatesize()
    {
        return Rotatesize;
    }
  
private:
    Node* _root = nullptr;
    int Rotatesize = 0;
    };

附录2(红黑树测试代码)

#include<iostream>
using namespace std;

#include<vector>
#include"RBTree.h"
#include"AVLtree.h"

void test1()
{
		//int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
		int a[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14,16, 3, 7, 11, 9, 26, 18, 14, 15 };
		RBTree<int, int> t;
		for (auto e : a)
		{
			if (e == 14)
			{
				int x = 0;
			}
			t.Insert(make_pair(e, e));
			//cout <<e<<"->" << t.isBalance() << endl;
		}

		t.Inorder();
		cout << t.isBalance() << endl;

}

void test2()
{
	const int N = 10000000;
	vector<int> v;
	v.reserve(N);
	srand((size_t)time(0));
	for (size_t i = 0; i < N; i++)
	{
		v.push_back(rand() + i);

	}

	size_t begin2 = clock();
	RBTree<int, int> t;
	for (auto e : v)
	{
		t.Insert(make_pair(e, e));
	}
	size_t end2 = clock();
	cout << "Insert:" << end2 - begin2 << endl;
	cout << t.isBalance() << endl;
	cout << "Height:" << t.Height() << endl;
	cout << "Size:" << t.Size() << endl;

	size_t begin1 = clock();
	// 确定在的值
	for (auto e : v)
	{
		t.Find(e);
	}

	// 随机值
	for (size_t i = 0; i < N; i++)
	{
		t.Find((rand() + i));
	}

	size_t end1 = clock();

	cout << "Find:" << end1 - begin1 << endl;
}

void test3()
{
	//调试出来的错误为,退出循环写错了位置,导致uncle为红色结束后直接退出了
	const int N = 20;
	vector<int> v;
	v.reserve(N);
	//srand(time(0));

	for (size_t i = 0; i < N; i++)
	{
		v.push_back(rand()%100);
	}

	RBTree<int, int> t;
	for (auto e : v)
	{
		if (e == 64)
		{
			int x = 0;
		}
		t.Insert(make_pair(e, e));
		cout <<e<<"->" <<t.isBalance() << endl;
	}
	cout << t.isBalance() << endl;
}


//1、红黑树高度略高与AVL
//2、AVL插入效率略高于红黑树,但两者效率再一个层次,
//3、如果插入的是有序值,AVL更好一点
//4、红黑树的优势主要在,大大减少了旋转次数
//5、查找,红黑树肯定吃亏
//*************************更多应用是红黑树
void RBTree_AVL_Compare()
{

	const int N = 10000000;
	vector<int> v;
	v.reserve(N);
	srand(time(0));
	for (size_t i = 0; i < N; i++)
	{
		//v.push_back(rand() + i);//随机值
		v.push_back(i);         //有序值
	}
	RBTree<int, int> t1;
	AVLTree<int, int> t2;

	size_t begin1 = clock();
	for (auto e : v)
	{
		t1.Insert(make_pair(e, e));
	}
	size_t end1 = clock();

	size_t begin2 = clock();
	for (auto e : v)
	{
		t2.Insert(make_pair(e, e));
	}
	size_t end2 = clock();

	size_t begin3 = clock();
	// 确定在的值
	for (auto e : v)
	{
		t1.Find(e);
	}

	// 随机值
	/*for (size_t i = 0; i < N; i++)
	{
		t1.Find((rand() + i));
	}*/

	size_t end3 = clock();

	size_t begin4 = clock();
	// 确定在的值
	for (auto e : v)
	{
		t2.Find(e);
	}

	// 随机值
	/*for (size_t i = 0; i < N; i++)
	{
		t2.Find((rand() + i));
	}*/

	size_t end4 = clock();


	cout << "RBTree RoateSize:" << t1.GetRotatesize() << endl;
	cout << "AVLTree RoateSize:" << t2.GetRotatesize() << endl << endl;


	cout << "RBTree Insert:" << end1 - begin1 << endl;
	cout << "AVLTree Insert:" << end2 - begin2 << endl << endl;

	cout << "RBTree IsBalance:" << t1.isBalance() << endl;
	cout << "AVLTree IsBalance:" << t2.isBalance() << endl << endl;

	cout << "RBTree Height:" << t1.Height() << endl;
	cout << "AVLTree Height:" << t2.Height() << endl<< endl;

	cout << "AVLTree Size:" << t2.Size() << endl ;
	cout << "RBTree Size:" << t1.Size() << endl << endl;

	cout << "RBTree Find:" << end3 - begin3 << endl;
	cout << "AVLTree Find:" << end4 - begin4 << endl<<endl;

}
int main()
{
	//test1();
	


	//test2();


	//test3();//调试出来了很隐蔽的错误

	RBTree_AVL_Compare();

	return 0;
}

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/1631002.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

高频面试题:解决Spring框架中的循环依赖问题

引言&#xff1a;什么是Spring框架与循环依赖&#xff1f; 在Spring框架中&#xff0c;循环依赖是指两个或多个bean相互依赖对方以完成自己的初始化。这种依赖关系形成了一个闭环&#xff0c;导致无法顺利完成依赖注入。比如&#xff0c;如果Bean A在其构造函数中需要Bean B&a…

【python笔记】datafram的时间动态可视化 pyecharts地图

import pandas as pd# 假设DataFrame是这样的&#xff1a; df pd.DataFrame({ year: [2014, 2015, 2016, 2014, 2015, 2016, 2014, 2015, 2016], province: [广东省, 广东省, 河南省, 湖南省, 北京市, 北京市, 上海市, 新疆维吾尔自治区, 上海市], values: [100, 150, 75…

添加阿里云yum源

添加阿里云yum源 要添加阿里云的 yum 源&#xff0c;可以执行以下步骤&#xff1a; 首先&#xff0c;备份你的现有 yum 源配置文件&#xff0c;以防止意外更改&#xff1a; sudo cp /etc/yum.repos.d/CentOS-Base.repo /etc/yum.repos.d/CentOS-Base.repo.backup然后&#xf…

基于OpenMV 双轴机械臂 机器学习

文章目录 一、项目简要二、目标追踪1. 色块识别与最大色块筛选2. PID位置闭环 三、机器学习1. Device12. Device2 四、效果演示 一、项目简要 两套二维云台设备&#xff0c;Device1通过摄像头捕捉目标物块点位进行实时追踪&#xff0c;再将自身点位传到Device2&#xff0c;Dev…

嵌入式学习64-C++(labmda和动态内存分配)

知识回顾&#xff1a; Volatile关键字的作用 C vector容器详解 浅谈堆、栈、堆区、栈区的概念和区别 知识零碎&#xff1a; …

Git for Windows 下载与安装

当前环境&#xff1a;Windows 8.1 x64 1 打开网站 https://git-scm.com/ &#xff0c;点击 Downloads 。 2 点击 Windows 。 3 选择合适的版本&#xff0c;这里选择了 32-bit Git for Windows Portable。 4 解压下载后的 PortableGit-2.44.0-32-bit.7z.exe &#xff0c;并将 P…

2-3 任务:成绩等级评定

在编程中&#xff0c;多分支结构是控制程序流程的重要手段之一&#xff0c;它允许根据不同的条件执行不同的代码块。在处理成绩等级评定的任务时&#xff0c;我们可以看到有四种不同的多分支结构处理方式&#xff1a;并列式、嵌套式、延拓式和开关式。每种方式都有其优缺点&…

上位机开发PyQt5(一)【创建窗口、窗口标题、气泡、显示图片和图标、显示文字】

目录 一、 第一个Qt窗口 二、PyQt模块简介 三、窗口标题和气泡 setWindowTitle resize setToolTip 四、标签QLabel显示图片和图标 setPixmap setWindowIcon resize(label.pixmap().size()) 五、标签QLabel显示文字 setText QFont setPointSize setFont set…

Python —— 模块、包

一、模块和包 1. 模块module 模块是 Python 程序架构的一个核心概念。Python中模块就是一个.py文件&#xff0c;模块中可以定义函数&#xff0c;变量&#xff0c;类。模块可以被其他模块引用 1.1. 创建模块文件 创建文件&#xff1a;utils.py # 定义变量 name 张三# 定义函…

【论文阅读】ViTAE:Vision transformer advanced by exploring intrinsic inductive bias

ViTAE:Vision transformer advanced by exploring intrinsic inductive bias 论文地址摘要&#xff1a;简介&#xff1a;3 方法论3.1 重温视觉变压器3.2 ViTAE3.3 缩减单元3.4 Normal cell3.5 模型细节 4 训练4.1 Implementation details4.2 Comparison with the state-of-the-…

选择洗地机需要注意什么?六大选购技巧,亲测有效

这些年&#xff0c;洗地机行业的「卷」&#xff0c;就从来没停过&#xff01;特别是最近一两年&#xff0c;随随便便升级点啥&#xff0c;都能出个新款&#xff01;那么&#xff0c;面对种类繁多的洗地机&#xff0c;我们应该怎么去选购呢&#xff1f;今天笔者来给大家讲讲选择…

怎么通过PHP语言实现远程控制棋牌室

怎么通过PHP语言实现远程控制棋牌室呢&#xff1f; 本文描述了使用PHP语言调用HTTP接口&#xff0c;实现控制棋牌室&#xff0c;通过专用的包间控制器&#xff0c;来实现包间内所有电器以及门锁的独立控制。 可选用产品&#xff1a;可根据实际场景需求&#xff0c;选择对应的规…

穷人想要改命,是选择打工还是创业? 2024创业项目小成本!2024轻资产创业!2024风口行业!2024普通人做什么行业赚钱?

今日话题穷人想要改命&#xff0c;是选择打工还是创业&#xff1f; 改命的方式就是跳进水里&#xff0c;忍受呛水&#xff0c;学会游泳&#xff0c;这个过程越年轻实现越好&#xff0c;就像小鹰往山崖下跳&#xff0c;要么学会飞&#xff0c;要么就狠狠的被摔死。打工思维和创…

请编写函数fun,该函数的功能是:实现B=A+A‘,即把矩阵A加上A的转置,存放在矩阵B中。计算结果在main函数中输出。

本文收录于专栏:算法之翼 https://blog.csdn.net/weixin_52908342/category_10943144.html 订阅后本专栏全部文章可见。 本文含有题目的题干、解题思路、解题思路、解题代码、代码解析。本文分别包含C语言、C++、Java、Python四种语言的解法完整代码和详细的解析。 题干 请编…

回归预测 | MATLAB实现BO-BP贝叶斯优化BP神经网络多输入单输出回归预测

回归预测 | MATLAB实现BO-BP贝叶斯优化BP神经网络多输入单输出回归预测 目录 回归预测 | MATLAB实现BO-BP贝叶斯优化BP神经网络多输入单输出回归预测预测效果基本介绍程序设计参考资料预测效果 基本介绍 回归预测 | MATLAB实现BO-BP贝叶斯优化BP神经网络多输入单输出回归预测 B…

【论文阅读】互连网络的负载平衡路由算法 (GAL, Globally Adaptive Load-balancing 全局自适应负载平衡)

Globally Adaptive Load-balancing 全局自适应负载平衡 GAL: Globally Adaptive Load-balanced routing 全局自适应负载平衡路由 1. GAL on a ring2. GAL on higher dimensional torus3. 实验性能4. 算法稳定性 Stability总结 References Globally Adaptive Load-balancing 全…

node.js + @elastic/elasticsearch 操作elasticsearch数据库

我这边node.js 使用的是 koa2&#xff0c;elasticsearch是8.11.1版本 官网&#xff1a;https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/getting-started-js.html 一、elastic/elasticsearch 连接 elasticsearch数据库 如果elasticsearch没有设…

开发模型???

开发模型??? 一:什么是需求??二:开发模型2.1:软件的生命周期2.1.1:软件生命周期 2.2:常见开发模型2.2.1:瀑布模型2.2.2:螺旋模型2.2.3:增量模型 && 迭代模型 二级目录 一级目录二级目录二级目录二级目录三级目录 一:什么是需求?? 用户需求:通常就是一句话,没有…

网络原理(qq消息发送原理)

1.网络初识 IP地址 概念&#xff1a; IP地址主要⽤于标识⽹络主机、其他⽹络设备&#xff08;如路由器&#xff09;的⽹络地址。简单说&#xff0c;IP地址⽤于定位主机的⽹络地址。 就像我们发送快递⼀样&#xff0c;需要知道对⽅的收货地址&#xff0c;快递员才能将包裹送到…