题目地址

https://leetcode-cn.com/problems/find-mode-in-binary-search-tree/solution/

思路

暴力统计

这看到这道题目，最直观的方法一定是把这个树都遍历了，用map统计频率，用vector排个序，最后出去前面高频的元素。

其实这是可以的，也是有效的，面试中时间紧张，可能快速的把这个方法实现出来，后面在考虑满满优化。

至于用前中后序那种遍历也不重要，因为就是要全遍历一遍，怎么个遍历法都行，层序遍历都没毛病！

这种方法C++代码如下：

class Solution {
private:

void searchBST(TreeNode* cur, unordered_map<int, int>& map) { // 前序遍历
    if (cur == NULL) return ;
    map[cur->val]++; // 统计元素频率
    searchBST(cur->left, map);
    searchBST(cur->right, map);
    return ;
}
bool static cmp (const pair<int, int>& a, const pair<int, int>& b) {
    return a.second > b.second;
}
public:
    vector<int> findMode(TreeNode* root) {
        unordered_map<int, int> map;
        vector<int> result;
        if (root == NULL) return result;
        searchBST(root, map);
        vector<pair<int, int>> 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++) {
            if (vec[i].second == vec[0].second) result.push_back(vec[i].first);
            else break;
        }
        return result;
    }
};

这种方法的缺点是没有利用上二叉搜索树这一特性，如果用这种方法，这道题就可以是普通的二叉树就行了，反正都要全撸一遍统计频率。

中序遍历

既然是搜索树，它就是有序的，那么如何有序呢？

搜索树在中序遍历的过程中，就是有序序列，所以此时的问题相当于给出如果给出一个有序数组，求最大频率的元素集合。

所以我们要采用中序遍历！

如图：

中序遍历代码如下：

    void searchBST(TreeNode* cur) {
        if (cur == NULL) return ;
        searchBST(cur->left);       // 左
        （处理节点）                // 中
        searchBST(cur->right);      // 右
        return ;
    }

遍历有序数组的元素出现频率，从头遍历，那么一定是相邻两个元素作比较，要是数组的话，好搞，在树上怎么搞呢？

需要弄一个指针指向前一个节点，这样每次cur（当前节点）才能和pre（前一个节点）作比较。

而且初始化的时候pre = NULL，这样当pre为NULL时候，我们就知道这是比较的第一个元素，然后再给pre赋值即pre = cur;

代码如下：

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

此时又有问题了，因为要求最大频率的元素集合，直观想的想法是要先遍历一遍找出频率最大的次数maxCount，然后在重新遍历一遍再把出现频率为maxCount的元素放进集合。

那么如何只遍历一遍呢？

如果频率count 等于 maxCount，当然要把这个元素加入到结果集中（以下代码为result数组），代码如下：

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

当时感觉这里有问题，result怎么能轻易就把元素放进去了呢，万一，这个maxCount此时还不是真正最大值呢。

所以下面要做如下操作：

频率count 大于 maxCount的时候，不仅要更新maxCount，而且要清空结果集（以下代码为result数组），因为结果集之前的元素都失效了。

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

关键代码都讲完了，完整代码如下：

class Solution {
private:
    int count;
    int maxCount;
    TreeNode* pre;
    vector<int> 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<int> findMode(TreeNode* root) {
        int count = 0; // 记录元素出现次数
        int maxCount = 0;
        TreeNode* pre = NULL; // 记录前一个节点
        result.clear();

        searchBST(root);
        return result;
    }
};

此时的运行效率：

需要强调的是 leetcode上的耗时统计是非常不准确的，看个大概就行，一样的代码耗时可以差百分之50以上，所以leetcode的耗时统计别太当回事，知道理论上的效率优劣就行了。

5.8 KiB Raw Blame History Unescape Escape

题目地址

思路

暴力统计

中序遍历

5.8 KiB

Raw Blame History