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

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

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

题目链接：530.二叉搜索树的最小绝对差

双指针法 + 递归

思路：暴力思想为将二叉搜索树转化为数组，进而寻找最小绝对差。利用双指针可以一次遍历就得出结果（中序遍历），如下图所示：

class Solution {
    private int result = Integer.MAX_VALUE; // 结果
    private TreeNode pre = null; // 代表当前节点的前一个节点
    public int getMinimumDifference(TreeNode root) {
        traversal(root);
        return result;
    }
    public void traversal(TreeNode root) {
        if (root == null) return; // 终止条件
        // 左
        traversal(root.left);

		// 中
        if (pre != null) {
            result = result < (root.val - pre.val) ? result : (root.val - pre.val);
        }
        pre = root;
        
		// 右
        traversal(root.right);
    }
}

501.二叉搜索树中的众数

题目链接：501.二叉搜索树中的众数

双指针法 + 递归

思路：同样采用中序遍历的方式，主要技巧在于更新结果以及 maxCount 处，目的在于一次遍历即可完成操作。

class Solution {
    ArrayList<Integer> resList; // 结果集
    int maxCount; // 某元素出现的最大频率
    int count; // 记录某元素的出现频率
    TreeNode pre; // 当前节点的前一个节点

    public int[] findMode(TreeNode root) {
        resList = new ArrayList<>();
        maxCount = 0;
        count = 0;
        pre = null;
        findMode1(root);
        int[] res = new int[resList.size()];
        for (int i = 0; i < resList.size(); i++) {
            res[i] = resList.get(i);
        }
        return res;
    }

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

        int rootValue = root.val;
        // 计数
        if (pre == null || rootValue != pre.val) {
            count = 1;
        } else {
            count++;
        }
        
        // 更新结果以及 maxCount
        if (count > maxCount) {
            resList.clear();
            resList.add(rootValue);
            maxCount = count;
        } else if (count == maxCount) {
            resList.add(rootValue);
        }
        pre = root;

        findMode1(root.right);
    }
}

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

题目链接：236. 二叉树的最近公共祖先

双指针法 + 递归

思路：首先需要考虑到自底向上查找，即二叉树的回溯。各种遍历方式中，后序遍历是天然的回溯过程，可以根据左右子树的返回值，来处理中节点的逻辑。对本题有两种情况：

1. 如果找到一个节点，发现左子树出现结点 p，右子树出现节点 q，或者左子树出现结点 q，右子树出现节点 p，那么该节点就是节点 p 和 q 的最近公共祖先，如图所示：
   判断逻辑是：如果递归遍历遇到 q，就将 q 返回，遇到 p 就将 p 返回，那么如果左右子树的返回值都不为空，说明此时的中节点，一定是 q 和p 的最近祖先。
2. 节点本身 p(q)，它拥有一个子孙节点 q§，如图所示：

对于以上两种情况，在代码的实现过程中都是一样的，也可以说实现情况一的逻辑包含了情况二，因为遇到 q 或者 p 就返回，这样也包含了 q 或者 p 本身就是公共祖先的情况。完整流程图如下：

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;
        }
    }
}