数据结构与算法（五）：树

参考引用

• Hello 算法
• Github：hello-algo

1. 二叉树

• 二叉树（binary tree）是一种非线性数据结构，代表着祖先与后代之间的派生关系，体现着“一分为二”的分治逻辑

  • 与链表类似，二叉树的基本单元是节点，每个节点包含：值、左子节点引用、右子节点引用

  /* 二叉树节点结构体 */
  struct TreeNode {
      int val;          // 节点值
      TreeNode *left;   // 左子节点指针
      TreeNode *right;  // 右子节点指针
      TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
  };
  

• 每个节点都有两个指针，分别指向左子节点和右子节点，该节点被称为这两个子节点的父节点。当给定一个二叉树的节点时，将该节点的左子节点及其以下节点形成的树称为该节点的左子树，同理可得右子树

• 在二叉树中，除叶节点外，其他所有节点都包含子节点和非空子树

  • 如果将 “节点 2” 视为父节点，则其左子节点和右子节点分别是 “节点 4” 和 “节点 5”，左子树是 “节点 4 及其以下节点形成的树”，右子树是 “节点 5 及其以下节点形成的树”

1.1 二叉树常见术语

• 根节点 root node
  • 位于二叉树顶层的节点，没有父节点
• 叶节点 leaf node
  • 没有子节点的节点，其两个指针均指向 None
• 边 edge
  • 连接两个节点的线段，即节点指针
• 节点所在的层 level
  • 从顶至底递增，根节点所在层为 1
• 节点的度 degree
  • 节点的子节点的数量。在二叉树中，度的取值范围是 0、1、2
• 二叉树的高度 height
  • 从根节点到最远叶节点所经过的边的数量
• 节点的深度 depth
  • 从根节点到该节点所经过的边的数量
• 节点的高度 height
  • 从最远叶节点到该节点所经过的边的数量

1.2 二叉树基本操作

/* 1、初始化二叉树 */
// 与链表类似，首先初始化节点，然后构建指针
// 初始化节点
TreeNode* n1 = new TreeNode(1);
TreeNode* n2 = new TreeNode(2);
TreeNode* n3 = new TreeNode(3);
TreeNode* n4 = new TreeNode(4);
TreeNode* n5 = new TreeNode(5);
// 构建指针指向
n1->left = n2;
n1->right = n3;
n2->left = n4;
n2->right = n5;

/* 2、插入与删除节点 */
// 与链表类似，在二叉树中插入与删除节点可以通过修改指针来实现
TreeNode* P = new TreeNode(0);
// 在 n1 -> n2 中间插入节点 P
n1->left = P;
P->left = n2;
// 删除节点 P
n1->left = n2;

1.3 常见二叉树类型

1.3.1 完美二叉树（满二叉树）

• 完美二叉树（perfect binary tree）所有层的节点都被完全填满。在完美二叉树中，叶节点的度为 0，其余所有节点的度都为 2；若树高度为 h，则节点总数为 $2^{h+1}-1$，呈现标准的指数级关系，反映了自然界中常见的细胞分裂现象

1.3.2 完全二叉树

• 完全二叉树（complete binary tree）只有最底层的节点未被填满，且最底层节点尽量靠左填充

1.3.3 完满二叉树

• 完满二叉树（full binary tree）除了叶节点之外，其余所有节点都有两个子节点

1.3.4 平衡二叉树

• 平衡二叉树（balanced binary tree）中任意节点的左子树和右子树的高度之差的绝对值不超过 1

1.4 二叉树的退化

• 当二叉树的每层节点都被填满时，达到 “完美二叉树”；而当所有节点都偏向一侧时，二叉树退化为 “链表”
  • 完美二叉树是理想情况，可以充分发挥二叉树 “分治” 的优势
  • 链表则是另一个极端，各项操作都变为线性操作，时间复杂度退化至 O(n)

2. 二叉树遍历

从物理结构的角度来看，树是一种基于链表的数据结构，因此其遍历方式是通过指针逐个访问节点。然而，树是一种非线性数据结构，这使得遍历树比遍历链表更加复杂，需要借助搜索算法来实现

• 二叉树常见的遍历方式包括层序遍历、前序遍历、中序遍历和后序遍历等

2.1 层序遍历

• 层序遍历（level-order traversal）从顶部到底部逐层遍历二叉树，并在每一层按照从左到右的顺序访问节点
  • 层序遍历本质上属于广度优先遍历（breadth-first traversal），它体现了 “一圈一圈向外扩展” 的逐层遍历思想

