TopK、最小堆、随机排序、快排问题

盗用下别人的标题，把我的顶上去，别人说的虽然有道理，但是缺乏实践。决定自己写个例子，实测结果如下：

总数1万个取最大100，快排略快，最小堆偶尔快。

总数10万个取最大100，最小堆略快，快排偶尔快。

总数100万个取最大100，最小堆完胜，快排没戏，而且最小堆大概快了2倍。

总数1000万个取最大100，最小堆完虐，快排没戏，而且最小堆快了大概2倍。

N个随机数取最大的K个和第K个其实是一个问题，区别在于K的位置。
当K很小，N很大时，用小顶堆。当K接近N的一半时，用快排。

结论：最小堆比快排优秀。

原因：

1.速度确实快。

2.最小堆不需要打乱原数据顺序，而快排会打乱。（并不是快的原因，而是最小堆的优点）

3.如果内存有限，无法加载所有数据，则最小堆快。

4.快排需要把所有数加到缓存里，而数据太大，查询过程中导致高速缓存置换，反而更慢了

#include <vector>
#include <iostream>
#include <time.h>
#include <random>
using namespace std;

//改良版部分区域快排
int Partition(vector<int>& arr, int low, int high)
{
    int pivokey = arr[low];//因为arr已经是随机数了，不需要再有分区算法，反而会慢
    while (low < high)
    {
        while (low < high && arr[high] <= pivokey) --high;
        arr[low] = arr[high];
        while (low < high && arr[low] >= pivokey) ++low;
        arr[high] = arr[low];
    }
    arr[low] = pivokey;
    return low;
}
int TopK_Qsort(vector<int>& arr, int start, int end, int k)
{
    int index = 0;
    if (start < end)
    {
        index = Partition(arr, start, end);
        if (index < k)//还要从index的右边找k-index个数
        {
            index = TopK_Qsort(arr, index + 1, end, k);
        }
        else if (index > k)//k个数都在Index的左边
        {
            index = TopK_Qsort(arr, start, index - 1, k);
        }
    }
    return index;
}

//小顶堆化
void HeapAdjust(vector<int>& nums, int pos)
{
    for (int i = 2 * pos + 1; i < nums.size(); i = 2 * i + 1)
    {
        if (i<nums.size() - 1 && nums[i]>nums[i + 1])
            i++;
        if (nums[i] >= nums[pos])
            break;
        swap(nums[i], nums[pos]);
        pos = i;
    }
}
void TopK_Heap(vector<int>& arr, int k)
{
    if (arr.size() <= k)
        return;
    vector<int> box;
    box.resize(k);
    for (int i = 0; i < k; i++)
        box[i] = arr[i];
    for (int i = box.size() / 2; i >= 0; i--)
        HeapAdjust(box, i);
    for (int i = k; i < arr.size(); i++)
    {
        if (arr[i] > box[0])
        {
            box[0] = arr[i];
            HeapAdjust(box, 0);
        }
    }
}

int main()
{
    int nCounterA = 0;    //代表小顶堆胜出次数
    int nCounterB = 0;    //代表快排胜出次数
    int nCounterC = 0;    //平手
    for (int t = 750; t<= 770;++t)//t是随机种子，保证每次待排序列表里是新的随机数
    {
        default_random_engine e;
        e.seed(t);                

        int nTotal = 10000;            //总共有多少个数
        int nTopK = 100;                //前TOPK个数
        //-------------------填充随机数-----------------------
        vector<int> vecQsortResource;
        vecQsortResource.reserve(nTotal);
        vector<int> vecHeapResource;
        vecHeapResource.reserve(nTotal);
        for (int i = nTotal; i > 0; i--)
        {
            vecQsortResource.push_back(e() % nTotal);
        }
        vecHeapResource = vecQsortResource;

        //-------------------两种算法开始计算-----------------------
        clock_t start, finish;
        start = clock();
        TopK_Heap(vecHeapResource, nTopK);
        finish = clock();
        double nRes1 = (double)(finish - start);
        //cout << "
小顶堆的运行时间为" << nRes1 / CLOCKS_PER_SEC << "秒！" << endl;

        start = clock();
        TopK_Qsort(vecQsortResource, 0, nTotal - 1, nTopK - 1);
        finish = clock();
        double nRes2 = (double)(finish - start);
        //cout << "
快排的运行时间为" << nRes2 / CLOCKS_PER_SEC << "秒！" << endl;

        if (nRes1 < nRes2)
        {
            nCounterA++;
        }
        else if (nRes1 > nRes2)
        {
            nCounterB++;
        }
        else
        {
            nCounterC++;
        }
    }

    cout << nCounterA << endl;    //代表小顶堆胜出次数
    cout << nCounterB << endl;    //代表快排胜出次数
    cout << nCounterC << endl;    //平手
    return 0;
}