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

最新推荐文章于 2024-05-20 20:08:58 发布

Aaron_Yang.

最新推荐文章于 2024-05-20 20:08:58 发布

阅读量806

点赞数 18

分类专栏：代码随想录算法训练营文章标签：算法

本文链接：https://blog.csdn.net/captain_aaron/article/details/136040232

版权

代码随想录算法训练营专栏收录该内容

51 篇文章 0 订阅

订阅专栏

二叉树理论基础：

https://programmercarl.com/%E4%BA%8C%E5%8F%89%E6%A0%91%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE

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

题目链接：https://leetcode.cn/problems/minimum-absolute-difference-in-bst/

思路:

遇到在二叉搜索树上求最值，差值之类的，就把它想成在一个有序数组上求最值，求差值，这样就简单多了。
那么二叉搜索树采用中序遍历，其实就是一个有序数组。
但是这题的话，也可以不引入额外空间，不使用额外的有序数组，用一个pre结点记录一下cur结点的前一个结点就可以了。

class Solution {
    private int min_val = Integer.MAX_VALUE;
    private TreeNode pre = null;
    public int getMinimumDifference(TreeNode root) {
        traversal(root);
        return min_val;
    }
    // 左中右
    public void traversal(TreeNode root){
        if(root == null)   return;
        traversal(root.left);
        if(pre != null){
            min_val = Math.min(min_val,root.val-pre.val);
        }
        pre = root;
        traversal(root.right);
    }
}

501.二叉搜索树中的众数

题目连接：https://leetcode.cn/problems/find-mode-in-binary-search-tree/

思路1：（如果不是二叉搜索树）

如果不是二叉搜索树，最直观的方法一定是把这个树都遍历了，用map统计频率，把频率排个序，最后取前面高频的元素的集合。

具体步骤如下：
这个树都遍历了，用map统计频率；
至于用前中后序哪种遍历也不重要，因为就是要全遍历一遍，怎么个遍历法都行，层序遍历也没毛病。

同时，要注意一下，对map中的value排序，具体是怎么实现的。

class Solution {
    // 如果不是二叉搜索树
    public int[] findMode(TreeNode root) {
        Map<Integer,Integer> map = new HashMap<>();
        List<Integer> list = new ArrayList<>();
        if(root == null)    return list.stream().mapToInt(Integer::intValue).toArray();
        // 拿到二叉树对应的频率map
        searchBST(root,map);
        List<Map.Entry<Integer,Integer>> mapList = map.entrySet().stream().sorted((c1,c2) -> c2.getValue().compareTo(c1.getValue())).collect(Collectors.toList());
        list.add(mapList.get(0).getKey());
        // 把其他频率最高的加入list
        for(int i=1;i<mapList.size();i++){
            if(mapList.get(i).getValue() == mapList.get(i-1).getValue()){
                list.add(mapList.get(i).getKey());
            }else{
                break;
            }
        }
        return list.stream().mapToInt(Integer::intValue).toArray();
    }
    public void searchBST(TreeNode curr, Map<Integer,Integer> map){
        if(curr == null)    return ;
        map.put(curr.val,map.getOrDefault(curr.val,0)+1);
        searchBST(curr.left,map);
        searchBST(curr.right,map);
    }
}

思路2：（如果是二叉搜索树）

既然是搜索树，它中序遍历就是有序的。
遍历有序数组的元素出现频率，从头遍历，那么一定是相邻两个元素作比较，然后就把出现频率最高的元素输出就可以了。
但是，这是在树上进行操作，具有一定难度。
弄一个指针指向前一个节点，这样每次cur（当前节点）才能和pre（前一个节点）作比较。
而且初始化的时候pre = NULL，这样当pre为NULL时候，我们就知道这是比较的第一个元素。

如果频率count 等于 maxCount（最大频率），当然要把这个元素加入到结果集中。
同时，如果频率count 大于 maxCount的时候，不仅要更新maxCount，而且要清空结果集（以下代码为result数组），因为结果集之前的元素都失效了。

class Solution {
    ArrayList<Integer> resList = new ArrayList<>();
    private int maxCount = 0;
    private int count = 0;
    TreeNode pre = null;

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

    public void traversal(TreeNode root){
        if(root == null)  return ;
        traversal(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;
        traversal(root.right);
    }
}

700.二叉搜索树中的搜索

题目链接：https://leetcode.cn/problems/search-in-a-binary-search-tree/

思路：

二叉搜索树是一个有序树：
若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
它的左、右子树也分别为二叉搜索树。
这就决定了，二叉搜索树，递归遍历和迭代遍历和普通二叉树都不一样。

如果root为空，或者找到这个数值了，就返回root结点。
因为二叉搜索树的结点是有序的，所以可以有方向的去搜索。
如果root.val > val，就搜索左子树，反之搜索右子树，最后如果都没有搜索到，就返回null。

class Solution {
    public TreeNode searchBST(TreeNode root, int val) {
        // 二叉搜索树：左子树的所有结点的值都小于根节点，右子树的所有结点的值都大于根节点
        if(root == null || root.val == val)
            return root;
        if(root.val > val)
            return searchBST(root.left,val);
        if(root.val < val)
            return searchBST(root.right,val);
        return null;
    }
}

98.验证二叉搜索树

题目链接：https://leetcode.cn/problems/validate-binary-search-tree/

思路：

根据二叉搜索树的特性，我们可以得知，在中序遍历下，输出的二叉搜索树的结点数值是有序序列。
有了这个特性，验证二叉搜索树，就相当于变成了判断一个序列是不是递增的了。
可以递归中序遍历将二叉搜索树转变成一个数组，然后只要比较一下，这个数组是否是有序的，注意二叉搜索树中不能有重复元素。但是，可以不引入数组，在递归遍历的过程中直接判断是否有序。
同时要注意：不能单纯的比较左节点小于中间节点，右节点大于中间节点就完事了。
我们要比较的是左子树所有节点小于中间节点，右子树所有节点大于中间节点。

class Solution {
    private long prev = Long.MIN_VALUE;
    public boolean isValidBST(TreeNode root) {
        // 陷阱：不能单纯的比较左节点小于中间节点，右节点大于中间节点就完事了
        // 要比较的是 （左子树）所有节点小于中间节点，（右子树）所有节点大于中间节点
        // 通过中序遍历，左中右，可以直观的看到是否单挑递增 -> 验证是否是一个二叉搜索树
        if(root == null)
            return true;
        // 左中右
        boolean left = isValidBST(root.left);
        if(root.val <= prev)  return false;
        prev = root.val;
        boolean right = isValidBST(root.right);
        return left & right;
    }
}