代码随想录刷题训练营DAY21|二叉树part8

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

思路：
利用二叉搜索树的有序性。

假设p和q出现在左右子树，那么root一定是p和q的最近公共祖先。
关键点：第一次遇到 cur节点是数值在[q, p]区间中，那么cur就是 q和p的最近公共祖先。

考虑单层的递归逻辑。

• [q,p] or [p,q] 的区间，如果root在这个区间里，说明LCA就是root
• 如果root小与p和q，说明p和q都在root的右子树，所以去右子树里找。
• 如果root大于p和q，说明p和q都在root的左子树，所以去左子树里找。

/**
 * 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.val>p.val&&root.val<q.val){
            return root;
        }

         if(root.val>q.val&&root.val<p.val){
            return root;
        }

        //p和q都在root的左边
        if(root.val>p.val&&root.val>q.val){
            TreeNode left=lowestCommonAncestor(root.left, p, q);
            return left;
        }
         //p和q都在root的右边
        if(root.val<p.val&&root.val<q.val){
            TreeNode right=lowestCommonAncestor(root.right, p, q);
            return right;
        }
        return root;
    }
}

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

思考单层逻辑:

class Solution {
    public TreeNode insertIntoBST(TreeNode root, int val) {
        //遍历到null结点就是我们要插入的位置
        if(root==null){
            TreeNode newnode=new TreeNode(val);
            return newnode;//返回一个新结点给上一层
        }
        if(val<root.val){
            TreeNode newleft=insertIntoBST(root.left, val);//获得一个新结点
            root.left=newleft;
            
        }
        
        if(val>root.val){
            TreeNode newright=insertIntoBST(root.right, val);//获得一个新结点
            root.right=newright;
        }
        return root;
    }
}

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

考虑多种情况。

• 叶子结点->直接删除
• 非叶子结点：

删除：
● 情况一：被删除的是叶子结点，这种情况直接删除
● 情况二：被删除的不是叶子结点（只有一颗左子树或者右子树，那就用子树来补位）

● 情况三：被删除的不是叶子结点，且有左右子树

import java.security.PrivilegedAction;/**
 * 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) {
        
        if (root == null) return null;

        if(root.val>key){
            //去左边找
            root.left=deleteNode(root.left, key);
        }else if(root.val<key){
            //去右边找
            root.right=deleteNode(root.right, key);
        }else{
            //情况1：删除的结点是叶子结点
        if(root.left==null&&root.right==null){
            return null;//返回给父节点一个空
        }
        //情况2：删除的结点时非叶子结点
        if(root.left==null&&root.right!=null){
            //左子树为空，右子树不为空，用右子树填补
            return root.right;
        }
         if(root.left!=null&&root.right==null){
            //左子树为空，左子树不为空，用左子树填补
            return root.left;
        }
        //情况3：左右子树都不为空
        if(root.left!=null&&root.right!=null){
            //找右子树中序遍历的第一个结点，也就是找右子树最小的结点
            TreeNode newnode=findMin(root.right);//找到右子树中最小的几点
            root.val = newnode.val;//将当前的root换成newnode
            root.right=deleteNode(root.right, root.val);//删除最小结点，删除那个用来替换的结点
        }
        }
        return root;
    }

    private TreeNode findMin(TreeNode root){
        while(root.left!=null){
            root=root.left;
        }
        return root;
    }
}