代码随想录算法训练营 Day17 | 二叉树 part07

235. 二叉搜索树的最近公共祖先

给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为："对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。"

// 递归法
class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        // 1. 如果 p 和 q 的值都小于当前节点，说明目标都在左子树
        // 根据 BST 性质，向左递归查找
        if (root->val > p->val && root->val > q->val) {
            return lowestCommonAncestor(root->left, p, q);
        }
        // 2. 如果 p 和 q 的值都大于当前节点，说明目标都在右子树
        // 根据 BST 性质，向右递归查找
        else if (root->val < p->val && root->val < q->val) {
            return lowestCommonAncestor(root->right, p, q);
        }
        // 3. 其他情况：当前节点就是最近公共祖先
        // 包括：p/q 分别在左右两侧，或者当前节点就是 p/q
        else return root;
    }
};

// 迭代法
class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        while (root) {
            // 1. 目标都在左子树，向左移动
            if (root->val > p->val && root->val > q->val) {
                root = root->left;
            }
            // 2. 目标都在右子树，向右移动
            else if (root->val < p->val && root->val < q->val) {
                root = root->right;
            }
            // 3. 找到分叉点或目标节点，直接返回
            else {
                return root;
            }
        }
        return NULL;
    }
};

总结

1. 解题思路：利用 BST 性质

这道题与"普通二叉树最近公共祖先"最大的不同在于：不需要回溯。

• 普通二叉树：不知道 p 和 q 在哪边，必须通过后序遍历（自底向上）把左右子树都查一遍才能确定。
• BST：可以通过节点值的大小关系直接判断方向：
  • 都比当前小 -> 往左走。
  • 都比当前大 -> 往右走。
  • 一大一小（或等于） -> 找到了！

2. 为什么迭代法是优选？

• 空间复杂度 O(1)：迭代法只修改指针，不需要递归栈，非常高效。
• 递归法：虽然代码简洁，但需要 O(H) 的栈空间。

3. 复杂度分析

• 时间复杂度：O(H)
  • H 是树的高度。最好情况 O(log N)，最坏情况 O(N)。只需要从根走到 LCA 即可，不需要遍历整棵树。
• 空间复杂度：
  • 递归：O(H)（栈空间）。
  • 迭代：O(1)。

---

701. 二叉搜索树中的插入操作

给定二叉搜索树（BST）的根节点 root 和要插入树中的值 value ，将值插入二叉搜索树。 返回插入后二叉搜索树的根节点。 输入数据 保证 ，新值和原始二叉搜索树中的任意节点值都不同。

注意，可能存在多种有效的插入方式，只要树在插入后仍保持为二叉搜索树即可。 你可以返回 任意有效的结果 。

// 递归法
class Solution {
public:
    TreeNode* insertIntoBST(TreeNode* root, int val) {
        // 1. 终止条件：找到空位置，创建新节点并返回
        if (root == NULL) {
            return new TreeNode(val);
        }
        // 2. 单层递归逻辑
        // 如果插入值小于当前节点，去左子树找位置
        // 并将返回的子树根节点接在 root->left 上
        if (root->val > val) {
            root->left = insertIntoBST(root->left, val);
        }
        // 如果插入值大于当前节点，去右子树找位置
        // 并将返回的子树根节点接在 root->right 上
        else if (root->val < val) {
            root->right = insertIntoBST(root->right, val);
        }
        // 3. 返回当前节点（保持树的结构不变）
        return root;
    }
};

// 迭代法
class Solution {
public:
    TreeNode* insertIntoBST(TreeNode* root, int val) {
        // 特殊情况：如果树为空，直接创建根节点
        if (root == NULL) return new TreeNode(val);
        TreeNode* head = root; // 保存根节点，最后返回用
        TreeNode* pre = NULL;  // 记录前驱节点（父节点），用于最后挂载新节点
        // 1. 寻找插入位置
        while (root) {
            pre = root; // 更新父节点
            if (root->val > val) {
                root = root->left; // 往左走
            }
            else if (root->val < val) {
                root = root->right; // 往右走
            }
        }
        // 2. 循环结束时，root 为空，pre 是叶子节点
        // 根据 pre 的值决定新节点挂在左边还是右边
        TreeNode* node = new TreeNode(val);
        if (pre->val > val) {
            pre->left = node;
        }
        else {
            pre->right = node;
        }
        return head;
    }
};

