力扣打卡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;
    }
}

你可能感兴趣的:(leetcode,算法,数据结构)