leetcode 508. Most Frequent Subtree Sum

最新推荐文章于 2025-10-20 18:54:16 发布

原创最新推荐文章于 2025-10-20 18:54:16 发布 · 345 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #Subtree

leetcode 专栏收录该内容

57 篇文章

订阅专栏

本文介绍了一种算法，用于找到二叉树中最频繁出现的子树和，并提供了两种实现方式。通过递归地计算每个节点的子树和，并使用HashMap来跟踪每个和的频率，最终返回最高频率的子树和值。

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.

直观想法，递归求子树的和，然后用HashMap存放键值对，存放过程中，记录最大出现次数，然后遍历map。没想到提交有89%，有一个top answer也是这样！真粗暴！

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
import java.util.Map.Entry; 

public class Solution {
    int maxF = 1;
    public int[] findFrequentTreeSum(TreeNode root) {
        HashMap<Integer, Integer> map = new HashMap<>();
        int tp = subTreeSum(root, map);
        ArrayList<Integer> res = new ArrayList<>();
        for(Entry<Integer, Integer> entry: map.entrySet()){
            int key = entry.getKey();
            int val = entry.getValue();
            if(val==maxF){
                res.add(key);
            }
        }
        int[] resA = new int[res.size()];
        for(int i = 0; i< res.size(); i++){
            resA[i] = res.get(i);
        }
        return resA;
    }

    public int subTreeSum(TreeNode root, HashMap<Integer, Integer> map){
        if(root==null) return 0;
        int left = subTreeSum(root.left, map);
        int right = subTreeSum(root.right, map);

        int sum = root.val + left + right;
        if(map.containsKey(sum)) {
            int val = map.get(sum);
            val ++;
            if(val > maxF) maxF = val;
            map.put(sum, val);
        }else{
            map.put(sum, 1);
        }
        return sum;
    }
}

附上别人的

Verbose Java solution, postOrder traverse, HashMap (18ms)
For sake of saving time during contest, can't write so concise solution :)
Idea is post-order traverse the tree and get sum of every sub-tree, put sum to count mapping to a HashMap. Then generate result based on the HashMap.

public class Solution {
    Map<Integer, Integer> sumToCount;
    int maxCount;

    public int[] findFrequentTreeSum(TreeNode root) {
        maxCount = 0;
        sumToCount = new HashMap<Integer, Integer>();

        postOrder(root);

        List<Integer> res = new ArrayList<>();
        for (int key : sumToCount.keySet()) {
            if (sumToCount.get(key) == maxCount) {
                res.add(key);
            }
        }

        int[] result = new int[res.size()];
        for (int i = 0; i < res.size(); i++) {
            result[i] = res.get(i);
        }
        return result;
    }

    private int postOrder(TreeNode root) {
        if (root == null) return 0;

        int left = postOrder(root.left);
        int right = postOrder(root.right);

        int sum = left + right + root.val;
        int count = sumToCount.getOrDefault(sum, 0) + 1;
        sumToCount.put(sum, count);

        maxCount = Math.max(maxCount, count);

        return sum;
    }
}

这里有个写法可以简化我的[哭]

int count = sumToCount.getOrDefault(sum, 0) + 1;