力扣 501. 二叉搜索树中的众数

题目来源：https://leetcode.cn/problems/find-mode-in-binary-search-tree/description/

 

C++题解1：使用中序遍历将二叉搜索树有小到大放进数组中，在寻找最大数组。

class Solution {
public:
    void traversal(TreeNode* node, vector& nums) {
        if(!node) return;
        traversal(node->left, nums);
        nums.push_back(node->val);
        traversal(node->right, nums);
        return;
    }
    vector findMode(TreeNode* root) {
        vector res, nums;
        if(!root) return res;
        traversal(root, nums);
        int len = nums.size();
        int tim = 1, maxtim = 0;
        for(int i = 1; i < len; i++) {
            if(nums[i] == nums[i-1]) {
                tim++;
            } 
            else {
                if(tim > maxtim) {
                    maxtim = tim;
                    res.clear();
                    res.push_back(nums[i-1]);
                }
                else if(tim == maxtim) res.push_back(nums[i-1]);
                tim = 1;
            }
        }
        if(tim > maxtim) {
            maxtim = tim;
            res.clear();
            res.push_back(nums[len-1]);
        }
        else if(tim == maxtim) res.push_back(nums[len-1]);

        return res;
    }
};

以下题解来自代码随想录

C++题解2：在递归过程中寻找众数，用pre表示上一个节点，第一个pre用NULL标注。

class Solution {
private:
    int maxCount = 0; // 最大频率
    int count = 0; // 统计频率
    TreeNode* pre = NULL;
    vector result;
    void searchBST(TreeNode* cur) {
        if (cur == NULL) return ;

        searchBST(cur->left);       // 左
                                    // 中
        if (pre == NULL) { // 第一个节点
            count = 1;
        } else if (pre->val == cur->val) { // 与前一个节点数值相同
            count++;
        } else { // 与前一个节点数值不同
            count = 1;
        }
        pre = cur; // 更新上一个节点

        if (count == maxCount) { // 如果和最大值相同，放进result中
            result.push_back(cur->val);
        }

        if (count > maxCount) { // 如果计数大于最大值频率
            maxCount = count;   // 更新最大频率
            result.clear();     // 很关键的一步，不要忘记清空result，之前result里的元素都失效了
            result.push_back(cur->val);
        }

        searchBST(cur->right);      // 右
        return ;
    }

public:
    vector findMode(TreeNode* root) {
        count = 0;
        maxCount = 0;
        TreeNode* pre = NULL; // 记录前一个节点
        result.clear();

        searchBST(root);
        return result;
    }
};

C++题解3：迭代法

class Solution {
public:
    vector findMode(TreeNode* root) {
        stack st;
        TreeNode* cur = root;
        TreeNode* pre = NULL;
        int maxCount = 0; // 最大频率
        int count = 0; // 统计频率
        vector result;
        while (cur != NULL || !st.empty()) {
            if (cur != NULL) { // 指针来访问节点，访问到最底层
                st.push(cur); // 将访问的节点放进栈
                cur = cur->left;                // 左
            } else {
                cur = st.top();
                st.pop();                       // 中
                if (pre == NULL) { // 第一个节点
                    count = 1;
                } else if (pre->val == cur->val) { // 与前一个节点数值相同
                    count++;
                } else { // 与前一个节点数值不同
                    count = 1;
                }
                if (count == maxCount) { // 如果和最大值相同，放进result中
                    result.push_back(cur->val);
                }

                if (count > maxCount) { // 如果计数大于最大值频率
                    maxCount = count;   // 更新最大频率
                    result.clear();     // 很关键的一步，不要忘记清空result，之前result里的元素都失效了
                    result.push_back(cur->val);
                }
                pre = cur;
                cur = cur->right;               // 右
            }
        }
        return result;
    }
};

C++题解4：普通二叉树解法，用vector存放map才可以进行排序，但仍需重新定义sort函数中的cmp函数。

class Solution {
private:

void searchBST(TreeNode* cur, unordered_map& map) { // 前序遍历
    if (cur == NULL) return ;
    map[cur->val]++; // 统计元素频率
    searchBST(cur->left, map);
    searchBST(cur->right, map);
    return ;
}
bool static cmp (const pair& a, const pair& b) {
    return a.second > b.second;
}
public:
    vector findMode(TreeNode* root) {
        unordered_map map; // key:元素，value:出现频率
        vector result;
        if (root == NULL) return result;
        searchBST(root, map);
        vector> vec(map.begin(), map.end());
        sort(vec.begin(), vec.end(), cmp); // 给频率排个序
        result.push_back(vec[0].first);
        for (int i = 1; i < vec.size(); i++) {
            // 取最高的放到result数组中
            if (vec[i].second == vec[0].second) result.push_back(vec[i].first);
            else break;
        }
        return result;
    }
};

这简单题真的简单吗？