随想录Day22--235. 二叉搜索树的最近公共祖先 ，701.二叉搜索树中的插入操作 ，450.删除二叉搜索树中的节点

今天的三道题总结起来就是二叉搜索树的查、增、删，典型的增删查改类型，改直接对val的值进行操作，没有算法意义，所以这三题基本就是把二叉树的操作覆盖了。

首先查，找公共祖先，之前做过普通二叉树的公共祖先，递归返回值为boolean类型，目的就是判断其子树是否还有其中的某一个值，把这个信息上传，然后再找到一个节点，能够使得左右子树或者说本身和其子树含有这两个值，就找到了公共祖先。二叉搜索树，基于有序性，找到第一个满足节点的值在于两个值之间就可以了。

那么本题是二叉搜索树，二叉搜索树是有序的，那得好好利用一下这个特点。

在有序树里，如果判断一个节点的左子树里有p，右子树里有q呢？

因为是有序树，所有 如果 中间节点是 q 和 p 的公共祖先，那么 中节点的数组 一定是在 [p, q]区间的。即 中节点 > p && 中节点 < q 或者 中节点 > q && 中节点 < p。

那么只要从上到下去遍历，遇到 cur节点是数值在[p, q]区间中则一定可以说明该节点cur就是q 和 p的公共祖先。 那问题来了，一定是最近公共祖先吗？

如图，我们从根节点搜索，第一次遇到 cur节点是数值在[p, q]区间中，即 节点5，此时可以说明 p 和 q 一定分别存在于 节点 5的左子树，和右子树中。

此时节点5是不是最近公共祖先？ 如果 从节点5继续向左遍历，那么将错过成为q的祖先， 如果从节点5继续向右遍历则错过成为p的祖先。

所以当我们从上向下去递归遍历，第一次遇到 cur节点是数值在[p, q]区间中，那么cur就是 p和q的最近公共祖先。

理解这一点，本题就很好解了。

而递归遍历顺序，本题就不涉及到 前中后序了（这里没有中节点的处理逻辑，遍历顺序无所谓了）。

如图所示：p为节点6，q为节点9

可以看出直接按照指定的方向，就可以找到节点8，为最近公共祖先，而且不需要遍历整棵树，找到结果直接返回！

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

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

百度百科中最近公共祖先的定义为：“对于有根树 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 为不同节点且均存在于给定的二叉搜索树中。

class Solution {
    //运用递归思路，在递归函树里面寻找合适满足条件的节点，因为递归压栈后
    //弹出来的最后一个满足条件的节点相当于从上往下的第一个节点，所以定义
    //一个全局变量，一直迭代到满足条件，当然，条件限制情况下，下面的方法更加清晰。
    // TreeNode res;
    // public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
    //     find(root, p ,q);
    //     return res;
    // }
    // public void find(TreeNode node, TreeNode p, TreeNode q){
    //     if((node.val <= p.val && node.val >= q.val) || (node.val >= p.val && node.val <= q.val)){
    //         res = node;
    //     }
    //     if(node.val > p.val && node.val > q.val){
    //         find(node.left, p, q);
    //     }
    //     if(node.val < p.val && node.val < q.val){
    //         find(node.right, p, q);
    //     }
    // }
    //直接进行递归，因为这样的话，它是从上往下开始寻找的，和最开始的压栈递归不一样
    //在左右孩子中寻找值，找到第一个就直接return，不会在继续遍历下去
    //如果是已知遍历下去的，那就和普通的二叉树一样了。
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
         if(root.val > p.val && root.val > q.val){
            return lowestCommonAncestor(root.left, p, q);
         }
         if(root.val < p.val && root.val < q.val){
           return lowestCommonAncestor(root.right, p, q);
         }
        return root;
    }
}

第二题插值操作，也就是增操作。如果是普通的二叉树，可能需要涉及到移位的操作，这里二叉搜索树没有重复值，所以关键思路在于找到合适的位置进行插入。寻找位置有两个关键点，第一个是要插入后还要满足二叉搜索树，所以要保持其有序性，因此可以根据大小去减少递归的次数；第二个关键点是插入的地方是null，这样可以很好保持其有序性，也不需要太大操作。

这题不要考虑重新构造树，如果考虑，也可以先中序遍历一边树，把值放入一个数组，这个数组是有序的，然后在数组插入需要插入的值，再根据新数组构造树。

不考虑题目中提示所说的改变树的结构的插入方式。

如下演示视频中可以看出：只要按照二叉搜索树的规则去遍历，遇到空节点就插入节点就可以了。

例如插入元素10 ，需要找到末尾节点插入便可，一样的道理来插入元素15，插入元素0，插入元素6，需要调整二叉树的结构么？ 并不需要。。

只要遍历二叉搜索树，找到空节点 插入元素就可以了，那么这道题其实就简单了。

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

给定二叉搜索树（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中不存在。

