力扣算法篇：二叉搜索树中的众数

题解：

递归 转为有序数组

依然利用二叉搜索树中序遍历有序的性质，递归中序遍历转为有序数组

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> result;
    void traversal(TreeNode* node){
        if(node == NULL){
            return;
        }
        //左
        traversal(node->left);
        //中
        result.push_back(node->val);
        //右
        traversal(node->right);
        return;
    }
    vector<int> findMode(TreeNode* root) {
        //转为有序数组
        traversal(root);
        //寻找有序数组中的众数
        int maxcount = 1;
        vector<int> res;
        int countemp = 1;
        for(int i = 0;i<result.size()-1;i++){
            if(result[i] == result[i+1]){
                countemp++;
            }else{
                //不等
                countemp = 1;
            }
            if(countemp>maxcount){
                maxcount = countemp;
                //清空res
                res.clear();
                //加入结果
                res.push_back(result[i]);
            }else if(countemp == maxcount){
                res.push_back(result[i]);
            }
        }
        //如果都不同 
        if(maxcount == 1){
            res.push_back(result[result.size()-1]);
        }
        return res;
    }
};

递归 中序遍历一次得到众数集

class Solution {
public:
    //结果集
    vector<int> result;
    //最大频率
    int maxcount;
    //统计频率
    int countemp;
    //指向前一个结点
    TreeNode* pre;
    void traversal(TreeNode* cur){
        //如果当前结点为空 返回
        if(cur == NULL){
            return;
        }
        //左
        traversal(cur->left);
        //中 处理结点
        if(pre!=NULL){
            if(pre->val == cur->val){
                //当前结点与前一个结点数值相同 
                countemp++;
            }else{
                //不同
                countemp=1;
            }
        }
        //更新maxcount
        if(countemp>maxcount){
            maxcount = countemp;
            //清空结果集
            result.clear();
            //加入
            result.push_back(cur->val);
        }else if(countemp == maxcount){
            result.push_back(cur->val);
        }
        //更新前结点
        pre = cur;
        //右
        traversal(cur->right);
        return;
    }
    vector<int> findMode(TreeNode* root) {
        //初始化变量
        maxcount = 1;
        countemp = 1;
        pre = NULL;
        //遍历
        traversal(root);
        return result;
    }
};

可以看到中间结点的处理逻辑与遍历有序数组得到众数处理逻辑一致，只是从遍历有序数组到中序遍历二叉搜索树，本质一样

迭代

用栈模拟中序遍历 中间结点的处理逻辑同上

class Solution {
public:
    vector<int> findMode(TreeNode* root) {
        stack<TreeNode*> st;
        //结果集
        vector<int> result;
        //最大频率
        int maxcount = 1;
        //统计频率
        int countemp = 1;
        //指向前一个结点
        TreeNode* pre = NULL;
        TreeNode* cur = root;
        while(cur!=NULL || !st.empty()){
            if(cur != NULL){
                // 指针来访问节点，访问到最底层
                //将要访问的结点加入栈
                st.push(cur);
                cur = cur->left;
            }else{
                //处理结点
                cur = st.top();
                st.pop();
                if(pre!=NULL){
                    if(pre->val == cur->val){
                        //当前结点与前一个结点数值相同 
                        countemp++;
                    }else{
                        //不同
                        countemp=1;
                    }
                }
                //更新maxcount
                if(countemp>maxcount){
                    maxcount = countemp;
                    //清空结果集
                    result.clear();
                    //加入
                    result.push_back(cur->val);
                }else if(countemp == maxcount){
                    result.push_back(cur->val);
                }
                //更新前结点
                pre = cur;
                //右
                cur = cur->right;
            }
        }
        return result;
    }
};