代码随想录day21|530. 二叉搜索树的最小绝对差、501. 二叉搜索树中的众数、236. 二叉树的最近公共祖先

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

注意：×

1. 一眼分析就是右边的树和左边最大树进行比较，左边节点和右边最小比较
2. 结果太蠢了，刷多了已经忘记二叉搜索树是有序数组的本质了
3. 使用了遍历的方法，引入pre表示上一个节点，非常巧妙，值得反复看
4. // 中序遍历位置 if (prev != null) { res = Math.min(res, root.val - prev.val); } prev = root;非常值得反复看

class Solution {
    public int getMinimumDifference(TreeNode root) {
        traverse(root);
        return res;
    }

    TreeNode prev = null;
    int res = Integer.MAX_VALUE;

    // 遍历函数
    void traverse(TreeNode root) {
        if (root == null) {
            return;
        }
        traverse(root.left);
        // 中序遍历位置
        if (prev != null) {
            res = Math.min(res, root.val - prev.val);
        }
        prev = root;
        traverse(root.right);
    }
}

leetcode501. 二叉搜索树中的众数

注意：×

1. 乍一看可以直接转数组用map，后来发现确实如题解所说没有使用二叉搜索树的性质
2. 自己看了以后@test才意识到为什么findMode函数中是遍历mode，然后将值传递给res
3. 是因为众数可能不止一个，操作是很合理的，需要仔细体会一下，非常容易出错

class Solution {
    ArrayList<Integer> mode = new ArrayList<>();
    TreeNode prev = null;
    // 当前元素的重复次数
    int curCount = 0;
    // 全局的最长相同序列长度
    int maxCount = 0;

    public int[] findMode(TreeNode root) {
        // 执行中序遍历
        traverse(root);

        int[] res = new int[mode.size()];
        for (int i = 0; i < res.length; i++) {
            res[i] = mode.get(i);
        }
        return res;
    }

    void traverse(TreeNode root) {
        if (root == null) {
            return;
        }
        traverse(root.left);

        // 中序遍历位置
        if (prev == null) {
            // 初始化
            curCount = 1;
            maxCount = 1;
            mode.add(root.val);
        } else {
            if (root.val == prev.val) {
                // root.val 重复的情况
                curCount++;
                if (curCount == maxCount) {
                    // root.val 是众数
                    mode.add(root.val);
                } else if (curCount > maxCount) {
                    // 更新众数
                    mode.clear();
                    maxCount = curCount;
                    mode.add(root.val);
                }
            }

            if (root.val != prev.val) {
                // root.val 不重复的情况
                curCount = 1;
                if (curCount == maxCount) {
                    mode.add(root.val);
                }
            }
        }
        // 别忘了更新 prev
        prev = root;

        traverse(root.right);
    }
}

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

注意：×

1. 今日时间超时了，这题自己写也没考虑出来，直接看答案，复习的时候再详细看
2. 注意代码随想录文章里面关于递归返回值的论述，感觉还是很有意思的
3. 第二天回头看发现了Labuladong书中最后有这一系列题目的解答，深刻体会

    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        // base case
        if (root == null) return null;
        if (root == p || root == q) return root;

        TreeNode left = lowestCommonAncestor(root.left, p, q);
        TreeNode right = lowestCommonAncestor(root.right, p, q);
        // 情况 1
        if (left != null && right != null) {
            return root;
        }
        // 情况 2
        if (left == null && right == null) {
            return null;
        }
        // 情况 3
        return left == null ? right : left;
    }