【陪伴式刷题】Day 19｜二叉树｜501.二叉搜索树中的众数(Find Mode in Binary Search Tree)

刷题顺序按照代码随想录建议

题目描述

英文版描述

Given the root of a binary search tree (BST) with duplicates, return all the mode(s) (i.e., the most frequently occurred element) in it.

If the tree has more than one mode, return them in any order.

Assume a BST is defined as follows:

The left subtree of a node contains only nodes with keys less than or equal to the node's key.
The right subtree of a node contains only nodes with keys greater than or equal to the node's key.
Both the left and right subtrees must also be binary search trees.

Example 1:

Input: root = [1,null,2,2] Output: [2]

Example 2:

Input: root = [0] Output: [0]

Constraints:

The number of nodes in the tree is in the range [1, 10^4].
-10^5 <= Node.val <= 10^5.

英文版地址

leetcode.com/problems/fi...

中文版描述

给你一个含重复值的二叉搜索树（BST）的根节点 root ，找出并返回 BST 中的所有众数（即，出现频率最高的元素）。

如果树中有不止一个众数，可以按 任意顺序 返回。

假定 BST 满足如下定义：

结点左子树中所含节点的值 小于等于 当前节点的值
结点右子树中所含节点的值 大于等于 当前节点的值
左子树和右子树都是二叉搜索树

示例 1：

输入： root = [1,null,2,2] 输出： [2]

示例 2：

输入： root = [0] 输出： [0]

提示：

树中节点的数目在范围 [1, 10(4)] 内
-10^5 <= Node.val <= 10^5

中文版地址

leetcode.cn/problems/fi...

解题方法

递归法

java 复制代码

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
 List<Integer> resultList = new ArrayList<>();

    public int[] findMode(TreeNode root) {
        recursion(root);
        List<Map.Entry<Integer, Integer>> collect = 
            map.entrySet().stream()
            .sorted((p2, p1) -> p1.getValue().compareTo(p2.getValue()))
            .collect(Collectors.toList());
        Integer last = collect.get(0).getValue();
        for (Map.Entry item : collect) {
            Integer value = (Integer) item.getValue();
            if (value.equals(last)) {
                resultList.add((Integer) item.getKey());
            }
        }
        return resultList.stream().mapToInt(Integer::intValue).toArray();
    }

    Map<Integer, Integer> map = new HashMap<>();

    private void recursion(TreeNode root) {
        if (root == null) {
            return;
        }
        recursion(root.left);
        int count = 1;
        if (map.containsKey(root.val)) {
            count = map.get(root.val) + 1;
        }
        map.put(root.val, count);
        recursion(root.right);
    }
}

复杂度分析

时间复杂度：O(n)，其中 n 是二叉树的节点数。每一个节点恰好被遍历一次
空间复杂度：O(n)，为递归过程中栈的开销，平均情况下为 O(log⁡n)，最坏情况下树呈现链状，为 O(n)

根据平衡二叉树的特性，可以对上面的暴力解法进行优化

递归法优化版（针对平衡二叉树）

java 复制代码

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
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;
        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);
    }
}

复杂度分析

时间复杂度：O(n)，其中 n 是二叉树的节点数，每一个节点恰好被遍历一次
空间复杂度：O(n)，为递归过程中栈的开销，平均情况下为 O(log⁡n)，最坏情况下树呈现链状，为 O(n)