@TOC

---

前言

代码随想录算法训练营day22

---

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

1.题目

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

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

例如，给定如下二叉搜索树: root = [6,2,8,0,4,7,9,null,null,3,5]

示例 1:

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8 输出: 6 解释: 节点 2 和节点 8 的最近公共祖先是 6。

示例 2:

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4 输出: 2 解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。

说明:

所有节点的值都是唯一的。
p、q 为不同节点且均存在于给定的二叉搜索树中。

来源：力扣（LeetCode） 链接：leetcode.cn/problems/lo…

2.解题思路

方法一：两次遍历

思路与算法

注意到题目中给出的是一棵「二叉搜索树」，因此我们可以快速地找出树中的某个节点以及从根节点到该节点的路径，例如我们需要找到节点 pp：

我们从根节点开始遍历；

如果当前节点就是 pp，那么成功地找到了节点；

如果当前节点的值大于 pp 的值，说明 pp 应该在当前节点的左子树，因此将当前节点移动到它的左子节点；

如果当前节点的值小于 pp 的值，说明 pp 应该在当前节点的右子树，因此将当前节点移动到它的右子节点。

对于节点 qq 同理。在寻找节点的过程中，我们可以顺便记录经过的节点，这样就得到了从根节点到被寻找节点的路径。

当我们分别得到了从根节点到 pp 和 qq 的路径之后，我们就可以很方便地找到它们的最近公共祖先了。显然，pp 和 qq 的最近公共祖先就是从根节点到它们路径上的「分岔点」，也就是最后一个相同的节点。因此，如果我们设从根节点到 pp 的路径为数组 path_ppath_p，从根节点到 qq 的路径为数组 path_qpath_q，那么只要找出最大的编号 ii，其满足

path_p[i]=path_q[i]path_p[i]=path_q[i]

那么对应的节点就是「分岔点」，即 pp 和 qq 的最近公共祖先就是 path_p[i]path_p[i]（或 path_q[i]path_q[i]）。

3.代码实现

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        List<TreeNode> path_p = getPath(root, p);
        List<TreeNode> path_q = getPath(root, q);
        TreeNode ancestor = null;
        for (int i = 0; i < path_p.size() && i < path_q.size(); ++i) {
            if (path_p.get(i) == path_q.get(i)) {
                ancestor = path_p.get(i);
            } else {
                break;
            }
        }
        return ancestor;
    }

    public List<TreeNode> getPath(TreeNode root, TreeNode target) {
        List<TreeNode> path = new ArrayList<TreeNode>();
        TreeNode node = root;
        while (node != target) {
            path.add(node);
            if (target.val < node.val) {
                node = node.left;
            } else {
                node = node.right;
            }
        }
        path.add(node);
        return path;
    }
}

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

1.题目

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

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

示例 1：

输入：root = [4,2,7,1,3], val = 5 输出：[4,2,7,1,3,5] 解释：另一个满足题目要求可以通过的树是：

示例 2：

输入：root = [40,20,60,10,30,50,70], val = 25 输出：[40,20,60,10,30,50,70,null,null,25]

示例 3：

输入：root = [4,2,7,1,3,null,null,null,null,null,null], val = 5 输出：[4,2,7,1,3,5]

提示：

树中的节点数将在 [0, 104]的范围内。
-108 <= Node.val <= 108
所有值 Node.val 是 独一无二 的。
-108 <= val <= 108
保证 val 在原始BST中不存在。

来源：力扣（LeetCode） 链接：leetcode.cn/problems/in…

2.解题思路

方法一：模拟

思路与算法

首先回顾二叉搜索树的性质：对于任意节点 rootroot 而言，左子树（如果存在）上所有节点的值均小于 root.valroot.val，右子树（如果存在）上所有节点的值均大于 root.valroot.val，且它们都是二叉搜索树。

因此，当将 valval 插入到以 rootroot 为根的子树上时，根据 valval 与 root.valroot.val 的大小关系，就可以确定要将 valval 插入到哪个子树中。

如果该子树不为空，则问题转化成了将 valval 插入到对应子树上。
否则，在此处新建一个以 valval 为值的节点，并链接到其父节点 rootroot 上。

3.代码实现

class Solution {
    public TreeNode insertIntoBST(TreeNode root, int val) {
        if (root == null) {
            return new TreeNode(val);
        }
        TreeNode pos = root;
        while (pos != null) {
            if (val < pos.val) {
                if (pos.left == null) {
                    pos.left = new TreeNode(val);
                    break;
                } else {
                    pos = pos.left;
                }
            } else {
                if (pos.right == null) {
                    pos.right = new TreeNode(val);
                    break;
                } else {
                    pos = pos.right;
                }
            }
        }
        return root;
    }
}

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

