代码随想录算法训练营第22天 || 235. 二叉搜索树的最近公共祖先 || 701.二叉搜索树中的插入操作 || 450.删除二叉搜索树中的节点

代码随想录算法训练营第22天 || 235. 二叉搜索树的最近公共祖先 || 701.二叉搜索树中的插入操作 || 450.删除二叉搜索树中的节点

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

题目简介：

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

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

个人思路：

本题与二叉树：公共祖先问题 是差不多的，可以说更简单一些。本题还有搜索树的特性可以使用

整体思路上，还是使用后序遍历操作，只不过可以通过搜索树特性判断减少一定的时间复杂度。

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        return Traversal(root, p, q);
    }

    public TreeNode Traversal(TreeNode root, TreeNode p, TreeNode q) {
        if (root == null)
            return null;
        if (root.val == p.val || root.val == q.val)
            return root;
        TreeNode left = null;
        TreeNode right = null;
        //搜索树特性减少时间复杂度
        if (p.val > root.val && q.val > root.val)
            left = Traversal(root.left, p, q);
        else if (p.val < root.val && q.val < root.val)
            right = Traversal(root.right, p, q);
        else {
            left = Traversal(root.left, p, q);
            right = Traversal(root.right, p, q);
        }
        //返回处理
        if (left == null && right == null)
            return null;
        else if (left != null && right != null)
            return root;
        else return left != null ? left : right;
    }
}

题解解析：

事实上，这道题还有很大的优化空间，我们发现可以通过搜索树优化不少

• 判断pq是否都在某个结点的左子树或均位于右子树
  • 如果都在某一侧就去那一侧继续寻找
  • 如果不在同一侧
    • 分布在两侧，那么此时的结点就是它们的最近公共祖先
    • 如果其中一个结点就是当前结点，那么这个结点也是最近公共祖先

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        return Traversal(root, p, q);
    }

    public TreeNode Traversal(TreeNode root, TreeNode p, TreeNode q) {
        if (p.val > root.val && q.val > root.val)
            return Traversal(root.right, p, q);
        else if (p.val < root.val && q.val < root.val)
            return Traversal(root.left, p, q);
        else return root;
    }
}

迭代法：

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        while (root != p && root != q) {
            if (root.val > p.val && root.val > q.val)
                root = root.left;
            else if (root.val < p.val && root.val < q.val)
                root = root.right;
            else break;
        }
        return root;
    }
}

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

题目简介：

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

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

个人思路：

采用的是最简单的找null结点位置插入的方式，直接根据搜索树特性找到合适位置即可

class Solution {
    public TreeNode insertIntoBST(TreeNode root, int val) {
        return Traversal(root, val);
    }

    public TreeNode Traversal(TreeNode root, int val) {
        if (root == null) {//找到插入位置
            TreeNode node = new TreeNode(val);
            return node;
        }
        //根据实际情况选择往左孩子或右孩子找目标
        if (val > root.val) root.right = Traversal(root.right, val);
        else root.left = Traversal(root.left, val);
        return root;
    }
}

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

题目简介：

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

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

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

示例 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
输出: []

个人思路：

整体来看这道题还是有点复杂的，我们不要急着一下子解出来，可以把问题一个个拆分解决

主要问题/步骤：

1. 找到要删除的结点

2. 如何删除节点并调整二叉树结构

   1. 大思路：找到删除结点的右孩子的一路向左孩子替换删除结点（左孩子一路向右也可）

   2. 几种要解决的情况：

      1. 删除结点左右孩子中有null结点：好办直接接上去即可

         

      2. 删除结点的右孩子无左孩子：直接将该右孩子接上去即可

         

      3. 重难点：删除结点的右孩子有左孩子

         1. 处理好一路向左孩子的右孩子
         2. 处理好一路向左孩子的新左右孩子
            

要完成这种复杂处理，我们需要设置一个pre指针，保存前一个遍历位置，这样便于我们调整孩子位置

class Solution {
    public TreeNode pre = null;

    public TreeNode deleteNode(TreeNode root, int key) {
        return Traversal(root, key);
    }

    public TreeNode Traversal(TreeNode root, int key) {
        if (root == null)
            return null;
        if (root.val == key) {
            //左右孩子出现null的简单情况处理
            if (root.left == null) return root.right;
            else if (root.right == null) return root.left;
            if (root.right.left == null) {   //左右孩子均不为null的一种简单情况的处理
                root.right.left = root.left;
                return root.right;
            }
            //左右子树均不为null，思路移动右子树的左孩子的左孩子...
            TreeNode node = root.right;//找到要更新的结点，同时移动pre
            while (node.left != null) {
                pre = node;
                node = node.left;
            }
            //node本身相连的右孩子接到pre的左孩子上
            pre.left = node.right;
            //node的左右孩子接上root的左右孩子，注意两者顺序不能乱
            node.left = root.left;
            node.right = root.right;
            return node;//返回修改后的结点
        } else if (key < root.val) root.left = Traversal(root.left, key);
        else root.right = Traversal(root.right, key);
        return root;
    }
}