0
点赞
收藏
分享

微信扫一扫

LeetCode501. 二叉搜索树中的众数(day0017_1)

给你一个含重复值的二叉搜索树(BST)的根节点 root ,找出并返回 BST 中的所有 众数(即,出现频率最高的元素)。

如果树中有不止一个众数,可以按 任意顺序 返回。

假定 BST 满足如下定义:

  • 结点左子树中所含节点的值 小于等于 当前节点的值

  • 结点右子树中所含节点的值 大于等于 当前节点的值

  • 左子树和右子树都是二叉搜索树

示例 1:

 输入:root = [1,null,2,2]
 输出:[2]

示例 2:

 输入:root = [0]
 输出:[0]

提示:

  • 树中节点的数目在范围 [1, 104] 内

  • -105 <= Node.val <= 105

递归法(定义数组):

/**
 * 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 {
private:
    vector<int>result;//最大频率元素
    vector<int>vec;//存放二叉搜索树所有元素
    int count;//统计频率
    int maxCount;//最大频率
    void searchBST(TreeNode* cur){
        if(cur==NULL)return;
        searchBST(cur->left);//左
        vec.push_back(cur->val);//中
        searchBST(cur->right);//右
        return;
    }
public:
    vector<int> findMode(TreeNode* root) {
        result.clear();
        vec.clear();
        count=1;//一定初始为1,因为i从1开始
        maxCount=1;//为了不忽略i=0
        searchBST(root);
        result.push_back(vec[0]);//把i=0的元素放入
        //遍历数组
        for(int i=1;i<vec.size();i++){
            //与前一个节点数值相同
            if(vec[i]==vec[i-1]){
                count++;     
            }else{
                //与前一个节点数值不相同
                count=1;
            }
            //如果和最大值相同,则将其放入result
            if(count==maxCount)result.push_back(vec[i]);
            if(count>maxCount){//如果计数大于最大频率
                maxCount=count;//更新最大频率
                result.clear();//清除result
                result.push_back(vec[i-1]);//把高频元素放入
            }
        }
        return result;
    }
};

递归法(简洁版):

/**
 * 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 {
private:
    TreeNode* pre;//记录前一个节点
    int count;//计算元素出现频率
    int maxCount;//记录频率最高元素
    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(maxCount==count){//如果和最大值相同,则将其放入result中
            result.push_back(cur->val);
        }
        if(maxCount<count){//如果计算值大于最大频率
            result.clear();//最关键的一步,清空result,之前的最高频率都失效了
            maxCount=count;//更新最大值
            result.push_back(cur->val);
        }
        searchBST(cur->right);//右
        return ; 
    }
public:
    vector<int> findMode(TreeNode* root) {
        count=0;
        maxCount=0;
        pre=NULL;
        result.clear();
        searchBST(root);
        return result;
    }
};

迭代法:

/**
 * 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> findMode(TreeNode* root) {
        TreeNode* pre=NULL;
        TreeNode* cur=root;
        int count=0;
        int maxCount=0;
        stack<TreeNode*> st;
        vector<int> 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(maxCount==count){//如果和最大值相同,放入result中
                    result.push_back(cur->val);
                }
                if(maxCount<count){//如果计数大于最大频率
                    maxCount=count;//最大频率更新
                    result.clear();//清空result
                    result.push_back(cur->val);//将高频元素放入
                }
                pre=cur;//前一个节点
                cur=cur->right;//右
            }
        }
        return result;
    }
};
举报

相关推荐

0 条评论