• 广度优先遍历通常借助 “队列” 来实现。队列遵循 “先进先出” 的规则，而广度优先遍历则遵循 “逐层推进” 的规则，两者背后的思想是一致的

  /* 层序遍历 */
  // 时间复杂度：所有节点被访问一次，使用 O(n) 时间，其中 n 为节点数量
  // 空间复杂度：在最差情况下，即满二叉树时，遍历到最底层之前，队列中最多同时存在 (n+1)/2 个节点，占用 O(n) 空间
  vector<int> levelOrder(TreeNode *root) {
      // 初始化队列，加入根节点
      queue<TreeNode *> queue;
      queue.push(root);
      // 初始化一个列表，用于保存遍历序列
      vector<int> vec;
      while (!queue.empty()) {
          TreeNode *node = queue.front();
          queue.pop();                 // 队列出队
          vec.push_back(node->val);    // 保存节点值
          if (node->left != nullptr)
              queue.push(node->left);  // 左子节点入队
          if (node->right != nullptr)
              queue.push(node->right); // 右子节点入队
      }
      return vec;
  }
  

2.2 前序、中序、后序遍历

• 前序、中序和后序遍历都属于深度优先遍历（depth-first traversal），体现 “先走到尽头，再回溯继续” 的思想
• 下图展示了对二叉树进行深度优先遍历的工作原理。深度优先遍历就像是绕着整个二叉树的外围 “走” 一圈，在每个节点都会遇到三个位置，分别对应前序遍历、中序遍历和后序遍历

• 深度优先搜索通常基于递归实现

  // 时间复杂度：所有节点被访问一次，使用 O(n) 时间
  // 空间复杂度：在最差情况下，即树退化为链表时，递归深度达到 n，系统占用 O(n) 栈帧空间
  /* 前序遍历 */
  void preOrder(TreeNode *root) {
      if (root == nullptr)
          return;
      // 访问优先级：根节点 -> 左子树 -> 右子树
      vec.push_back(root->val);
      preOrder(root->left);
      preOrder(root->right);
  }
  
  /* 中序遍历 */
  void inOrder(TreeNode *root) {
      if (root == nullptr)
          return;
      // 访问优先级：左子树 -> 根节点 -> 右子树
      inOrder(root->left);
      vec.push_back(root->val);
      inOrder(root->right);
  }
  
  /* 后序遍历 */
  void postOrder(TreeNode *root) {
      if (root == nullptr)
          return;
      // 访问优先级：左子树 -> 右子树 -> 根节点
      postOrder(root->left);
      postOrder(root->right);
      vec.push_back(root->val);
  }
  

前序遍历二叉树的递归过程可分为 “递” 和 “归” 两个逆向的部分

• “递” 表示开启新方法，程序在此过程中访问下一个节点
• “归” 表示函数返回，代表当前节点已经访问完毕

2.3 二叉树数组表示

2.3.1 表示完美二叉树

• 给定一个完美二叉树，将所有节点按照层序遍历的顺序存储在一个数组中，则每个节点都对应唯一的数组索引。根据层序遍历的特性，可以推导出父节点索引与子节点索引之间的 “映射公式”
  • 若节点的索引为 i，则该节点的左子节点索引为 2i+1，右子节点索引为 2i+2

映射公式的角色相当于链表中的指针。给定数组中的任意一个节点，都可通过映射公式来访问它的左（右）子节点

2.3.2 表示任意二叉树

• 完美二叉树是一个特例，在二叉树的中间层通常存在许多 None。由于层序遍历序列并不包含这些 None，因此无法仅凭该序列来推测 None 的数量和分布位置。这意味着存在多种二叉树结构都符合该层序遍历序列
  • 在层序遍历序列中显式地写出所有 None，下图所示，这样层序遍历序列就可以唯一表示二叉树

  // 使用 int 最大值 INT_MAX 标记空位
  vector<int> tree = {1, 2, 3, 4, INT_MAX, 6, 7, 8, 9, INT_MAX, INT_MAX, 12, INT_MAX, INT_MAX, 15};
  

• 完全二叉树非常适合使用数组来表示。完全二叉树的 None 只出现在最底层且靠右的位置，因此所有 None 一定出现在层序遍历序列的末尾。这意味着使用数组表示完全二叉树时，可以省略存储所有 None