总结

1. 解题思路

• 寻找位置：利用 BST 性质（左 < 根 < 右），一路向下直到找到空节点。
• 链接节点：
  • 递归法：利用函数返回值自动完成父子节点的链接（root->left = ...）。代码非常简洁。
  • 迭代法：需要手动维护一个 pre 指针，记录当前节点的父节点。当找到空位置时，通过 pre 把新节点挂上去。

2. 复杂度分析

• 时间复杂度：O(H)
  • H 是树的高度。只需一条路径走到叶子，不需要遍历整棵树。
• 空间复杂度：
  • 递归法：O(H)，取决于递归栈深度。
  • 迭代法：O(1)，只使用了几个指针变量，效率更高。

---

450. 删除二叉搜索树中的节点

给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的 key 对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用。

一般来说，删除节点可分为两个步骤：

1. 首先找到需要删除的节点；
2. 如果找到了，删除它。

class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
        // 1. 终止条件：没找到目标节点
        if (root == NULL) return NULL;
        // 2. 找到目标节点，开始删除逻辑
        if (root->val == key) {
            // 情况A：叶子节点（左右子树都空）
            // 直接删除，返回 NULL 给上层接住
            if (!root->left && !root->right) {
                delete root;
                return NULL;
            }
            // 情况B：左不空，右空
            // 删除节点，将左子树接上去
            else if (root->left && !root->right) {
                TreeNode* node = root->left;
                delete root;
                return node;
            }
            // 情况C：左空，右不空
            // 删除节点，将右子树接上去
            else if (!root->left && root->right) {
                TreeNode* node = root->right;
                delete root;
                return node;
            }
            // 情况D：左右子树都不空
            // 策略：将左子树挂到右子树的最左节点（最小值节点）的左边
            else {
                TreeNode* cur = root->right; // 进入右子树
                while (cur->left) {          // 找到右子树的最左节点
                    cur = cur->left;
                }
                cur->left = root->left;      // 将要删除节点的左子树挂在这里
                // 用右子树替换当前节点
                TreeNode* tmp = root;
                root = root->right;
                delete tmp;
                return root;
            }
        }
        // 3. 递归查找与链接
        // 如果目标值小，去左子树删，并用返回值更新左孩子
        if (root->val > key) root->left = deleteNode(root->left, key);
        // 如果目标值大，去右子树删，并用返回值更新右孩子
        if (root->val < key) root->right = deleteNode(root->right, key);
        return root;
    }
};

总结

1. 删除逻辑详解（难点）

在二叉搜索树中删除节点分为四种情况，代码逻辑非常清晰：

1. 叶子节点：最简单，直接删除，返回 NULL。
2. 只有左孩子：让左孩子接替自己的位置。
3. 只有右孩子：让右孩子接替自己的位置。
4. 左右孩子都有：这是最复杂的情况。通常有两种策略：
   • 策略一（代码采用）：将左子树移植到右子树的最左节点（右子树中最小的节点）的左孩子位置上，然后让右子树成为新的根。这样做依然满足 BST 性质。
   • 策略二（常见替代）：找到前驱节点（左子树最大值）或后继节点（右子树最小值）的值来覆盖当前节点，然后递归删除那个前驱/后继节点。

2. 递归的"接线"技巧

代码中利用递归返回值完成了父节点与子节点的重新连接：
root->left = deleteNode(...)

这行代码意味着：不管 deleteNode 内部发生了什么（是删除了、还是返回了新的子节点），父节点的 left 指针都会正确指向处理后的结果。

3. 复杂度分析

• 时间复杂度：O(H)
  • H 是树的高度。主要耗时在于查找目标节点和寻找右子树的最左节点。
• 空间复杂度：O(H)
  • 递归栈的深度取决于树的高度。