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

class Solution {
    int pre;
    int res;
    public int getMinimumDifference(TreeNode root) {
        if(root == null)return 0;
        pre = -1;
        res = Integer.MAX_VALUE;
        dfs(root);
        return res;
    }
    private void dfs(TreeNode node){
        if(node == null)return;

        dfs(node.left);

        if(pre == -1){
            pre = node.val;
        }
        else{
            res = Math.min(res, Math.abs(node.val - pre));
            pre = node.val;
        }

        dfs(node.right);
    }
}

501. 二叉搜索树中的众数

class Solution {
    int curCount;
    int maxCount;
    TreeNode pre;
    ArrayList<Integer> mode;
    public int[] findMode(TreeNode root) {
        curCount = 0;
        maxCount = 0;
        pre = null;
        mode = new ArrayList<>();

        traverse(root);

        int[] res = new int[mode.size()];
        for(int i = 0; i < mode.size(); i++){
            res[i] = mode.get(i);
        }
        return res;
    }
    private void traverse(TreeNode node){
        if(node == null)return;

        traverse(node.left);

        if(pre == null){
            // 初始化
            curCount = 1;
            maxCount = 1;
            mode.add(node.val);
        }
        else{
            if(node.val == pre.val){ // 重复的情况
                curCount++;

                if(curCount == maxCount){
                    mode.add(node.val);
                }
                else if(curCount > maxCount){
                    mode.clear();
                    maxCount = curCount;
                    mode.add(node.val);
                }
            }
            else if(node.val != pre.val){ // 不重复的情况
                curCount = 1;
                if(curCount == maxCount){
                    mode.add(node.val);
                }
            }
        }

        // 更新pre
        pre = node;

        traverse(node.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)return root;
        else if(left == null && right != null)return right;
        else if(left != null && right == null)return left;
        else return null; // if(left == null && right == null)
    }
}