• 实现一个基于数组表示的二叉树，包括以下几种操作

  • 给定某节点，获取它的值、左（右）子节点、父节点
  • 获取前序遍历、中序遍历、后序遍历、层序遍历序列

  /* 数组表示下的二叉树类 */
  class ArrayBinaryTree {
  public:
      /* 构造方法 */
      ArrayBinaryTree(vector<int> arr) {
          tree = arr;
      }
  
      /* 节点数量 */
      int size() {
          return tree.size();
      }
  
      /* 获取索引为 i 节点的值 */
      int val(int i) {
          // 若索引越界，则返回 INT_MAX ，代表空位
          if (i < 0 || i >= size())
              return INT_MAX;
          return tree[i];
      }
  
      /* 获取索引为 i 节点的左子节点的索引 */
      int left(int i) {
          return 2 * i + 1;
      }
  
      /* 获取索引为 i 节点的右子节点的索引 */
      int right(int i) {
          return 2 * i + 2;
      }
  
      /* 获取索引为 i 节点的父节点的索引 */
      int parent(int i) {
          return (i - 1) / 2;
      }
  
      /* 层序遍历 */
      vector<int> levelOrder() {
          vector<int> res;
          // 直接遍历数组
          for (int i = 0; i < size(); i++) {
              if (val(i) != INT_MAX)
                  res.push_back(val(i));
          }
          return res;
      }
  
      /* 前序遍历 */
      vector<int> preOrder() {
          vector<int> res;
          dfs(0, "pre", res);
          return res;
      }
  
      /* 中序遍历 */
      vector<int> inOrder() {
          vector<int> res;
          dfs(0, "in", res);
          return res;
      }
  
      /* 后序遍历 */
      vector<int> postOrder() {
          vector<int> res;
          dfs(0, "post", res);
          return res;
      }
  
  private:
      vector<int> tree;
  
      /* 深度优先遍历 */
      void dfs(int i, string order, vector<int> &res) {
          // 若为空位，则返回
          if (val(i) == INT_MAX)
              return;
          // 前序遍历
          if (order == "pre")
              res.push_back(val(i));
          dfs(left(i), order, res);
          // 中序遍历
          if (order == "in")
              res.push_back(val(i));
          dfs(right(i), order, res);
          // 后序遍历
          if (order == "post")
              res.push_back(val(i));
      }
  };
  

2.3.3 优势与局限性

• 二叉树的数组表示主要有以下优点

  • 数组存储在连续的内存空间中，对缓存友好，访问与遍历速度较快
  • 不需要存储指针，比较节省空间
  • 允许随机访问节点

• 二叉树的数组表示主要有以下局限性

  • 数组存储需要连续内存空间，因此不适合存储数据量过大的树
  • 增删节点需要通过数组插入与删除操作实现，效率较低
  • 当二叉树中存在大量 None 时，数组中包含的节点数据比重较低，空间利用率较低

3. 二叉搜索树

• 如下图所示，二叉搜索树（binary search tree）满足以下条件
  • 对于根节点，左子树中所有节点的值 < 根节点的值 < 右子树中所有节点的值
  • 任意节点的左、右子树也是二叉搜索树，即同样满足上述条件

3.1 二叉搜索树的操作

3.1.1 查找节点

• 给定目标节点值 num，可以根据二叉搜索树的性质来查找。声明一个节点 cur，从二叉树的根节点 root 出发，循环比较节点值 cur.val 和 num 之间的大小关系

  • 若 cur.val < num ，说明目标节点在 cur 的右子树中，因此执行 cur = cur.right
  • 若 cur.val > num ，说明目标节点在 cur 的左子树中，因此执行 cur = cur.left
  • 若 cur.val = num ，说明找到目标节点，跳出循环并返回该节点

• 二叉搜索树的查找操作与二分查找算法的工作原理一致，都是每轮排除一半情况。循环次数最多为二叉树的高度，当二叉树平衡时，使用 O(log n) 时间

  /* 查找节点 */
  TreeNode *search(int num) {
      TreeNode *cur = root;
      // 循环查找，越过叶节点后跳出
      while (cur != nullptr) {
          // 目标节点在 cur 的右子树中
          if (cur->val < num)
              cur = cur->right;
          // 目标节点在 cur 的左子树中
          else if (cur->val > num)
              cur = cur->left;
          // 找到目标节点，跳出循环
          else
              break;
      }
      // 返回目标节点
      return cur;
  }
  

3.1.2 插入节点

