代码随想录-Day22

1.LeetCode 235.二叉搜索数的最近公共祖先

题目链接：力扣刷题

参考资料：代码随想录

视频讲解：B站视频讲解

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

百度百科中最近公共祖先的定义为：“对于有根树 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。

思路：和236二叉数的最近公共祖先和类似的一道题，但是这次我们要结合二叉搜树的特征来进行解题。

1.二叉搜索数，如果当root.val > q.val && root.val > p.val，此时我们只要考虑二叉搜索树的左边进行递归，如果当root.val < q.val && root.val < p.val ，我们只要靠率在二叉搜索树的邮件进行递归，其他情况那就说明一个在右边，一个在左边，那我们直接返回根节点即可（根节点是所有子节点的祖先）。

具体的java递归代码如下：

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        // 如果root 为空，且root==q和q的一个，那就说明根节点是他们的最近公共祖先
        if(root == null || root == p|| root ==q){
            return  root;
        }
        // 进行左递归处理，因为p和q的val都小于根节点,如果没找到，那就说明left接受的值是null，那就直接返回null，
        // 因为我们这个方法有返回值，那我们就要进行接受返回值，最后返回返回值即可。
        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;
        }
        // 如果都没有找到，那就直接返回root即可
        return root;
        
    }
}

层序遍历：迭代法相对来说也是一样，当root.val> p.val && root.val > q.val ,root 就向左遍历，继续判断，如果root.val < p.val && root.val < q.val ，就向右遍历，直至不满足上面2个条件，我们退出循环。返回此时的root

迭代法代码如下：

class Solution {
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
// 同递归法
        if(root == null || root == p|| root ==q){
            return  root;
        }
        // 我们使用while 循环，找到不满足的时候直接跳出循环，此时的root就是最近的公共祖先
        // 为什么不满足就直接跳出循环？ 因为是排序二叉树，且题目说明一定存在，
        // 如果不满足的情况就是一个在右边，一个在左边，那此时的节点就是最近的，我们返回即可
        while (true){
            if(root.val > q.val && root.val > p.val){
                root = root.left;
            } else if (root.val < q.val && root.val < p.val) {
                root = root.right;
            }else{
                break;
            }
        }
        return root;
    }

2.LeetCode 701.二叉所搜树的插入操作

题目链接：力扣刷题

参考资料：代码随想录

视频讲解：B站视频讲解

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

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

示例 1：

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

思路：

这道题目其实是一道简单题目，但是题目中的提示：有多种有效的插入方式，还可以重构二叉搜索树，一下子吓退了不少人，瞬间感觉题目复杂了很多。

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

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

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

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

接下来就是遍历二叉搜索树的过程了

java代码如下：

1.当root是空节点的时候，那我们的val就相当于是根节点了，直接返回即可。

2.当root不为空的时候，那就进行了递归处理，如果找到了null位置，那就说明我们的val插入的位置找到了，向上返回就好了。

3.进行递归的时候，需要判断根节点的值和val值的大小进行判断，这样，我们就不用整个二叉树进行遍历了。

class Solution {
    public TreeNode insertIntoBST(TreeNode root, int val) {
        // 如果二叉树是空的，那么我们新增的数据就是根节点，直接返回即可
        if(root == null){
            return  new TreeNode(val);
        }
        // 如果插入的树小于根节点，那就直接进行左递归处理，因为存在返回值，这个是在处理左节点，那么就是root.left来接受返回值
        // 同理右节点也如此，最后返回root节点即可
        if(root.val > val){
            root.left = insertIntoBST(root.left,val);
        } else if (root.val < val) {
            root.right = insertIntoBST(root.right,val);
        }
        return root;
    }
}

 层序遍历法：也称为迭代法

1.我们创建一个temp节点来接受当前的val要插入到那个节点下，一直进行遍历.

2.当temp的值大于val，那就创建左节点，反之创建右节点。

public TreeNode insertIntoBST(TreeNode root, int val) {
        // 判断root是否为空，为空就返回val作为根节点
        if (root == null) {
            return new TreeNode(val);
        }
        // 定义一个新二叉树
        TreeNode newRoot = root;
        // 记录值
        TreeNode temp = root;
        // 遍历二叉树，找到要插入的位置，只是要插入左边还是右边不清楚，反正在这个节点
        while (root != null) {
            // 记录当前节点
            temp = root;
            // 如果大于，就向左遍历,小于，就向有遍历
            if (temp.val > val) {
                root = root.left;
            } else if (temp.val < val) {
                root = root.right;
            }
        }
        // 找到最后一个满足条件的值，如果当前记录的值大于要插入的值，那就说明要插入的值是当前值的左节点，反之为右节点
        if (temp.val > val) {
            temp.left = new TreeNode(val);
        } else {
            temp.right = new TreeNode(val);
        }
        return newRoot;
    }

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

题目链接：力扣刷题

参考资料：代码随想录

视频讲解：B站视频讲解

给定一个二叉搜索树的根节点 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]。

 

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

有以下五种情况：

• 第一种情况：没找到删除的节点，遍历到空节点直接返回了
• 找到删除的节点
  • 第二种情况：左右孩子都为空（叶子节点），直接删除节点， 返回NULL为根节点
  • 第三种情况：删除节点的左孩子为空，右孩子不为空，删除节点，右孩子补位，返回右孩子为根节点
  • 第四种情况：删除节点的右孩子为空，左孩子不为空，删除节点，左孩子补位，返回左孩子为根节点
  • 第五种情况：左右孩子节点都不为空，则将删除节点的左子树头结点（左孩子）放到删除节点的右子树的最左面节点的左孩子上，返回删除节点右孩子为新的根节点。

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

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

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

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

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

 java代码如下：

class Solution {
    public TreeNode deleteNode(TreeNode root, int key) {
        if (root == null ) {
            return root;
        }
        // 如果root.val== 要删除的key，那么就要进行判断
        if(root.val == key){
            // 如果左子树为空，那么就直接返回右子树
            if(root.left == null){
                return  root.right;
                // 如果右子树为空，那就返回左子树
            } else if (root.right == null) {
                return  root.left;
            }else{
                // 其他情况就进行判断，我们将原来的数据要重新插入到右子树的最左点（右子树的最小值比左子树的最大值大，所以插入，只能插入在右子树最小的左方）
                TreeNode temp = root.right;
                // 一直遍历到最后一个左节点
                while (temp.left != null){
                    temp = temp.left;
                }
                // 当前最左节点的左节点存放原来属于root的左子树
                temp.left = root.left;
                // 当前的节点要被删除了，所以返回当前的右子树向上返回
                root = root.right;
                // 最后返回root；
                return root;
            }
        }
        // 进行递归
        if (root.val > key) {
            // 向左递归，那么接受的就是root.left子树了
             root.left = deleteNode(root.left, key);
        }else if(root.val < key){
            // 向右递归，那么接受的就是root.right子树了
             root.right = deleteNode(root.right,key);
        }
        //最后返回root;
        return root;
    }
}

迭代法暂时还没做，等有空在进行补充。