day19

530 力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

class Solution {
    TreeNode pre;
    int result = Integer.MAX_VALUE;
    public int getMinimumDifference(TreeNode root) {
        getMin(root);
        return result;
    }

    
    public void getMin(TreeNode root){
        if(root == null){
            return;
        }
        getMin(root.left);
        if(pre != null){
            result = Math.min(result,root.val - pre.val);
        }
        pre = root;
        getMin(root.right);
    }
}

501力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

本题我自己用了暴力解法：
 

class Solution {
    Map<Integer,Integer> map = new TreeMap<>();
        public int[] findMode(TreeNode root) {
            if(root == null){
                return new int[]{};
            }
            orderView(root);
            PriorityQueue<int[] > pq = new PriorityQueue<>(new Comparator<int[]>() {
                @Override
                public int compare(int[] o1, int[] o2) {
                    return o2[1] - o1[1];
                }
            });
            for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
                pq.offer(new int[]{entry.getKey(),entry.getValue()});
            }
            int peek = pq.peek()[1];
            ArrayList<Integer> list =new ArrayList<>();
            for(int i = 0;i<map.size();i++){
                int[] poll = pq.poll();
                if(poll[1] == peek){
                    list.add(poll[0]);
                }
            }
            int[] array = new int[list.size()];
            for(int i = 0;i<array.length;i++){
                array[i] = list.get(i);
            }
            return array;
        }
        public void orderView(TreeNode root){
            if(root == null)
                return;
            orderView(root.left);
            map.put(root.val,map.getOrDefault(root.val,0) + 1);
            orderView(root.right);
        }
    
}

中序遍历 —— 加到map中——转大顶堆——得到和peek()一样的值的数，非常繁琐

用随想录的方法：

class Solution {
    ArrayList<Integer> list = new ArrayList<>();
//记录每个数出现的次数
    int count = 0;
//记录最大数
    int countMax = 0;
//前一个结点
    TreeNode pre;
        public int[] findMode(TreeNode root) {
           orderView(root);
           int[] res = new int[list.size()];
           for(int i = 0; i < res.length; i++){
               res[i] = list.get(i);
           }
           return res;
        }
        public void orderView(TreeNode root){
           if(root == null){
               return;
           }
           findMode(root.left);
//pre == null 初始化count，
root.val != pre.val 上一个数在这颗二叉搜索树中已经没了，重新计数
           if(pre == null || root.val != pre.val){
               count = 1;
           }else{
               count++;
           }
//如果大于，则更新
           if(count > countMax){
               list.clear();
               list.add(root.val);
               countMax = count;
//小于则继续添加
           }else if(count == countMax){
               list.add(root.val);
           }
           pre = root;
           findMode(root.right);
        }
    
}

236.

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if (root == null || 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) { // 若未找到节点 p 或 q
            return null;
        }else if(left == null && right != null) { // 若找到一个节点
            return right;
        }else if(left != null && right == null) { // 若找到一个节点
            return left;
        }else { // 若找到两个节点
            return root;
        }
    }
}