思路大概是将数组中所有元素的频率记下来，然后统一使用最小堆来管理，将根节点与下一个元素比较，将频率更的高元素插入最小堆，同时进行堆排序操作，以此进行管理

在这里发现原来c++有优先队列priority_queue可以达到相同的效果，优先队列将权值最大的放在队列的出口处，这样就完成了类似的效果

原算法：

class Solution {

public:

    int sift_down(vector<pair<int,int>> &v,int k){

        int father=0;

        int child=2*father+1;

        pair<int,int> temp=v[0];

        while(child<k){

            if((child+1<k)&&(v[child].first>v[child+1].first))

                child++;

            if(temp.first>v[child].first){

                v[father]=v[child];

                father=child;

                child=father*2+1;

            }

            else

                break;

        }

        v[father]=temp;

        return 0;

    }

    vector<int> topKFrequent(vector<int>& nums, int k) {

        vector<pair<int,int>> v;

        for(int i=0;i<k;i++){

            v.push_back(make_pair(0,0));

        }

        map<int,int> m;

        for(vector<int>::iterator it=nums.begin();it!=nums.end();it++){

            if(m.find(*it)->second==0)

                m.insert(make_pair(*it,1));

            else

                m.find(*it)->second++;            

        }

        for(map<int,int>::iterator it=m.begin();it!=m.end();it++){

            if(it->second>v[0].first){

                v[0]=make_pair(it->second,it->first);

                sift_down(v,k);   

            }

        }

        vector<int> v1;

        for(vector<pair<int,int>>::iterator i=v.begin();i!=v.end();i++)

            v1.push_back(i->second);

        return v1;

    }

};

改进算法，写的很漂亮：

class Solution {
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {
         unordered_map<int,int> m;
        priority_queue<pair<int,int>> p;
        vector<int> res;
        for(int num:nums)
        {
            ++m[num];
        }
        for(auto a:m)
        {
            p.push({a.second,a.first});
        }
        for(int i=0;i<k;++i)
        {
            res.push_back(p.top().second);
            p.pop();
        }
        return res;
    }
};