• 给定一个待插入元素 num，为保持二叉搜索树 “左子树 < 根节点 < 右子树” 性质，插入操作流程如下图所示
  • 查找节点插入位置
    • 与查找操作相似，从根节点出发，根据当前节点值和 num 的大小关系循环向下搜索，直到越过叶节点（遍历至 None）时跳出循环
  • 在该位置插入节点
    • 初始化节点 num，将该节点置于 None 的位置

• 在代码实现中，需要注意以下两点
  • 二叉搜索树不允许存在重复节点，否则将违反其定义。因此，若待插入节点在树中已存在，则不执行插入，直接返回
  • 为实现插入节点，需要借助节点 pre 保存上一轮循环的节点。这样在遍历至 None 时，可以获取到其父节点，从而完成节点插入操作

  // 时间复杂度：O(log n)
  void insert(int num) {
      // 若树为空，则初始化根节点
      if (root == nullptr) {
          root = new TreeNode(num);
          return;
      }
      TreeNode *cur = root, *pre = nullptr;
      // 循环查找，越过叶节点后跳出
      while (cur != nullptr) {
          // 找到重复节点，直接返回
          if (cur->val == num)
              return;
          pre = cur;
          // 插入位置在 cur 的右子树中
          if (cur->val < num)
              cur = cur->right;
          // 插入位置在 cur 的左子树中
          else
              cur = cur->left;
      }
      // 插入节点
      TreeNode *node = new TreeNode(num);
      if (pre->val < num)
          pre->right = node;
      else
          pre->left = node;
  }
  

3.1.3 删除节点

• 先在二叉树中查找到目标节点，再将其从二叉树中删除。与插入节点类似，需要保证在删除操作完成后，二叉搜索树的 “左子树 < 根节点 < 右子树” 的性质仍然满足。需要根据目标节点的子节点数量，共分为 0、1 和 2 这三种情况，执行对应的删除节点操作

1. 当待删除节点的度为 0 时，表示该节点是叶节点，可以直接删除

2. 当待删除节点的度为 1 时，将待删除节点替换为其子节点即可

3. 当待删除节点的度为 2 时，无法直接删除它，而需要使用一个节点替换该节点

• 由于要保持二叉搜索树 “左 < 根 < 右” 的性质，因此这个节点可以是右子树的最小节点或左子树的最大节点
• 假设选择右子树的最小节点（即中序遍历的下一个节点），则删除操作流程如下
  • 查找 cur 在中序遍历的后继节点 nex
  • 在二叉树中递归删除节点 nex
  • 将节点 nex 值赋给节点 cur

// 时间复杂度：O(log n)
// 其中查找待删除节点需要 O(log n) 时间，获取中序遍历后继节点需要 O(log n) 时间
void remove(int num) {
    // 若树为空，直接提前返回
    if (root == nullptr)
        return;
    TreeNode *cur = root, *pre = nullptr;
    // 循环查找，越过叶节点后跳出
    while (cur != nullptr) {
        // 找到待删除节点，跳出循环
        if (cur->val == num)
            break;
        pre = cur;
        // 待删除节点在 cur 的右子树中
        if (cur->val < num)
            cur = cur->right;
        // 待删除节点在 cur 的左子树中
        else
            cur = cur->left;
    }
    // 若无待删除节点，则直接返回
    if (cur == nullptr)
        return;

    // 1、子节点数量 = 0 or 1
    if (cur->left == nullptr || cur->right == nullptr) {
        // 当子节点数量 = 0 / 1 时， child = nullptr / 该子节点
        TreeNode *child = cur->left != nullptr ? cur->left : cur->right;
        // 删除节点 cur
        if (cur != root) {
            if (pre->left == cur)
                pre->left = child;
            else
                pre->right = child;
        } else {
            // 若删除节点为根节点，则重新指定根节点
            root = child;
        }
        // 释放内存
        delete cur;
    }
    // 2、子节点数量 = 2
    else {
        // 获取中序遍历中 cur 的下一个节点
        TreeNode *tmp = cur->right;
        while (tmp->left != nullptr) {
            tmp = tmp->left;
        }
        int tmpVal = tmp->val;
        // 递归删除节点 tmp
        remove(tmp->val);
        // 用 tmp 覆盖 cur
        cur->val = tmpVal;
    }
}

3.1.4 中序遍历有序

• 二叉树的中序遍历遵循 “左 < 根 < 右” 的遍历顺序，而二叉搜索树满足 “左子节点 < 根节点 < 右子节点” 的大小关系。这意味着在二叉搜索树中进行中序遍历时，总是会优先遍历下一个最小节点，从而得出一个重要性质：二叉搜索树的中序遍历序列是升序的
• 利用中序遍历升序的性质，在二叉搜索树中获取有序数据仅需 O(n) 时间，无须进行额外的排序操作，非常高效

