508. Most Frequent Subtree Sum

最新推荐文章于 2025-07-29 14:24:32 发布

原创最新推荐文章于 2025-07-29 14:24:32 发布 · 127 阅读

0 ·

CC 4.0 BY-SA版权

二叉树专栏收录该内容

21 篇文章

订阅专栏

本文介绍了一种算法，用于找到二叉树中最频繁出现的子树和。通过深度优先搜索，利用映射记录每个子树和的出现次数，并返回出现频率最高的子树和值。若多个值具有相同最高频率，则一并返回。

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.

思路：深度优先，利用map记录每次子和出现的次数，最后遍历获得结果；

知识点：map的遍历使用指针；vector.clear( )

代码1：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    map<int,int> tongji;
    
    int cal(TreeNode* root){
        if(!root->left && !root->right){
            tongji[root->val]++;
            return root->val;
        }
        int leftsum=0,sum=0,rightsum=0;
        if(root->left){leftsum=cal(root->left);}
        if(root->right){rightsum=cal(root->right);}
        sum=leftsum+rightsum+root->val;
        tongji[sum]++;
        return sum;
    }
    
    vector<int> findFrequentTreeSum(TreeNode* root) {
        vector<int> result;
        if(!root){return result;}
        int temp=cal(root);
        int max = tongji.begin()->second;
        for(map<int,int>::iterator it = tongji.begin();it != tongji.end();it++){
            if(it->second > max){
                max = it->second;
                result.clear();
                result.push_back(it->first);
            }
            else if(it->second == max){result.push_back(it->first);}
        }
        return result;
    }
};

代码2：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    map<int,int> m;
    int helper(TreeNode* root){
        if(root->left==NULL && root->right==NULL){
            m[root->val]++;
            return root->val;
        }
        int res= root->val;
        if(root->left!=NULL){
            res += helper(root->left);
        }
        if(root->right!=NULL){
            res += helper(root->right);
        }
        m[res]++;
        return res;
    }
    
    vector<int> findFrequentTreeSum(TreeNode* root) {
        vector<int> res;
        if(root==NULL){return res;}
        int temp=helper(root);
        temp=0;
        map<int,int>::iterator mp=m.begin();
        while(mp!=m.end()){
            if(mp->second>temp){
                res.clear();
                res.push_back(mp->first);
                temp=mp->second;
            }
            else if(mp->second==temp){res.push_back(mp->first);}
            mp++;
        }
        return res;
    }
};

代码3：

class Solution {
public:
    vector<int> findFrequentTreeSum(TreeNode* root) {
        unordered_map<int,int> counts;
        int maxCount = 0;
        countSubtreeSums(root, counts, maxCount);
        
        
        vector<int> maxSums;
        for(const auto& x :  counts){
            if(x.second == maxCount) maxSums.push_back(x.first);
        }
        return maxSums;
    }
    
    int countSubtreeSums(TreeNode *r, unordered_map<int,int> &counts, int& maxCount){
        if(r == nullptr) return 0;
        
        int sum = r->val;
        sum += countSubtreeSums(r->left, counts, maxCount);
        sum += countSubtreeSums(r->right, counts, maxCount);
        ++counts[sum];
        maxCount = max(maxCount, counts[sum]);
        return sum;
    }
};