代码随想录算法训练营第 18 天 | 530. 二叉搜索树的最小绝对差、501. 二叉搜索树中的众数、236. 二叉树的最近公共祖先

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

题目链接

简单方法：中序遍历转成数组，判断数组相邻元素差最小值
代码略

双指针法：用中序遍历，再遍历过程中得出最小值

和 98. 验证二叉搜索树 差不多

class Solution {

    int result = Integer.MAX_VALUE;
    TreeNode pre = null;

    public int getMinimumDifference(TreeNode root) {
        traversal(root);
        return result;
    }

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

        // 左
        traversal(cur.left);

        // 中
        if (pre != null) {
            result = Math.min(result, cur.val - pre.val);
        }
        pre = cur;

        // 右
        traversal(cur.right);
    }
}

之所以有效：
因为先一直递归到左叶子，才给 pre 赋值，pre 赋值的一直都是 cur，所以 pre 一直跟在 cur 屁股后面，而 cur 是中序遍历，所以能够满足题意。

---

501. 二叉搜索树中的众数

题目链接

还是双指针法，遍历一遍二叉树即可

注意众数可以有多个

class Solution {
    int count = 1; // 统计单个元素出现次数
    int maxCount = 1; // 统计最大出现次数
    List<Integer> list = new ArrayList<>(); // 存放结果，会转成数组
    TreeNode pre = null;

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

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

        // 左
        traversal(cur.left);

        // 中
        if (pre != null) {
            if (cur.val == pre.val) {
                count++;
            } else {
                count = 1;
            }
        }
        pre = cur;

        if (count == maxCount) {
            list.add(cur.val);
        } else if (count > maxCount) {
            maxCount = count;
            list.clear();
            list.add(cur.val);
        }

        // 右
        traversal(cur.right);
    }
}

---

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

题目链接

要从下往上返回逻辑，用后序遍历

左子树有没有出现过 p 或 q
右子树有没有出现过 p 或 q
如果都为是，则该节点为最近公共祖先

即
左子树和右子树判断都不为空，返回这个节点
左子树判断为空，右子树判断不为空，返回右子树
左子树判断不为空，右子树判断为空，返回左子树
左右子树判断都为空，返回空

如果是第二种情况，自己是最近公共祖先，那么遇到自己的时候就直接返回了，甚至不会遍历自己下面的节点

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        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);

        // 中
        if (left != null && right != null) {
            return root;
        }
        if (left == null && right != null) { // 妙，返回了逻辑，还包含了第二种情况
            return right;
        }
        if (left != null && right == null) { // 妙
            return left;
        }
        return null; // if (left == null && right == null)
    }
}

---

提炼模板：二叉树中序遍历双指针

class Solution {
    TreeNode pre = null;

    public int get(TreeNode root) {
        traversal(root);
        return result;
    }

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

        // 左
        traversal(cur.left);

        // 中
        if (pre != null) {
            ...
        }
        pre = cur;

        // 右
        traversal(cur.right);
    }
}

优化：不把 pre 设置成 TreeNode 型，设置成节点的值的实际类型以避免判断空指针（大部分为 int）