• 【C++ 学习 ㉒】- 超详解 AVL 树的插入、平衡调整以及删除（含源代码）

    目录

    一、AVL 树的概念

    二、AVL 树节点的定义

    三、AVL 树的插入

    四、AVL 树的平衡调整

    五、AVL 树的删除

    六、AVL 树的实现

    6.1 - AVL.h

    6.2 - test.cpp

     

    一、AVL 树的概念

    二叉搜索树查找算法的性能取决于二叉树搜索树的形状，而二叉搜索树的形状则取决于数据集。如果数据呈有序排列，则二叉搜索树为单支树，查找的时间复杂度为 O(n)；反之，如果二叉搜索树的形状合理，则查找速度较快，查找的时间复杂度为 O(log_2^n)。事实上，树的高度越小，查找速度越快，因此，希望二叉树的高度尽可能小。下面将讨论一种特殊类型的二叉搜索树，称为平衡二叉树（Balanced Binary Tree 或 Height-Balanced Tree），因由前苏联数学家 Adelson-Velskii 和 Landis 提出，所以又称 AVL 树。

    平衡二叉树或者是空树，或者是具有如下特征的二叉搜索树：

    1. 左子树和右子树的高度之差的绝对值不超过 1。

    2. 左子树和右子树也是平衡二叉树。

    若将二叉树上节点的平衡因子（BF, Balance Factor）定义为该节点左子树和右子树的高度之差，则平衡二叉树上的所有节点的平衡因子只可能是 -1、0 和 1。只要二叉树上有一个节点的平衡因子的绝对值大于 1，则该二叉树就是不平衡。

    例如，下面图 (a) 所示为两棵平衡二叉树，图 (b) 所示则为两棵不平衡的二叉树，节点中的值为该结点的平衡因子。

    因为 AVL 树上任何节点的左右子树的高度之差都不超过 1，则可以证明它的深度和 log_2^n 是同数量级的（其中 n 为节点个数）。由此，其查找的时间复杂度是 O(log_2^n)。

    二、AVL 树节点的定义

    1. template<class K, class V>
    2. struct AVLNode
    3. {
    4.     AVLNode* _left;
    5.     AVLNode* _right;
    6.     AVLNode* _parent;
    7.     std::pair _kv;
    8.     int _bf;
    9. ​
    10.     AVLNode(const std::pair& kv = std::pair())
    11.         : _left(nullptr), _right(nullptr), _parent(nullptr), _kv(kv), _bf(0)
    12.     { } 
    13. };

    三、AVL 树的插入

    当新增的节点 *cur（指向节点的指针为 cur） 插入到其双亲节点 *parent（指向节点的指针为 parent）的左边时，双亲节点的平衡因子 +1；反之，当新增的节点插入到其双亲节点的右边时，双亲节点的平衡因子 -1。

    1. 若双亲节点的平衡因子原来为 -1 或者 1，在它的左边或者右边插入新增的节点后，它的平衡因子变为 0。由于以 *parent 为根节点的子树的高度没有发生变化，因此也不会影响除 *parent 以外的其它祖先节点的平衡因子，插入完成。

    2. 若双亲节点的平衡因子原来为 0，在它的左边或者右边插入新增的节点后，它的平衡因子变为 1 或者 -1。由于以 *parent 为根节点的子树的高度增高了 1，此时也就会影响其它祖先节点的平衡因子，需要往上更新。

      往上更新其它祖先节点的平衡因子的方式和一开始插入新增节点 *cur 时更新其双亲节点 *parent 的平衡因子的方式是一样的，即如果 *cur 在祖先节点的左子树中，则祖先节点的平衡因子 +1；如果 *cur 在祖先节点的右子树中，则祖先节点的平衡因子 -1。

      • 如果祖先节点的平衡因子被更新为 0，则说明更新完成了，也意味着插入完成了。

      • 如果祖先节点的平衡因子被更新为 1 或者 -1，则说明还需要继续往上更新，直到某个祖先节点的平衡因子被更新为 0，或者直到更新完根节点，当根节点的平衡因子被更新为 0、1 或者 -1 时，意味着更新和插入也都完成了。

      • 如果祖先节点的平衡因子被更新为 2 或者 -2（即其较高的子树增高了），就需要对以该节点为根节点的子树（称为最小不平衡子树）做平衡调整来恢复平衡。

    四、AVL 树的平衡调整

    假设最小不平衡子树的根节点为 A，则失去平衡后进行调整的规律可归纳为下列 4 种情况。

    1. LL 型：由于在 A 左子树根节点的左子树上插入节点，A 的平衡因子由 1 增至 2，致使以 A 为根节点的子树失去平衡，则需进行一次向右的顺时针旋转操作。

      1. void LL(Node* pA)
      2. {
      3.     Node* pB = pA->_left;
      4.     Node* pBR = pB->_right;
      5. ​
      6.     pA->_left = pBR;
      7.     if (pBR)
      8.         pBR->_parent = pA;
      9. ​
      10.     pB->_right = pA;
      11.     Node* tmp = pA->_parent;
      12.     pA->_parent = pB;
      13.     pB->_parent = tmp;
      14. ​
      15.     if (tmp == nullptr)  // 或者 _root == pA
      16.     {
      17.         _root = pB;
      18.     }
      19.     else
      20.     {
      21.         if (tmp->_left == pA)
      22.             tmp->_left = pB;
      23.         else
      24.             tmp->_right = pB;
      25.     }
      26. ​
      27.     pA->_bf = pB->_bf = 0;
      28. }

    2. RR 型：由于在 A 的右子树根节点的右子树上插入节点，A 的平衡因子由 -1 变成 -2，致使以 A 为根节点的子树失去平衡，则需进行一次向左的逆时针旋转操作。

      1. void RR(Node* pA)
      2. {
      3.     Node* pB = pA->_right;
      4.     Node* pBL = pB->_left;
      5. ​
      6.     pA->_right = pBL;
      7.     if (pBL)
      8.         pBL->_parent = pA;
      9. ​
      10.     pB->_left = pA;
      11.     Node* tmp = pA->_parent;
      12.     pA->_parent = pB;
      13.     pB->_parent = tmp;
      14. ​
      15.     if (tmp == nullptr)  // 或者 _root == pA
      16.     {
      17.         _root = pB;
      18.     }
      19.     else
      20.     {
      21.         if (tmp->_left == pA)
      22.             tmp->_left = pB;
      23.         else
      24.             tmp->_right = pB;
      25.     }
      26. ​
      27.     pA->_bf = pB->_bf = 0;
      28. }

    3. LR 型：由于在 A 的左子树的根节点的右子树上插入节点，A 的平衡因子由 1 增至 2，致使以 A 为根节点的子树失去平衡，则需要进行两次旋转操作。

      1. void LR(Node* pA)
      2. {
      3.     Node* pB = pA->_left;
      4.     Node* pC = pB->_right;
      5.     int bf = pC->_bf;
      6. ​
      7.     RR(pB);
      8.     LL(pA);
      9. ​
      10.     if (bf == 0)  // LR（0）型
      11.     {
      12.         pA->_bf = 0;
      13.         pB->_bf = 0;
      14.         pC->_bf = 0;
      15.     }
      16.     else if (bf == 1)  // LR（L）型
      17.     {
      18.         pA->_bf = -1;
      19.         pB->_bf = 0;
      20.         pC->_bf = 0;
      21.     }
      22.     else if (bf == -1)  // LR（R）型
      23.     {
      24.         pA->_bf = 0;
      25.         pB->_bf = 1;
      26.         pC->_bf = 0;
      27.     }
      28. }

    4. RL 型：由于在 A 的右子树根节点的左子树上插入节点，A 的平衡因子由 -1 变为 -2，致使以 A 为根节点的子树失去平衡，则旋转方法和 LR 型对称，也需进行两次旋转，先顺时针右旋，再逆时针左旋。

      1. void RL(Node* pA)
      2. {
      3.     Node* pB = pA->_right;
      4.     Node* pC = pB->_left;
      5.     int bf = pC->_bf;
      6. ​
      7.     LL(pB);
      8.     RR(pA);
      9. ​
      10.     if (bf == 0)  // RL（0）型
      11.     {
      12.         pA->_bf = 0;
      13.         pB->_bf = 0;
      14.         pC->_bf = 0;
      15.     }
      16.     else if (bf == 1)  // RL（L）型
      17.     {
      18.         pA->_bf = 0;
      19.         pB->_bf = -1;
      20.         pC->_bf = 0;
      21.     }
      22.     else if (bf == -1)  // RL（R）型
      23.     {
      24.         pA->_bf = 1;
      25.         pB->_bf = 0;
      26.         pC->_bf = 0;
      27.     }
      28. }

    总结：无论哪一种情况，在经过平衡旋转处理之后，以 B 或 C 为根的新子树为平衡二叉树，而且它们的高度和插入之前以 A 为根的子树相同。因此，当平衡的二叉搜索树因插入节点而失去平衡时，仅需对最小不平衡子树进行平衡旋转处理即可。

    五、AVL 树的删除

    AVL 树的删除算法与二叉搜索树类似，不同之处在于：若删除后破坏了 AVL 树的高度平衡性质，还需要做平衡化旋转。

    1. 如果被删节点 *cur 的左、右子树都不为空。首先找到左子树中键值最大的节点 *leftMax（或者找到右子树中键值最小的节点 *rightMin），然后进行交换，即 std::swap(cur->_kv, leftMax->_kv);， 此时被删节点就变成了 *leftMax，该节点的右子树一定为空。

    2. 如果被删节点 *cur 最多只有一个孩子 *child。可以把 *cur 的双亲节点 *parent 中原来指向 *cur 的指针改为指向 *child。如果 *cur 没有孩子，则 *parent 的相应指针置为 nullptr。由于以 *parent 为根节点的子树的高度缩短了 1，所以需沿着 *parent 通向根节点的路径，往上追踪高度的这一变化对路径上各个节点的影响。

    考查 *cur 的祖先节点，若 *cur 在祖先节点的左子树中，则祖先节点的平衡因子 -1，反之，则祖先节点的平衡因子 +1。根据祖先节点更新后的平衡因子，按以下三种情况分别进行处理：

    1. 祖先节点的平衡因子原来为 0，在它的左子树或者右子树被缩短后，它的平衡因子变为 -1 或者 1。由于以该节点为根的子树的高度没有改变，则不需要往上更新了，删除结束。

    2. 祖先节点的平衡因子原来为 1 或者 -1，在它的较高的子树被缩短后，它的平衡因子改为 0。此时以该节点为根的子树平衡，但其高度减 1，所以需要继续往上更新。

    3. 祖先节点的平衡因子原来为 -1 或者 1，在它的较矮的子树被缩短后，它的平衡因子变为 -2 或者 2。此时以该节点为根的子树不平衡，需要进行平衡化旋转来恢复平衡。

      根据祖先节点较高的子树的根（该子树未被缩短）的平衡因子，有如下 3 种平衡化操作：

      (1) 如果祖先节点较高的子树的根的平衡因子为 0，则执行一个单旋转来恢复子树的平衡。

      由于旋转平衡后以 *q 为根节点的子树的高度没有发生改变，所以不需要再往上更新了，删除结束。

      (2) 如果祖先节点较高的子树的根的平衡因子和祖先节点的平衡因子的正负号相同，则执行一个单旋转来恢复平衡。

      由于经过旋转平衡旋转后以 *q 为根节点的子树的高度降低了 1，所以需要继续往上更新。

      (3) 如果祖先节点较高的子树的根的平衡因子和祖先节点的平衡因子的正负号相反，则执行一个双旋转来恢复平衡。

      由于经过平衡化处理后以 *r 为根的子树的高度降低了 1，所以还需要继续往上更新。

    六、AVL 树的实现

    6.1 - AVL.h

    1. #pragma once
    2. ​
    3. #include 
    4. ​
    5. template<class K, class V>
    6. struct AVLNode
    7. {
    8.     AVLNode* _left;
    9.     AVLNode* _right;
    10.     AVLNode* _parent;
    11.     std::pair _kv;
    12.     int _bf;
    13. ​
    14.     AVLNode(const std::pair& kv = std::pair())
    15.         : _left(nullptr), _right(nullptr), _parent(nullptr), _kv(kv), _bf(0)
    16.     { } 
    17. };
    18. ​
    19. template<class K, class V>
    20. class AVL
    21. {
    22.     typedef AVLNode Node;
    23. public:
    24.     AVL() : _root(nullptr) { }
    25. ​
    26.     ~AVL()
    27.     {
    28.         Destroy(_root);
    29.     }
    30. ​
    31.     bool isBalanced() const
    32.     {
    33.         return _isBalanced(_root);
    34.     }
    35. ​
    36.     bool insert(const std::pair& kv)
    37.     {
    38.         if (_root == nullptr)
    39.         {
    40.             _root = new Node(kv);
    41.             return true;
    42.         }
    43. ​
    44.         Node* parent = nullptr;
    45.         Node* cur = _root;
    46.         while (cur)
    47.         {
    48.             parent = cur;
    49.             if (kv.first < cur->_kv.first)
    50.                 cur = cur->_left;
    51.             else if (kv.first > cur->_kv.first)
    52.                 cur = cur->_right;
    53.             else
    54.                 return false;
    55.         }
    56. ​
    57.         cur = new Node(kv);
    58.         if (kv.first < parent->_kv.first)
    59.             parent->_left = cur;
    60.         else
    61.             parent->_right = cur;
    62.         cur->_parent = parent;  // 注意：这一步很容易被忽略
    63. ​
    64.         // 往上更新 *cur 的祖先节点的平衡因子
    65.         while (parent)
    66.         {
    67.             if (parent->_left == cur)
    68.                 ++parent->_bf;
    69.             else
    70.                 --parent->_bf;
    71. ​
    72.             if (parent->_bf == 0)
    73.             {
    74.                 break;
    75.             }
    76.             else if (parent->_bf == 1 || parent->_bf == -1)
    77.             {
    78.                 cur = parent;
    79.                 parent = parent->_parent;
    80.             }
    81.             else if (parent->_bf == 2 || parent->_bf == -2)
    82.             {
    83.                 // 平衡二叉树的平衡调整
    84.                 if (parent->_bf == 2 && cur->_bf == 1)
    85.                     LL(parent);
    86.                 else if (parent->_bf == -2 && cur->_bf == -1)
    87.                     RR(parent);
    88.                 else if (parent->_bf == 2 && cur->_bf == -1)
    89.                     LR(parent);
    90.                 else if (parent->_bf == -2 && cur->_bf == 1)
    91.                     RL(parent);
    92.                 // 跳出循环
    93.                 break;
    94.             }
    95.         }
    96.         return true;
    97.     }
    98. ​
    99.     bool erase(const std::pair& kv)
    100.     {
    101.         Node* parent = nullptr;
    102.         Node* cur = _root;
    103.         while (cur)
    104.         {
    105.             if (kv.first == cur->_kv.first)
    106.                 break;
    107. ​
    108.             parent = cur;
    109.             if (kv.first < cur->_kv.first)
    110.                 cur = cur->_left;
    111.             else
    112.                 cur = cur->_right;
    113.         }
    114. ​
    115.         if (cur == nullptr)  // 树为空或者在树中未找到被删节点
    116.             return false;
    117. ​
    118.         // 被删节点的左、右子树都不为空
    119.         if (cur->_left && cur->_right)
    120.         {
    121.             parent = cur;
    122.             Node* leftMax = cur->_left;
    123.             while (leftMax->_right)
    124.             {
    125.                 parent = leftMax;
    126.                 leftMax = leftMax->_right;
    127.             }
    128.             std::swap(cur->_kv, leftMax->_kv);
    129.             cur = leftMax;  
    130.             // 此时被删节点就变成了 *leftMax，该节点的右子树为空
    131.         }
    132. ​
    133.         // 被删节点最多只有一个孩子
    134.         Node* child;
    135.         if (cur->_left)
    136.             child = cur->_left;
    137.         else
    138.             child = cur->_right;
    139. ​
    140.         if (parent == nullptr)  // 被删节点为根节点
    141.         {
    142.             _root = child;  
    143.         }
    144.         else
    145.         {
    146.             if (parent->_left == cur)
    147.             {
    148.                 --parent->_bf;
    149.                 parent->_left = child;
    150.             }
    151.             else
    152.             {
    153.                 ++parent->_bf;
    154.                 parent->_right = child;
    155.             }
    156. ​
    157.             // 往上更新 *cur 的祖先节点的平衡因子
    158.             bool isFirst = true;
    159.             while (parent)
    160.             {
    161.                 // 注意：在第一次循环中，child 可能为 nullptr，
    162.                 // 不能通过下面的方式判断 *cur 在其祖先节点的左子树中，还是右子树中，
    163.                 // 所以需要在循环外更新 *cur 的双亲节点的平衡因子，
    164.                 // 在循环内更新 *cur 其它祖先节点的平衡因子。
    165.                 if (isFirst == false)
    166.                 {
    167.                     if (parent->_left == child)
    168.                         --parent->_bf;
    169.                     else
    170.                         ++parent->_bf;
    171.                 }
    172.                 isFirst = false;
    173. ​
    174.                 if (parent->_bf == -1 || parent->_bf == 1)
    175.                 {
    176.                     break;
    177.                 }
    178.                 else if (parent->_bf == -2 || parent->_bf == 2)
    179.                 {
    180.                     int sign = 0;  // 祖先节点的平衡因子的正负号
    181.                     Node* higher;
    182.                     if (parent->_bf < 0)
    183.                     {
    184.                         sign = -1;
    185.                         higher = parent->_right;
    186.                     }
    187.                     else
    188.                     {
    189.                         sign = 1;
    190.                         higher = parent->_left;
    191.                     }
    192. ​
    193.                     if (higher->_bf == 0)
    194.                     {
    195.                         if (sign < 0)
    196.                         {
    197.                             RR(parent);
    198.                             parent->_bf = -1;
    199.                             higher->_bf = 1;
    200.                         }
    201.                         else
    202.                         {
    203.                             LL(parent);
    204.                             parent->_bf = 1;
    205.                             higher->_bf = -1;
    206.                         }
    207.                         break;  // 不需要继续往上更新，跳出循环
    208.                     }
    209.                     else if (higher->_bf == sign)  // 两节点的平衡因子同号
    210.                     {
    211.                         if (sign < 0)
    212.                         {
    213.                             RR(parent);
    214.                             parent = higher;
    215.                             child = parent->_left;
    216.                         }
    217.                         else
    218.                         {
    219.                             LL(parent);
    220.                             parent = higher;
    221.                             child = parent->_right;
    222.                         }
    223.                     }
    224.                     else  // 两节点的平衡因子反号
    225.                     {
    226.                         if (sign < 0)
    227.                         {
    228.                             Node* tmp = parent->_right->_left;
    229.                             RL(parent);
    230.                             parent = tmp;
    231.                             child = parent->_left;
    232.                         }
    233.                         else
    234.                         {
    235.                             Node* tmp = parent->_left->_right;
    236.                             LR(parent);
    237.                             parent = tmp;
    238.                             child = parent->_right;
    239.                         }
    240.                     }
    241.                 }
    242.                 // 继续往上更新
    243.                 child = parent;
    244.                 parent = parent->_parent;
    245.             }
    246.         }
    247.         delete cur;
    248.         return true;
    249.     }
    250. private:
    251.     void Destroy(Node*& root)
    252.     {
    253.         //【注意:root 为 _root 或者某个节点的左或右作指针的引用】
    254.         if (root == nullptr)
    255.             return;
    256. ​
    257.         Destroy(root->_left);
    258.         Destroy(root->_right);
    259.         delete root;
    260.         root = nullptr;
    261.     }
    262. ​
    263.     int Height(Node* root) const
    264.     {
    265.         if (root == nullptr)
    266.             return 0;
    267. ​
    268.         int leftHeight = Height(root->_left);
    269.         int rightHeight = Height(root->_right);
    270.         return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
    271.     }
    272. ​
    273.     bool _isBalanced(Node* root) const
    274.     {
    275.         if (root == nullptr)
    276.             return true;
    277. ​
    278.         int leftHeight = Height(root->_left);
    279.         int rightHeight = Height(root->_right);
    280.         return abs(leftHeight - rightHeight) < 2
    281.             && _isBalanced(root->_left)
    282.             && _isBalanced(root->_right);
    283.     }
    284. ​
    285.     void LL(Node* pA)
    286.     {
    287.         Node* pB = pA->_left;
    288.         Node* pBR = pB->_right;
    289. ​
    290.         pA->_left = pBR;
    291.         if (pBR)
    292.             pBR->_parent = pA;
    293. ​
    294.         pB->_right = pA;
    295.         Node* tmp = pA->_parent;
    296.         pA->_parent = pB;
    297.         pB->_parent = tmp;
    298. ​
    299.         if (tmp == nullptr)  // 或者 pA == _root
    300.         {
    301.             _root = pB;
    302.         }
    303.         else
    304.         {
    305.             if (tmp->_left == pA)
    306.                 tmp->_left = pB;
    307.             else
    308.                 tmp->_right = pB;
    309.         }
    310. ​
    311.         pA->_bf = pB->_bf = 0;
    312.     }
    313. ​
    314.     void RR(Node* pA)
    315.     {
    316.         Node* pB = pA->_right;
    317.         Node* pBL = pB->_left;
    318. ​
    319.         pA->_right = pBL;
    320.         if (pBL)
    321.             pBL->_parent = pA;
    322. ​
    323.         pB->_left = pA;
    324.         Node* tmp = pA->_parent;
    325.         pA->_parent = pB;
    326.         pB->_parent = tmp;
    327. ​
    328.         if (tmp == nullptr)  // 或者 pA == _root
    329.         {
    330.             _root = pB;
    331.         }
    332.         else
    333.         {
    334.             if (tmp->_left == pA)
    335.                 tmp->_left = pB;
    336.             else
    337.                 tmp->_right = pB;
    338.         }
    339. ​
    340.         pA->_bf = pB->_bf = 0;
    341.     }
    342. ​
    343.     void LR(Node* pA)
    344.     {
    345.         Node* pB = pA->_left;
    346.         Node* pC = pB->_right;
    347.         int bf = pC->_bf;
    348. ​
    349.         RR(pB);
    350.         LL(pA);
    351. ​
    352.         if (bf == 0)  // LR（0）型
    353.         {
    354.             pA->_bf = 0;
    355.             pB->_bf = 0;
    356.             pC->_bf = 0;
    357.         }
    358.         else if (bf == 1)  // LR（L）型
    359.         {
    360.             pA->_bf = -1;
    361.             pB->_bf = 0;
    362.             pC->_bf = 0;
    363.         }
    364.         else if (bf == -1)  // LR（R）型
    365.         {
    366.             pA->_bf = 0;
    367.             pB->_bf = 1;
    368.             pC->_bf = 0;
    369.         }
    370.     }
    371. ​
    372.     void RL(Node* pA)
    373.     {
    374.         Node* pB = pA->_right;
    375.         Node* pC = pB->_left;
    376.         int bf = pC->_bf;
    377. ​
    378.         LL(pB);
    379.         RR(pA);
    380. ​
    381.         if (bf == 0)  // RL（0）型
    382.         {
    383.             pA->_bf = 0;
    384.             pB->_bf = 0;
    385.             pC->_bf = 0;
    386.         }
    387.         else if (bf == 1)  // RL（L）型
    388.         {
    389.             pA->_bf = 0;
    390.             pB->_bf = -1;
    391.             pC->_bf = 0;
    392.         }
    393.         else if (bf == -1)  // RL（R）型
    394.         {
    395.             pA->_bf = 1;
    396.             pB->_bf = 0;
    397.             pC->_bf = 0;
    398.         }
    399.     }
    400. private:
    401.     Node* _root;
    402. };

    6.2 - test.cpp

    1. #include "AVL.h"
    2. #include 
    3. #include 
    4. #include 
    5. using namespace std;
    6. ​
    7. void TestAVL1()
    8. {
    9.     // int arr[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };  // ok
    10.     int arr[] = { 4, 2, 6, 1, 3, 5, 15, 7, 16, 14 };
    11.     AVL<int, int> t;
    12.     for (const auto& e : arr)
    13.     {
    14.         t.insert(make_pair(e, e));
    15.         if (!t.isBalanced())
    16.         {
    17.             cout << "插入操作有误！" << endl;
    18.             exit(-1);
    19.         }
    20.     }
    21.     cout << "插入完成~" << endl;
    22. ​
    23.     for (const auto& e : arr)
    24.     {
    25.         t.erase(make_pair(e, e));
    26.         if (!t.isBalanced())
    27.         {
    28.             cout << "删除操作有误！" << endl;
    29.             exit(-1);
    30.         }
    31.     }
    32.     cout << "删除完成~" << endl;
    33. }
    34. ​
    35. void TestAVL2()
    36. {
    37.     srand((unsigned int)time(0));
    38.     size_t N = 1000;
    39.     vector<int> v;
    40.     for (size_t i = 0; i < N; ++i)
    41.     {
    42.         v.push_back(rand());
    43.     }
    44. ​
    45.     AVL<int, int> t;
    46.     for (const auto& e : v)
    47.     {
    48.         t.insert(make_pair(e, e));
    49.         if (!t.isBalanced())
    50.         {
    51.             cout << "插入操作有误！" << endl;
    52.             exit(-1);
    53.         }
    54.     }
    55.     cout << "插入完成~" << endl;
    56. ​
    57.     for (const auto& e : v)
    58.     {
    59.         t.erase(make_pair(e, e));
    60.         if (!t.isBalanced())
    61.         {
    62.             cout << e << endl;
    63.             cout << "删除操作有误！" << endl;
    64.             exit(-1);
    65.         }
    66.     }
    67.     cout << "删除完成~" << endl;
    68. }
    69. ​
    70. int main()
    71. {
    72.     TestAVL1();
    73.     TestAVL2();
    74.     return 0;
    75. }

  • 相关阅读:
    苹果iPhone手机发抖音短视频如何挂载词令抖音小程序？
    4- 24
    C语言——数组
    【王道】计算机组成原理第七章I/O系统(七)
    Go-zero框架学习+xorm+gorm配置
    Panglon可视化显示使用
    用微信小程序开启桶装水订购业务
    Java内部类
    宝，运维100+服务器很头疼怎么办？用行云管家！
    cup处理器的编号详情
  • 原文地址：https://blog.csdn.net/melonyzzZ/article/details/133149060