3.2 二叉搜索树的效率

• 二叉搜索树的各项操作的时间复杂度都是对数阶，具有稳定且高效的性能表现。只有在高频添加、低频查找删除的数据适用场景下，数组比二叉搜索树的效率更高

• 在理想情况下，二叉搜索树是 “平衡” 的，这样就可以在 log n 轮循环内查找任意节点。然而，如果在二叉搜索树中不断地插入和删除节点，可能导致二叉树退化为下图所示的链表，这时各种操作的时间复杂度也会退化为 O(n)

• 在完美二叉树中插入两个节点后，树将严重向左倾斜，查找操作的时间复杂度也随之恶化

3.3 二叉搜索树应用

• 用作系统中的多级索引，实现高效的查找、插入、删除操作
• 作为某些搜索算法的底层数据结构
• 用于存储数据流，以保持其有序状态

4. AVL 树

4.1 AVL 树常见术语

• AVL 树既是二叉搜索树也是平衡二叉树，同时满足这两类二叉树的所有性质，因此也被称为平衡二叉搜索树（balanced binary search tree）

4.1.1 节点高度

• 由于 AVL 树的相关操作需要获取节点高度，因此需要为节点类添加 height 变量

  /* AVL 树节点类 */
  struct TreeNode {
      int val{};          // 节点值
      int height = 0;     // 节点高度
      TreeNode *left{};   // 左子节点
      TreeNode *right{};  // 右子节点
      TreeNode() = default;
      explicit TreeNode(int x) : val(x){}
  };
  

• “节点高度” 是指从该节点到最远叶节点的距离，即所经过的 “边” 的数量
  • 需要特别注意的是，叶节点的高度为 0，而空节点的高度为 -1

  /* 获取节点高度 */
  int height(TreeNode *node) {
      // 空节点高度为 -1 ，叶节点高度为 0
      return node == nullptr ? -1 : node->height;
  }
  
  /* 更新节点高度 */
  void updateHeight(TreeNode *node) {
      // 节点高度等于最高子树高度 + 1
      node->height = max(height(node->left), height(node->right)) + 1;
  }
  

4.1.2 节点平衡因子

• 节点的平衡因子（balance factor）定义为节点左子树的高度减去右子树的高度，同时规定空节点的平衡因子为 0

  /* 获取平衡因子 */
  int balanceFactor(TreeNode *node) {
      // 空节点平衡因子为 0
      if (node == nullptr)
          return 0;
      // 节点平衡因子 = 左子树高度 - 右子树高度
      return height(node->left) - height(node->right);
  }
  

设平衡因子为 f，则一棵 AVL 树的任意节点的平衡因子皆满足 -1 < f < 1

4.2 AVL 树旋转

• AVL 树的特点在于 “旋转” 操作，它能够在不影响二叉树的中序遍历序列的前提下，使失衡节点重新恢复平衡
  • 换句话说，旋转操作既能保持 “二叉搜索树” 的性质，也能使树重新变为 “平衡二叉树”
• 将平衡因子绝对值 > 1 的节点称为 “失衡节点”
  • 根据节点失衡情况的不同，旋转操作分为四种：右旋、左旋、先右旋后左旋、先左旋后右旋

4.2.1 右旋

• 如下图所示（节点下方为平衡因子）
  • 从底至顶看，二叉树中首个失衡节点是 “节点 3”
  • 关注以该失衡节点为根节点的子树，将该节点记为 node，其左子节点记为 child
  • 执行 “右旋” 操作：以 child 为原点，将 node 向右旋转
  • 右旋完成后，用 child 替代以前 node 的位置，子树已恢复平衡，并仍保持二叉搜索树的特性

• 如下图所示，当节点 child 有右子节点（记为 grandChild）时，需要在右旋中添加一步：将 grandChild 作为 node 的左子节点

/* 右旋操作 */
TreeNode *rightRotate(TreeNode *node) {
    TreeNode *child = node->left;
    TreeNode *grandChild = child->right;
    // 以 child 为原点，将 node 向右旋转
    child->right = node;
    node->left = grandChild;
    // 更新节点高度
    updateHeight(node);
    updateHeight(child);
    // 返回旋转后子树的根节点
    return child;
}

4.2.2 左旋

