[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;
};