leetcode347 前K个高频元素

暴力的做法，先遍历一遍数组，然后把出现的数字与对应的出现次数放置在一个map中，而map自己无法根据value来排序，所以将map中的数据放置进一个vector中进行排序，撰写了一个函数用于排序的判定，最后输出前K个元素即可。贴代码

typedef pair<int,int> PAIR;
bool cmp_val(const PAIR &left,const PAIR &right)
{
    return left.second > right.second;
}
class Solution {
public:
    vector<int> topKFrequent(vector<int>& nums, int k) 
    {
        map<int,int> res_temp;
        vector<int> res;
        for(auto temp:nums)
        {
            if(!res_temp.count(temp))
            {
                res_temp.insert(pair<int,int>(temp,1));
            }            
            else
            {
                (res_temp.find(temp)->second)++;
            }
        }
        vector<PAIR> vec(res_temp.begin(),res_temp.end());
        sort(vec.begin(),vec.end(),cmp_val);
        vector<PAIR>::iterator it_temp = vec.begin();
        for(int i = 0 ; i < k ; i++)
        {
            res.push_back(it_temp->first);
            it_temp++;
        }
        return res;
    }
};

接触到了一种新的数据结构，堆，本质上是二叉树，其特殊性质是父节点一定小于或者大于其两个子节点，分别为小顶堆与大顶堆。可以在C++中通过priority_queue这一数据结构实现。还是先通过map实现遍历，然后建立一个K大小的小顶堆，如果堆的元素个数小于 k，就可以直接插入堆中。如果堆的元素个数等于 kk，则检查堆顶与当前出现次数的大小。如果堆顶更大，说明至少有 kk 个数字的出现次数比当前值大，故舍弃当前值；否则，就弹出堆顶，并将当前值插入堆中。最后输出堆中所有元素的first值，贴代码。

class Solution {
public:
    static bool cmp(pair<int, int>& m, pair<int, int>& n) {
        return m.second > n.second;
    }
    vector<int> topKFrequent(vector<int>& nums, int k) 
    {
        map<int,int> res_temp;
        vector<int> res;
        for(auto temp:nums)
        {
            if(!res_temp.count(temp))
            {
                res_temp.insert(pair<int,int>(temp,1));
            }            
            else
            {
                (res_temp.find(temp)->second)++;
            }
        }
        priority_queue<pair<int, int>, vector<pair<int, int>>, decltype(&cmp)> q(cmp);
        for(auto& [num,count] : res_temp)
        {
            if(q.size() == k)
            {
                if(q.top().second<count)
                {
                    q.pop();
                    q.emplace(num,count);
                }
            }
            else
            {
                q.emplace(num,count);
            }
        }
        while(!q.empty())
        {
            res.push_back(q.top().first);
            q.pop();
        }
        return res;
    }
};

还有一种方法，利用了快速排序的方法，快速排序的原理就是随机选定一个界限值，将大于该值的放在该值的左或者右，从而进行递归，而该例中不需要完成所有的排序，只需要得出k个最大的即可。如第一次排序出n个较大值，若n比k大，则继续进行排序，选择出k个最大的，若n比k小，先将n个值存储，然后在剩余值中选取k-n个较大值，同样能够完成，贴代码。

class Solution {
public:
    void quicksort(vector<pair<int,int>>& v,int start,int end, vector<int>& ret,int k)
    {
        int picked = rand()%(end - start +1)  + start;
        swap(v[start],v[picked]);
        int pivot = v[start].second;
        int index = start;
        for(int i = start+1 ; i <= end ; i++)
        {
            if(v[i].second>=pivot)          //将比pivot大的都放在index的左边
            {
                swap(v[index+1],v[i]);
                index++;
            }
        }
        swap(v[start],v[index]);
        if(k<=index-start)
        {
            quicksort(v,start,index-1,ret,k);
        }
        else
        {
            for(int i = start ; i <= index ; i++)
            {
                ret.push_back(v[i].first);
            }
            if(k>index-start+1)
            {
                quicksort(v,index+1,end,ret,k-(index-start+1));
            }
        }
    }
    vector<int> topKFrequent(vector<int>& nums, int k) 
    {
        map<int,int> res_temp;
        vector<int> res;
        for(auto temp:nums)
        {
            if(!res_temp.count(temp))
            {
                res_temp.insert(pair<int,int>(temp,1));
            }            
            else
            {
                (res_temp.find(temp)->second)++;
            }
        }
        vector<pair<int,int>> values;
        for(auto &temp:res_temp)
        {
            values.push_back(temp);
        }
        quicksort(values,0,values.size()-1,res,k);
        return res;
    }
};

 另一种快速排序的写法，本质上还是类似的。

class Solution {
public:
    vector<int> topKFrequent(vector<int>& nums, int k) 
    {
        map<int,int> countMap;
        for(auto temp:nums)
        {
            if(!countMap.count(temp))
            {
                countMap.insert(pair<int,int>(temp,1));
            }            
            else
            {
                (countMap.find(temp)->second)++;
            }
        }
        vector<pair<int,int>> countVec;
        for(auto &temp:countMap)
        countVec.push_back(temp);
        vector<int> resVec;
        quicksort(countVec,0,countVec.size()-1,k,resVec);
        return resVec;
    }
    void quicksort(vector<pair<int,int>>& countVec,int start,int end,int k,vector<int>& resVec)
    {
        int picked = rand()%(end - start +1)  + start;
        swap(countVec[start],countVec[picked]);
        int pivot = countVec[start].second;
        int index = start;
        for(int i = start+1 ; i <= end ; i++)
        {
            if(countVec[i].second>pivot)
            {
                swap(countVec[index+1],countVec[i]);
                index++;
            }            
        }
        swap(countVec[start],countVec[index]);
        if(index+1>k)
        quicksort(countVec,start,index-1,k,resVec);
        else if(index+1 == k)
        {
            for(int i = 0 ; i <= index ; i++)
            resVec.push_back(countVec[i].first);
        }
        else
        quicksort(countVec,index+1,end,k,resVec);
    }
};