算法训练营打卡Day21 | 二叉树part07

一、LC530.二叉搜索树的最小绝对差 

代码随想录

中序遍历，用一个TreeNode记录前一个节点，然后计算比较当前节点和前一个节点的差值。

class Solution {
    int result = Integer.MAX_VALUE;
    TreeNode pre;
    public int getMinimumDifference(TreeNode root) {
        //叶子节点
        if (root == null) {
            return 0;
        }

        //左节点
        getMinimumDifference(root.left);

        //中间节点
        if (pre != null) {
            result = Integer.min(result, root.val - pre.val);
        }
        pre = root;
        
        //右节点
        getMinimumDifference(root.right);

        return result;
    }
}

二、LC501.二叉搜索树中的众数 

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

方法一：利用搜索二叉树的特性，中序遍历二叉搜索树时，元素从小到大排序，相同元素会挨在一起，只用一个TreeNode记录当前元素是否和上一个元素相同。

count记录当前元素出现的此时，maxCount记录当前出现次数最多的元素出现的此时，result记录出现次数等于maxCount的所有元素（可能不止一个）。

中序遍历：左中右（按从小到大顺序遍历二叉树） ，终止条件：cur == null

在中间处理，

1. 更新count，三种情况

a) 如果pre != null && cur.val == pre.val, count++

b) 如果pre != null && cur.val != pre.val, count = 1，上一个元素看完了，新的值目前只出现了一次

c) 如果pre == null， 说明是遍历遇到的第一个节点，count = 1

2. 更新pre指针， pre = cur

3. 判断是否需要更新maxCount和result数组

a) count < maxCount, 不更新

b) count == maxCount, 加当前元素到result中

c) count > maxCount，新的众数出现，result中元素不再符合要求，result清空，将当前数字加入，更新 maxCount = count

class Solution {
    List<Integer> result = new ArrayList<>();
    TreeNode pre;
    int maxCount = 0;
    int count = 0;

    public int[] findMode(TreeNode root) {
        traverse(root);
        int[] ans = new int[result.size()];
        for (int i = 0; i < ans.length; i++) {
            ans[i] = result.get(i);
        }
        return ans;
    }

    public void traverse(TreeNode cur) {
        if (cur == null) {
            return;
        }

        //左
        traverse(cur.left);

        //中
        //1.更新count
        if (pre != null) {
            if (pre.val == cur.val) {
                count++;
            } else {
                count = 1;
            }
        } else {
            //遍历的第一个节点（最左下）
            count = 1;
        }
        //2. 更新pre节点
        pre = cur;

        //3. 更新maxCount
        if (count == maxCount) {
            result.add(cur.val);
        } else if (count > maxCount) {
            result.clear();
            result.add(cur.val);
            maxCount = count;
        }
        
        //右
        traverse(cur.right);
    }
}

方法二：遍历二叉树，统计每个元素出现的次数存在Map中，然后对Map进行排序找到出现次数最大的众数。

class Solution {
    public int[] findMode(TreeNode root) {
        Map<Integer, Integer> map = new HashMap<>();
        traverse(root, map);
        List<Map.Entry<Integer, Integer>> list = new ArrayList<>(map.entrySet());
        Collections.sort(list, new Comparator<Map.Entry<Integer, Integer>>() {
            public int compare(Map.Entry<Integer, Integer> e1, Map.Entry<Integer, Integer> e2) {
                return e2.getValue().compareTo(e1.getValue());
            }
        });
        List<Integer> result = new ArrayList<>();
        int count = list.get(0).getValue();
        for (Map.Entry<Integer, Integer> entry : list) {
            if (entry.getValue() == count) {
                result.add(entry.getKey());
            } else {
                break;
            }
        }
        int[] a = new int[result.size()];
        for (int i = 0; i < result.size(); i++) {
            a[i] = result.get(i);
        }
        return a;
    }

    public void traverse(TreeNode root, Map<Integer, Integer> map) {
        if (root == null) {
            return;
        }
        //左
        traverse(root.left, map);
        //中
        map.put(root.val, map.getOrDefault(root.val, 0) + 1);
        //右
        traverse(root.right, map);

    }

三、LC236. 二叉树的最近公共祖先  

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

自底向上查找，有点难度！ | LeetCode：236. 二叉树的最近公共祖先_哔哩哔哩_bilibili

代码随想录

思路：查找节点左右子节点看是否含有p,q，然后统计到中间节点（后序遍历：左右中）

重要前提：p,q都存在

1. 终止条件

遇到空的话，因为树都是空了，所以返回空。

那么我们来说一说，如果 root == q，或者 root == p，说明找到 q p ，则将其返回。

2.确定单层递归逻辑  后序遍历，先看左右子树，然后在中间节点处理

值得注意的是 本题函数有返回值，是因为回溯的过程需要递归函数的返回值做判断，但本题我们依然要遍历树的所有节点。

如果left 和 right都不为空，说明此时root就是最近公共节点。

如果left为空，right不为空，就返回right，说明目标节点是通过right返回的，反之依然。

如果left 和 right都为空，返回null，说明没找到。

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if (root == null) {
            return null;
        }

        if (root == p) {
            return root;
        }

        if (root == q) {
            return root;
        }

        TreeNode left = lowestCommonAncestor(root.left, p, q);
        TreeNode right = lowestCommonAncestor(root.right,  p, q);
        //中
        if (left == null && right == null) {
            return null;
        } else if (left != null && right == null) {
            return left;
        } else if (left == null && right != null) {
            return right;
        } else {//left != null && right != null
            return root;
        }
        
    }
}