/* 左旋操作 */
TreeNode *leftRotate(TreeNode *node) {
    TreeNode *child = node->right;
    TreeNode *grandChild = child->left;
    // 以 child 为原点，将 node 向左旋转
    child->left = node;
    node->right = grandChild;
    // 更新节点高度
    updateHeight(node);
    updateHeight(child);
    // 返回旋转后子树的根节点
    return child;
}

4.2.3 先左旋后右旋

• 对于下图中的失衡节点 3，仅使用左旋或右旋都无法使子树恢复平衡
  • 此时需要先对 child 执行 “左旋”，再对 node 执行 “右旋”

4.2.4 先右旋后左旋

4.2.5 旋转的选择

• 如下表，通过判断失衡节点的平衡因子以及较高一侧子节点的平衡因子的正负号，来确定失衡节点属于上图哪种情况

• 为便于使用，将旋转操作封装成一个函数。通过这个函数就能对各种失衡情况进行旋转，使失衡节点重新恢复平衡

  /* 执行旋转操作，使该子树重新恢复平衡 */
  TreeNode *rotate(TreeNode *node) {
      // 获取节点 node 的平衡因子
      int _balanceFactor = balanceFactor(node);
      // 左偏树
      if (_balanceFactor > 1) {
          if (balanceFactor(node->left) >= 0) {
              // 右旋
              return rightRotate(node);
          } else {
              // 先左旋后右旋
              node->left = leftRotate(node->left);
              return rightRotate(node);
          }
      }
      // 右偏树
      if (_balanceFactor < -1) {
          if (balanceFactor(node->right) <= 0) {
              // 左旋
              return leftRotate(node);
          } else {
              // 先右旋后左旋
              node->right = rightRotate(node->right);
              return leftRotate(node);
          }
      }
      // 平衡树，无须旋转，直接返回
      return node;
  }
  

4.3 AVL 树常用操作

4.3.1 插入节点

• AVL 树的节点插入操作与二叉搜索树在主体上类似。唯一的区别在于，在 AVL 树中插入节点后，从该节点到根节点的路径上可能会出现一系列失衡节点
  • 因此，需要从这个节点开始，自底向上执行旋转操作，使所有失衡节点恢复平衡

  /* 插入节点 */
  void insert(int val) {
      root = insertHelper(root, val);
  }
  
  /* 递归插入节点（辅助方法） */
  TreeNode *insertHelper(TreeNode *node, int val) {
      if (node == nullptr)
          return new TreeNode(val);
      /* 1. 查找插入位置，并插入节点 */
      if (val < node->val)
          node->left = insertHelper(node->left, val);
      else if (val > node->val)
          node->right = insertHelper(node->right, val);
      else
          return node;    // 重复节点不插入，直接返回
      updateHeight(node); // 更新节点高度
      /* 2. 执行旋转操作，使该子树重新恢复平衡 */
      node = rotate(node);
      // 返回子树的根节点
      return node;
  }
  

4.3.2 删除节点

• 类似地，在二叉搜索树的删除节点方法的基础上，需要从底至顶地执行旋转操作，使所有失衡节点恢复平衡

  /* 删除节点 */
  void remove(int val) {
      root = removeHelper(root, val);
  }
  
  /* 递归删除节点（辅助方法） */
  TreeNode *removeHelper(TreeNode *node, int val) {
      if (node == nullptr)
          return nullptr;
      /* 1. 查找节点，并删除之 */
      if (val < node->val)
          node->left = removeHelper(node->left, val);
      else if (val > node->val)
          node->right = removeHelper(node->right, val);
      else {
          if (node->left == nullptr || node->right == nullptr) {
              TreeNode *child = node->left != nullptr ? node->left : node->right;
              // 子节点数量 = 0 ，直接删除 node 并返回
              if (child == nullptr) {
                  delete node;
                  return nullptr;
              }
              // 子节点数量 = 1 ，直接删除 node
              else {
                  delete node;
                  node = child;
              }
          } else {
              // 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
              TreeNode *temp = node->right;
              while (temp->left != nullptr) {
                  temp = temp->left;
              }
              int tempVal = temp->val;
              node->right = removeHelper(node->right, temp->val);
              node->val = tempVal;
          }
      }
      updateHeight(node); // 更新节点高度
      /* 2. 执行旋转操作，使该子树重新恢复平衡 */
      node = rotate(node);
      // 返回子树的根节点
      return node;
  }
  

4.3.3 查找节点

• AVL 树的节点查找操作与二叉搜索树一致