[Leetcode] 501. Find Mode in Binary Search Tree 解题报告

题目：

Given a binary search tree (BST) with duplicates, find all the mode(s) (the most frequently occurred element) in the given BST.

Assume a BST is defined as follows:

• The left subtree of a node contains only nodes with keys less than or equal to the node's key.
• The right subtree of a node contains only nodes with keys greater than or equal to the node's key.
• Both the left and right subtrees must also be binary search trees.

For example:
Given BST [1,null,2,2],

   1    \     2    /   2

return [2].

Note: If a tree has more than one mode, you can return them in any order.

Follow up: Could you do that without using any extra space? (Assume that the implicit stack space incurred due to recursion does not count).

思路：

这道题目相对比较容易上手，因为只要我们对Tree进行中序遍历，检查连续出现次数最大的数就可以了（可能有多个）。在这个过程中，我们可以不断更新截至当前的最大出现次数max_count，以及截至当前出现这么多次的数的集合。一旦当前数的出现次数大于max_count了，那么就清空之前记录的集合，并且将当前数加入集合中。这样虽然只需要一次中序遍历就可以得到结果，但是却需要额外的空间，尤其在某些特殊情况下，空间复杂度高达O(n)（例如对于1,2,3,...n-2, n-1, n, n）。

如果要按照Follow up的要求，不使用额外空间，那么我觉得可以中序遍历两次：第一次统计出最大出现次数，第二次根据最大出现次数，构建结果。下面的代码就是两边中序遍历。其时间复杂度是O(n)，空间复杂度严格为O(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:    vector<int> findMode(TreeNode* root) {        vector<int> ret;        curr_value = 0, curr_count = 0, max_count = 1;        inorder(root);          // step 1: get the maximal frequency        max_count = max(max_count, curr_count);        curr_value = 0, curr_count = 0;        inorder(root, ret);     // step 2: collect the values that has the maximal frequency        if (curr_count == max_count) {            ret.push_back(curr_value);        }        return ret;    }private:    void inorder(TreeNode* root) {        if (root == NULL) {            return;        }        inorder(root->left);        if (curr_count == 0) {      // the first node            max_count = 1;            curr_count = 1, curr_value = root->val;        }        else {            if (root->val == curr_value) {                ++curr_count;            }            else {                max_count = max(max_count, curr_count);                curr_count = 1, curr_value = root->val;            }        }        inorder(root->right);    }    void inorder(TreeNode* root, vector<int> &ret) {        if (root == NULL) {            return;        }        inorder(root->left, ret);        if (curr_count == 0) {      // the first node            curr_count = 1, curr_value = root->val;        }        else {            if (root->val == curr_value) {                ++curr_count;            }            else {                if (curr_count == max_count) {                    ret.push_back(curr_value);                }                curr_count = 1, curr_value = root->val;            }        }        inorder(root->right, ret);    }    int curr_value, curr_count, max_count;};