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

今日内容

• leetcode. 530 二叉搜索树的最小绝对差
• leetcode. 501 二叉搜索树中的众数
• leetcode. 236 二叉树的最近公共祖先

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

文章链接：代码随想录 (programmercarl.com)

题目链接：530. 二叉搜索树的最小绝对差 - 力扣（LeetCode）

首先我们知道，二叉搜索树是有序的。 利用这个特性，我们可以使用任意一种遍历方式，将搜索树的节点值传到一个数组中。接着再遍历数组，减去其前一个元素获得绝对差，然后进行大小比较。这样是可以解决该问题的，但是需要遍历两次，一次是遍历搜索树，一次是遍历数组。

之前我们说过，双指针可以很好地提高效率，同样的，这里也可以使用双指针来提高效率，使最终只需要遍历一次搜索树即可得到结果。

思路就是 定义一个指针，使其每次都指向当前遍历节点的前一个节点。当要计算绝对差时，只需要用当前节点值减去前一个节点的值即可。期间再比较得到的差是否为最小。

代码如下：

class Solution {
    int result = Integer.MAX_VALUE;
    TreeNode pre; // 记录前一个节点的值
    public int getMinimumDifference(TreeNode root) {
        getMinimum(root);
        return result;
    }
    
    public void getMinimum(TreeNode node){
        if (node == null){return;}
    
        getMinimum(node.left); // 左
        
        // 中
        if (pre != null){
            result = Math.min(result, node.val - pre.val);
            
        }
        pre = node;
        
        getMinimum(node.right); // 右
    }
}

• 时间复杂度：O(n)
• 空间复杂度：O(n) 

Leetcode. 501 二叉搜索树中的众数

文章链接：代码随想录 (programmercarl.com)

题目链接：501. 二叉搜索树中的众数 - 力扣（LeetCode）

众数：出现频率最高的元素。

一般的思路就是创建一个Map，键为节点值，值为出现频率。遍历一次树之后，就可以得到各节点值的出现频率了。再按照出现频率进行排序。最后排序完之后，最前面的几个结果就是众数。

这种思路当然没有问题，它适用于处理非二叉搜索树的众数问题。但是我们要处理的是二叉搜索树，它是有序的，用这种思路解决就有点太没效率了。

既然二叉搜索树有序，那么我们就可以比较当前节点值和前一个节点值是否相同，这样就又可以引入双指针来解决了。

本题的思路如下：

1. 创建一个列表，用于记录众数。
2. 设置 count 变量记录当前元素的出现频率，maxCount 变量记录最大的出现频率。
3. 设置一个指针，使其指向当前节点的前一个节点。
4. 当前节点值若等于前一个节点值，count 加 1；否则重置为 1.
5. 将count 与 maxCount 进行比较，若二者相等，说明当前元素就是众数，写入列表中；否则说明有其他元素比当前元素出现频率更多，清空列表，将当前count赋值给maxCount，再将当前元素值写入列表。
6. 重复第3 - 5步，直到遍历结束。

按照上述思路，代码如下：

class Solution {
    int count = 0; // 当前统计频率
    int maxCount = 0; // 最大统计频率
    TreeNode pre;
    public int[] findMode(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        countElem(root, result);
        int[] array = new int[result.size()];
        for (int i = 0; i < array.length; i++){
            array[i] = result.get(i);
        }
        return array;
    }

    public void countElem(TreeNode root, List<Integer> result){
        if (root == null){return;}
        countElem(root.left, result); // 左

        // 中
        if (pre == null){ // pre为空，说明是首个节点
            count = 1;
        } else if (pre.val == root.val){ // 当前节点值与前一个节点相同，频率增加 
            count++;
        } else if (pre.val != root.val){ // 当前节点值和前一个节点不同，频率重置
            count = 1;
        }

        if (count == maxCount){ // 当前元素频率与最大频率一样，则符合众数条件
            result.add(root.val);
        }
        if (count > maxCount){ // 当前元素频率大于最大频率，说明当前元素才是众数
            maxCount = count;
            result.clear(); // 清空之前的众数
            result.add(root.val);
        }
        pre = root;

        countElem(root.right, result); // 右
    }
}

• 时间复杂度：O(n)
• 空间复杂度：O(n) 

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

文章链接：代码随想录 (programmercarl.com)

题目链接：236. 二叉树的最近公共祖先 - 力扣（LeetCode）

公共祖先的定义：对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。

在这个定义中，要求节点 x 的深度尽可能大，换言之就是希望节点 x 的高度尽可能小，尽可能接近底层，所以要找公共祖先最好是自底向上寻找。因此在本题中，我们需要使用后序遍历来解决这个问题。而且需要注意的是，在本题中，题目强调：树中所有节点的值都不相同，并且一定存在节点 p 和节点 q。

本题思路就是：后序遍历整棵树，遍历到节点 p 则返回 p，遍历到节点 q 则返回 q。若此时的中间节点的左右子树都不为空，则说明该中间节点就是最近公共祖先，返回该节点。若中间节点的左右子树有一个非空，有一个为空，则返回非空的那一个子树。具体的操作原理如下图所示：

1. 后序遍历，首先遍历到节点 1. 它不是要找的节点 5 和 6，返回null。
2. 再遍历，遍历到节点 6，是我们要找的，返回该节点。
3. 继续遍历，遍历到节点 5，是要找的节点，返回该节点。
4. 此时遍历到节点 7，该中间节点的左右子树都有返回值，都非空，说明节点 7 就是最近公共祖先。返回节点 7.
5. 遍历到节点 10，左子树为空，右子树非空，返回右子树，即节点 7.
6. 节点 8 的右子树以此类推。

最终我们得到节点 8 的左子树非空，右子树为空，返回左子树，即节点 7，故节点 7 就是我们要找的最近公共祖先。

上述步骤描绘的是节点 p 和 q 同属于一层时的情况（情况 1），但是假如其中某一个节点是另一个的父节点（情况 2），如下图所示，这时又该如何解决？

关于情况 2，其实定义中已经给出解题思路，公共祖先的定义中说到：一个节点也可以是它自己的祖先。 因此，在发现节点是 p 或 q 时，直接返回该节点就可以应付情况 2。

结合上述两个情况，写出代码如下：

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if (root == null){return root;}
        if (root == p || root == q){return root;} // 应付情况 2
        
        // 应付情况 1
        // 左
        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 left;
        } else if (left == null && right != null){ // 与左子树同理
            return right;
        } else { // 左右子树都空，该中间节点下没有要找的节点
            return null;
        }
    }
}

• 时间复杂度：O(n)
• 空间复杂度：O(n)

总结

有时候感觉，二叉树虽然就只有几个遍历方法，但是总是能玩出花来。虽然想题解时会很折磨，但是知道了它的解决思路后，又觉得很有意思。