leetcode 508. Most Frequent Subtree Sum

最新推荐文章于 2024-02-16 08:01:30 发布

原创最新推荐文章于 2024-02-16 08:01:30 发布 · 118 阅读

0 ·

CC 4.0 BY-SA版权

Leetcode练习专栏收录该内容

294 篇文章

订阅专栏

本文介绍了一种算法，用于找到给定树中出现频率最高的子树和，并提供了两种实现方法：一种使用列表进行排序和计数，另一种利用哈希映射记录每个子树和的出现次数。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Given the root of a tree, you are asked to find the most frequent subtree sum. The subtree sum of a node is defined as the sum of all the node values formed by the subtree rooted at that node (including the node itself). So what is the most frequent subtree sum value? If there is a tie, return all the values with the highest frequency in any order.

Examples 1
Input:

  5
 /  \
2   -3

return [2, -3, 4], since all the values happen only once, return all of them in any order.

Examples 2
Input:

  5
 /  \
2   -5

return [2], since 2 happens twice, however -5 only occur once.

Note: You may assume the sum of values in any subtree is in the range of 32-bit signed integer.

先求出所有节点的和的值，然后排序后找出频数最大的数

public class Solution {
    List<Integer> sum = new ArrayList<>();
    public int[] findFrequentTreeSum(TreeNode root) {
        helper(root);
        Collections.sort(sum);
        List<Integer> l = new ArrayList<>();
        int most=0, cnt=0, pre=Integer.MAX_VALUE;
        for(int i : sum){
            if(i==pre){
                cnt++;
            }else{
                cnt = 1;
                pre = i;
            }
            if(cnt==most){
                l.add(pre);
            }else if(cnt>most){
                l.clear();
                l.add(pre);
                most = cnt;
            }
        }
        int[] ans = new int[l.size()];
        int index=0;
        for(int i : l){
            ans[index++] = i;
        }
        return ans;
    }
    
    private int helper(TreeNode root){
        if(root==null) return 0;
        int left = helper(root.left);
        int right = helper(root.right);
        int temp = left + right + root.val;
        sum.add(temp);
        return temp;
    }
}

也可以用map来保存频数信息，同时保存最大频数，之后遍历相等则输出

public class Solution {
    int max = 0;
    public int[] findFrequentTreeSum(TreeNode root) {
        if(root==null) return new int[0];
        Map<Integer, Integer> map = new HashMap<>();
        helper(root, map);
        List<Integer> res = new LinkedList<>();
        for(Map.Entry<Integer, Integer> me: map.entrySet()){
            if(me.getValue()==max) res.add(me.getKey());
        }
        return res.stream().mapToInt(i->i).toArray();
    }
    
    private int helper(TreeNode n, Map<Integer, Integer> map){
        int left = (n.left==null) ? 0 : helper(n.left, map);
        int right = (n.right==null) ? 0 : helper(n.right, map);
        int sum = left + right + n.val;
        map.put(sum, map.getOrDefault(sum,0)+1);
        max = Math.max(max, map.get(sum));
        return sum;
    }
}