C++复习之路：算法与数据结构相关 2：top(k)问题，k个最值，k个出现频率最高的元素

一般是求k个最大值、最小值的情况类似。

解法有很多：

1：直接全部排序（当数据量比较大的时候，最傻最耗费资源）

 

2.利用快排的思想：

 

先进行一趟快排，假设标记位置的下标为index，那么当index==k时index左边的为前k个数，只需对这k个数排序即可；

如果index>K,那么第k个大小的值在index的左边，算法对index左边再次快排；

如果index<K,那么第k个大小的值在index的右边，算法对index左边再次快排；

直到index==k找到第k个大小的值，然后对其左边排序。

虽然有所优化，但是还是很耗费资源。

 

3.利用堆排序，这个算是比较优化的方法，时间复杂度也比较小O（nlogn） （这部分的代码待补充，先挖个坑）

这是一种局部淘汰法。先读取前K个数，建立一个最小堆。然后将剩余的所有数字依次与最小堆的堆顶进行比较，如果小于或等于堆顶数据，则继续比较下一个；否则，删除堆顶元素，并将新数据插入堆中，重新调整最小堆。当遍历完全部数据后，最小堆中的数据即为最大的K个数。 

 

4.分治法：如果数据量很大，可以考虑分成n份，先找出每份中前k个最值，再把N*k个数据放入内存，如果N*k还是很大就继续把n*k分为m份，找出每份中前k个最值，再把m*k个数据放入内存，以此类推，直到能放入内存，再使用上面的方法。

拓展：字符串数组中出现次数最多的前k个，如果次数相同则按字典序对数进行排序：

方法一：使用map记录出现次数，转换为vector方便排序，时间复杂度为O（nlogn）

 //题解：用map
    vector<string> topKFrequent(vector<string>& words, int k) {
        if(words.empty()||k<=0)//数组为空或者k输入错误
         return {};
          map<string,int> s;
          for(const string word:words)
          {
              s[word]++;//string相当于key，int作为value
          }
          vector<pair<string,int>>result(s.begin(),s.end()); //借助vector排序
            vector<string>re; //借助vector排序
          sort(result.begin(),result.end(),
            [](const pair<string,int>&a,const pair<string,int>&b)
            {
                if(a.second==b.second)//次数相等则字典排序（string本身就已经重载了<,>，==号）
                return a.first<b.first;
                else return a.second>b.second;
            }); //这里的lambda表达式相当于一个小函数
         
        //将vector的前k个元素添加到result中
        for(const auto& r:result)
        {
            if(k--==0)break;
            re.push_back(r.first);
        }
        return re;
    }

方法二：使用map记录出现次数，使用堆排序（即优先队列）时间复杂度为O（nlogK），空间：O(n)

但是方法2由于使用的是最小堆（优先队列priority_queue）记录前k个最大，所以记录结果其实是前k个最大从小到大的结果，最后还需要加上一步O（k）的反转数组，但是总的时间复杂度还是比方法1小的。

  static bool cmp(pair<string, int>& m, pair<string, int>& n) {
       if(m.second==n.second) return m.first<n.first;
        return m.second > n.second;
    }



    //题解：用map代替前缀树
    vector<string> topKFrequent(vector<string>& words, int k) {
        if(k<=0||words.size()==0) return {};
         unordered_map<string, int> occurrences;
        for (auto& v :  words) {
            occurrences[v]++;
        }
       
        // pair 的第一个元素代表数组的值，第二个元素代表了该值出现的次数
        priority_queue<pair<string, int>, vector<pair<string, int>>, decltype(&cmp)> q(cmp);
        for (auto& [num, count] : occurrences) {
            if (q.size() == k) {
                if (q.top().second < count) {
                    q.pop();
                    q.emplace(num, count);
                }
                else if (q.top().second == count&&q.top().first>num) {
                    q.pop();
                    q.emplace(num, count);
                }
            } else {
                q.emplace(num, count);
            }
        }
        vector<string> ret;
        while (!q.empty()) {
            ret.emplace_back(q.top().first);
            q.pop();
        }
       reverse(ret.begin(),ret.end());
        return ret;
    }