1.题目

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

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

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

示例 1:

输入：root = [5,3,6,2,4,null,7], key = 3 输出：[5,4,6,2,null,null,7] 解释：给定需要删除的节点值是 3，所以我们首先找到 3 这个节点，然后删除它。 一个正确的答案是 [5,4,6,2,null,null,7], 如下图所示。 另一个正确答案是 [5,2,6,null,4,null,7]。

示例 2:

输入: root = [5,3,6,2,4,null,7], key = 0 输出: [5,3,6,2,4,null,7] 解释: 二叉树不包含值为 0 的节点

示例 3:

输入: root = [], key = 0 输出: []

提示:

节点数的范围 [0, 104].
-105 <= Node.val <= 105
节点值唯一
root 是合法的二叉搜索树
-105 <= key <= 105

2.解题思路

方法一：递归

思路

二叉搜索树有以下性质：

左子树的所有节点（如果有）的值均小于当前节点的值；
右子树的所有节点（如果有）的值均大于当前节点的值；
左子树和右子树均为二叉搜索树。

二叉搜索树的题目往往可以用递归来解决。此题要求删除二叉树的节点，函数 deleteNodedeleteNode 的输入是二叉树的根节点 rootroot 和一个整数 keykey，输出是删除值为 keykey 的节点后的二叉树，并保持二叉树的有序性。可以按照以下情况分类讨论：

rootroot 为空，代表未搜索到值为 keykey 的节点，返回空。
root.val>keyroot.val>key，表示值为 keykey 的节点可能存在于 rootroot 的左子树中，需要递归地在 root.leftroot.left 调用 deleteNodedeleteNode，并返回 rootroot。
root.val<keyroot.val<key，表示值为 keykey 的节点可能存在于 rootroot 的右子树中，需要递归地在 root.rightroot.right 调用 deleteNodedeleteNode，并返回 rootroot。
root.val=keyroot.val=key，rootroot 即为要删除的节点。此时要做的是删除 rootroot，并将它的子树合并成一棵子树，保持有序性，并返回根节点。根据 rootroot 的子树情况分成以下情况讨论：
    rootroot 为叶子节点，没有子树。此时可以直接将它删除，即返回空。
    rootroot 只有左子树，没有右子树。此时可以将它的左子树作为新的子树，返回它的左子节点。
    rootroot 只有右子树，没有左子树。此时可以将它的右子树作为新的子树，返回它的右子节点。
    rootroot 有左右子树，这时可以将 rootroot 的后继节点（比 rootroot 大的最小节点，即它的右子树中的最小节点，记为 successorsuccessor）作为新的根节点替代 rootroot，并将 successorsuccessor 从 rootroot 的右子树中删除，使得在保持有序性的情况下合并左右子树。
    简单证明，successorsuccessor 位于 rootroot 的右子树中，因此大于 rootroot 的所有左子节点；successorsuccessor 是 rootroot 的右子树中的最小节点，因此小于 rootroot 的右子树中的其他节点。以上两点保持了新子树的有序性。
    在代码实现上，我们可以先寻找 successorsuccessor，再删除它。successorsuccessor 是 rootroot 的右子树中的最小节点，可以先找到 rootroot 的右子节点，再不停地往左子节点寻找，直到找到一个不存在左子节点的节点，这个节点即为 successorsuccessor。然后递归地在 root.rightroot.right 调用 deleteNodedeleteNode 来删除 successorsuccessor。因为 successorsuccessor 没有左子节点，因此这一步递归调用不会再次步入这一种情况。然后将 successorsuccessor 更新为新的 rootroot 并返回。

3.代码实现

class Solution {
    public TreeNode deleteNode(TreeNode root, int key) {
        if (root == null) {
            return null;
        }
        if (root.val > key) {
            root.left = deleteNode(root.left, key);
            return root;
        }
        if (root.val < key) {
            root.right = deleteNode(root.right, key);
            return root;
        }
        if (root.val == key) {
            if (root.left == null && root.right == null) {
                return null;
            }
            if (root.right == null) {
                return root.left;
            }
            if (root.left == null) {
                return root.right;
            }
            TreeNode successor = root.right;
            while (successor.left != null) {
                successor = successor.left;
            }
            root.right = deleteNode(root.right, successor.val);
            successor.right = root.right;
            successor.left = root.left;
            return successor;
        }
        return root;
    }
}