力扣打卡day16

遇到在二叉搜索树上求什么最值啊，差值之类的，就把它想成在一个有序数组上求最值，求差值，这样就简单多了。

530.二叉搜索树的最小绝对差

class Solution {
    int min=Integer.MAX_VALUE;
    TreeNode pre;
    public int getMinimumDifference(TreeNode root) {
        traverse(root);
        return min;
    }
    public void traverse(TreeNode cur){
        if(cur==null) return ;
        traverse(cur.left);
        if(pre!=null){
            min=Math.min(min,cur.val-pre.val);
        }
        pre=cur;
        traverse(cur.right);
    }
}

501. 二叉搜索树中的众数

class Solution {
    TreeNode pre;
    //统计单个元素出现频率
    int count;
    //统计整个二叉树中出现的最高频率
    int maxCount;
    List<Integer> res=new ArrayList<>();
    
    public int[] findMode(TreeNode root) {
        traverse(root);
        int[] result=new int[res.size()];
        for(int i=0;i<res.size();i++){
            result[i]=res.get(i);
        }
        return result;
    }
    public void traverse(TreeNode cur){
        if(cur==null) return ;
        traverse(cur.left);
        if(pre==null){
            count=1;
        }else if(pre.val==cur.val){
            count++;
        }else{//pre和cur值不相同
            count=1;
        }
         pre=cur;
        //统计结果
        if(count==maxCount) res.add(cur.val);
        if(count>maxCount){
            maxCount=count;
            //清空res，因为之前是以旧的maxCount值判断的count放入的res
            res.clear();
            //把新的count对应的值放入结果集
            res.add(cur.val);
        } 
        traverse(cur.right);
    }
}

236. 二叉树的最近公共祖先

遇到这个题目首先想的是要是能自底向上查找就好了，这样就可以找到公共祖先了。
回溯啊，二叉树回溯的过程就是从低到上。
后序遍历（左右中）就是天然的回溯过程，可以根据左右子树的返回值，来处理中节点的逻辑。
首先最容易想到的一个情况：如果找到一个节点，发现左子树出现结点p，右子树出现节点q，或者 左子树出现结点q，右子树出现节点p，那么该节点就是节点p和q的最近公共祖先。
判断逻辑是 如果递归遍历遇到q，就将q返回，遇到p 就将p返回，那么如果 左右子树的返回值都不为空，说明此时的中节点，一定是q 和p 的最近祖先

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        //递归条件
        if(root==null) return null;
        //遇到p和q就将其返回
        if(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 root;
        }
        if(left==null&&right!=null) return right;
        if(left!=null&&right==null) return left;
        else{
            return null;
        }
    }
}

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

本题是二叉搜索树，二叉搜索树是有序的，因为是有序树，所有 如果 中间节点是 q 和 p 的公共祖先，那么 中节点的数组 一定是在 [p, q]区间的。即 中节点 > p && 中节点 < q 或者 中节点 > q && 中节点 < p。
只要从上到下去遍历，遇到 cur节点是数值在[p, q]区间中则该节点cur就是q 和 p的公共祖先

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root==null) return null;
        //如果 cur->val 大于 p->val，同时 cur->val 大于q->val，那么就应该向左遍历（说明目标区间在左子树上）。
        //不知道p和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;

    }
}

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

class Solution {
    public TreeNode insertIntoBST(TreeNode root, int val) {
        //终止条件root为空，找到空节点，插入节点并返回
        //把添加的节点返回给上一层
        if(root==null){
            TreeNode node=new TreeNode(val);
            return node;
        }
        //单层递归逻辑
        if(root.val>val) root.left=insertIntoBST(root.left,val);
        if(root.val<val) root.right=insertIntoBST(root.right,val);
        return root;
    }
}

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

确定单层递归的逻辑
这里就把二叉搜索树中删除节点遇到的情况都搞清楚。

有以下五种情况：

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

class Solution {
    public TreeNode deleteNode(TreeNode root, int key) {
        //情况1
        if(root==null) return root;
        if(root.val>key){
            root.left=deleteNode(root.left,key);
        }else if(root.val<key){
            root.right=deleteNode(root.right,key);
        }else{
            //情况3
            if (root.left == null) {
                return root.right;
                //情况4
             } else if (root.right == null) {
                 return root.left;
             } else {
                 //情况5
                 TreeNode cur = root.right;
                while (cur.left != null) {
                    cur = cur.left;
                }
                cur.left = root.left;
                root = root.right;
                return root;
            }
        }
        return root;
    }
}