class Solution {
    //这个思路比较好理解，首先用递归找到需要插入地方的条件，也就是找到对应的空节点，直接插入就可以。
    //第一种情况时当root为空时，直接插入就可以。
    // public TreeNode insertIntoBST(TreeNode root, int val) {
    //     if(root == null){
    //         root = new TreeNode(val);
    //     }else{
    //         find(root, val);
    //     }
    //     return root;
    // }
    // public void find(TreeNode node, int val){        
    //     if(node.val > val){
    //         if(node.left == null){
    //             node.left = new TreeNode(val);
    //         }else{
    //             find(node.left, val);
    //         }
    //     }
    //     if(node.val < val){
    //         if(node.right == null){
    //             node.right = new TreeNode(val);
    //         }else{
    //             find(node.right, val);
    //         }
    //     }
    // }

    //这个是将递归有返回值，把插入的节点作为返回值返给孩子节点，最后再返回根节点，相当于上面方法的简化版
    public TreeNode insertIntoBST(TreeNode root, int val) {     
        return find(root, val);
    }
    public TreeNode find(TreeNode node, int val){        
        if(node == null){
            return new TreeNode(val);
        }
        if(node.val > val){
            node.left = find(node.left, val);
        }
        if(node.val < val){
            node.right = find(node.right, val);
        }
        return node;
    }

}

第三题是删操作，其实就是查和增的叠加版，先查到满足条件的节点，然后把把合适的节点增在删的位置。它的关键在于情况判断要写清楚，并且递归的返回值要想好。因为删除一个节点后，再补上另一个节点可以看成是补一棵子树，所以考虑返回值是一个树类型的值。查找过程中总共的5种情况，每种情况对应的返回值要捋清楚，画图更加清晰！！！最复杂的是左右孩子都不是空的情况，这时候要把左孩子接在右孩子的最左端，因为二叉搜索树左边的永远比右边小，所以左孩子只能在右孩子的最左边。

这里就把二叉搜索树中删除节点遇到的情况都搞清楚。

有以下五种情况：

• 第一种情况：没找到删除的节点，遍历到空节点直接返回了

• 找到删除的节点

• 第二种情况：左右孩子都为空（叶子节点），直接删除节点， 返回NULL为根节点

• 第三种情况：删除节点的左孩子为空，右孩子不为空，删除节点，右孩子补位，返回右孩子为根节点

• 第四种情况：删除节点的右孩子为空，左孩子不为空，删除节点，左孩子补位，返回左孩子为根节点

• 第五种情况：左右孩子节点都不为空，则将删除节点的左子树头结点（左孩子）放到删除节点的右子树的最左面节点的左孩子上，返回删除节点右孩子为新的根节点。

第五种情况有点难以理解，看下面动画：

动画中的二叉搜索树中，删除元素7， 那么删除节点（元素7）的左孩子就是5，删除节点（元素7）的右子树的最左面节点是元素8。

将删除节点（元素7）的左孩子放到删除节点（元素7）的右子树的最左面节点（元素8）的左孩子上，就是把5为根节点的子树移到了8的左孩子的位置。

要删除的节点（元素7）的右孩子（元素9）为新的根节点。.

这样就完成删除元素7的逻辑，最好动手画一个图，尝试删除一个节点试试。

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

输出: []

提示:

• 节点数的范围 [0, 104].

• -105 <= Node.val <= 105

• 节点值唯一

• root 是合法的二叉搜索树

• -105 <= key <= 105

进阶： 要求算法时间复杂度为 O(h)，h 为树的高度。

class Solution {
    //运用递归解题，递归的目的是遍历到满足条件的节点，然后再满足条件的节点上进行操作
    public TreeNode deleteNode(TreeNode root, int key) {
        return find(root,key);
    }
    public TreeNode find(TreeNode node, int key){
        //寻找节点要分为5种情况
        //如果没有找到节点，且已经是根节点了，那么就返回一个空，不用删除
        if(node == null){
            return null;
        }
        //如果找到了对应值的节点，就要分成4种情况判断
        if(node.val == key){
            //如果是叶子节点，直接把这个值删了就可以，返回null给父节点接住。
            if(node.left == null && node.right == null){
                return null;
            }
            //如果是其中一个为空，则把另一个节点直接返回给父节点
            if(node.left == null && node.right != null){
                return node.right;
            }
            if(node.left != null && node.right == null){
                return node.left;
            }
            //如果左右都不是空，那么就把左孩子放到右孩子的最左边的地方
            //再把右孩子返回。
            if(node.left != null && node.right != null){
                TreeNode left = node.left;
                TreeNode right = node.right;
                while(right.left != null){
                    right = right.left;
                }
                right.left = left;
                node.left = null;
                return node.right;
            }
        }
        //如果还没有遍历到根节点，并且没有找到，就继续往下遍历。
        node.left = find(node.left, key);
        node.right = find(node.right, key);
        return node;
        
    }
}