DAY22 【二叉树】235. 二叉搜索树的最近公共祖先 | 701.二叉搜索树中的插入操作 | 450.删除二叉搜索树中的节点

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

• 235. 二叉搜索树的最近公共祖先 | 题目链接
• 代码随想录 | 讲解链接
• 题意：给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。
  
• 思路：可以用普通二叉树的最近公共祖先方法求解，即回溯。完全同236.二叉树的最近公共祖先

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
//普通二叉树的最近公共祖先方法求解，与236.二叉树的最近公共祖先相同。
class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root == null || root == p || root == q) return root;

        TreeNode left = lowestCommonAncestor(root.left, p, q);
        TreeNode right = lowestCommonAncestor(root.right, p, q);

        if(left == null && right == null) {
            return null;
        } else if(left != null && right == null) {
            return left;
        } else if(left == null && right != null) {
            return right;
        } else {
            return root;
        }
    }
}

• 也可利用二叉搜索树的特性，确定搜索方向。

  二叉搜索树是有序的，如果中间节点是q和p的公共祖先，那么中间节点的大小一定在[p,q]区间内。

  即中间节点 > p && 中间节点 < q 或者 中间节点 > q && 中间节点 < p。

  据此，只要从上向下遍历，遇到当前节点是在[p,q]区间内的节点就说明该节点是p和q 的公共祖先。但是如何确定此节点就是最近的公共祖先呢？用举反例的方法，举不出遇到公共节点后继续往下走还有公共节点的例子。因此说明当遇到符合条件的公共节点时，就是所要找的最近的公共节点。

  此题是从上往下遍历找节点，不涉及遍历顺序，也没有中间节点的处理逻辑，所以遍历顺序可以自由选择。

• 递归法三部曲
  确定递归函数的返回值和参数：返回的是最近的公共节点，故返回Treenode，参数就是当前节点、两个目标节点p，q。

  确定终止条件：不需要终止条件，因为一定会找到一个最近的公共祖先，所以不可能存在遇到空的情况。

  单层递归的逻辑：遍历二叉树时要判断当前节点的大小在区间[p,q]内，如果cur.va > p && cur.va >q，则应向左孩子遍历，因此需调用递归函数把左孩子传入参数，然后return左孩子。
  如果cur.val < p && cur.val < q，则向右遍历，因此调用递归函数把有孩子传入参数，然后return右孩子。
  剩下的情况就是cur.val在两者之间的情况了，那么cur就是最近的公共节点了，直接返回cur即可。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root == null) {
            return null;
        }

        //二叉搜索树，可以利用性质确定遍历方向
        //如果根节点的值比p和q大，就向左遍历
        if(root.val > p.val && root.val > q.val) {
            TreeNode left = lowestCommonAncestor(root.left, p, q);
            return left;
        } else if(root.val < p.val && root.val < q.val) { 
            //反之，向右遍历
            TreeNode right = lowestCommonAncestor(root.right, p, q);
            return right;
        } else {
            //如果根节点值比p大，比q小，那此节点就是两个节点的最近公共节点
            return root;
        }  
    }
}

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

• 701.二叉搜索树中的插入操作 | 题目链接

• 代码随想录 | 讲解链接

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

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

• 思路：总可以在叶子节点找到插入节点的位置。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode insertIntoBST(TreeNode root, int val) {
        //不需要改变现存二叉树的结构，只需要遇到空节点时，把val插入到合适位置的空节点就可以。把添加的节点返回给上一层，就完成了父子节点的赋值操作了。
        if(root == null) {
            TreeNode node = new TreeNode(val);
            return node;
        }

        //二叉搜索树无需遍历整棵树。如果根节点的值大于val，那val只能插到左子树
        if(root.val > val) {
            root.left = insertIntoBST(root.left, val);
        } else if(root.val < val) { //同理，只能插到右子树
            root.right = insertIntoBST(root.right, val);
        } //直到找到一个合适的null位置，把val插入。
        return root;
    }
}

• 迭代方法：从上往下一个一个的迭代遍历，用两个节点，一个节点记录原先的root节点，用于最后返回原先的根节点。另一个临时节点用于从上往下根据条件遍历，变换位置用。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode insertIntoBST(TreeNode root, int val) {
        //如果是个空树，直接返回新节点
        if(root == null) return new TreeNode(val);

        //用newRoot记录最开始的根节点，以便最后返回结果
        TreeNode newRoot = root;
        //用cur节点记录一直往下遍历需寻找的节点
        TreeNode pre = root;

        //找到满足条件的空节点的位置,当前节点一直往下遍历
        while(root != null) {
            pre = root;
            if(root.val > val) {
                root = root.left;
            } else if(root.val < val) {
                root = root.right;
            }
        }

        //找到位置后插入新的节点
        if(pre.val > val) {
            pre.left = new TreeNode(val);
        } else {
            pre.right = new TreeNode(val);
        }
        return newRoot;
    }
}

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

• 450.删除二叉搜索树中的节点 | 题目链接

• 代码随想录 | 讲解链接

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

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

  首先找到需要删除的节点； 如果找到了，删除它。 说明： 要求算法时间复杂度为 $O(h)$，h 为树的高度。
  

• 思路：比添加节点复杂，因为可能要调整二叉树的结构

  情况1：没找到要删除的节点
  情况2：要删的节点是叶子节点（左右孩子都为空）
  情况3：要删的节点的左孩子不空，右孩子为空。让删除的节点的父节点直接指向要删除节点的其左孩子。
  情况4：要删的节点的左孩子为null，右孩子不空。让删除的节点的父节点直接指向要删除节点的其右孩子。
  情况5：要删的节点左右孩子都不为空。（最复杂，要大幅调整二叉树的结构）—— 让右孩子继位，就要妥善安排左子树的位置。左子树上的元素比删除的元素小，而右子树的元素都比删除的元素大。那么可以把左子树放到右子树的最左侧的叶子节点下（也就是右子树中最小的元素，也比所有的左子树大）

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode deleteNode(TreeNode root, int key) {
        //终止条件：找到要删的元素就终止了，删除元素的逻辑就写在终止条件内
        //情况1：没找到要删除的节点/传入的原始二叉树为空，我们就返回空（这样比较好理解）
        if(root == null) {
            return null;
        }

        if(root.val == key) {
            //情况2：要删的节点是叶子节点（左右孩子都为空）
            if(root.left == null && root.right == null) {
                return null;
            } else if(root.left != null && root.right == null) {
                //情况3：要删的节点的左孩子不空，右孩子为空
                return root.left;
            } else if(root.left == null && root.right != null) {
                //情况4：要删的节点的左孩子为null，右孩子不空。
                return root.right;
            } else {
                //情况5：要删的节点左右孩子都不为空。
                //让右孩子继位，找到右子树的最左侧的元素。
                TreeNode cur = root.right;
                while(cur.left != null) {
                    cur = cur.left;
                }
                //把要删除的节点的左子树放到cur下了，重构了二叉树的结构
                cur.left = root.left;
                return root.right;
            }
        }

        //单层递归逻辑，二叉搜索树可以确定搜索方向
        if(key < root.val) {
            root.left = deleteNode(root.left, key);
        } else if(key > root.val) {
            root.right = deleteNode(root.right, key);
        }
        return root;
    }
}