關於Top K演算法和尋找第K個最小的數這種經典問題網上已經說的很詳細了，不過畢竟不是自己的，這裡自己總結一下，而且這兩個問題又稍稍有點區別。

1.Top K演算法：即尋找一列數中K個最小值或K個最大值，這裡僅以尋找K個最小值為例（演算法類似）。

（1）普通排序：最直觀的演算法就是給整列數排序，然後取前K個數。這裡主要對各種排序演算法的時間複雜度進行分析：

插入排序：由於巢狀迴圈的每一次迭代都花費N次迭代，因此插入排序的時間複雜度為O（N^2)。

快速排序：對於已經排序的數列採用快速排序時間複雜度為O（N^2)，採用隨機數或者三數中值法可以避免這種情況，平均時間複雜度T（N）=O(NlogN)

void Swap(int *a, int *b)
{
    int Tmp = *a;
    *a = *b;
    *b = Tmp;
}
void Qsort(int A[], int Left, int Right)
{
    int i, j, Pivot;
 
    if(Left < Right)
    {
	Pivot = A[Left];
	i = Left + 1;
	j = Right;

	while(1)
	{
	    while(A[i] < Pivot)
		i++;
	    while(A[j] > Pivot)
		j--;
	    if(i < j)
		Swap(&A[i++], &A[j--]);
	    else
		break;
	}
	Swap(&A[j], &A[Left]);
	Qsort(A, Left, j - 1);
	Qsort(A, j + 1, Right);
    }
}
void quickSort(int A[], int N)
{
    Qsort(A, 0, N - 1);
}
 

（2）部分排序：如果對最小的K個數順序沒有要求，只要找出最小的K個數即可，則沒必要對所有數都進行排序，找出前K個最小的數就可以了。

陣列方法：維護一個大小為K的陣列，K以數列的前10個數初始化，按照從小到大排列。然後繼續從數列中的第11個數開始遍歷，若小於陣列中最大的數，則捨棄這個最大數，更新當前陣列，重新排列。插入新的數要遍歷這個陣列，因此最壞情況時間複雜度為N*K.

//陣列方法實現輸出最小的K個數
int* MinK(int *a, int n, int k)
{
    int* MinArry = new int[k+1];
    for(int i=0; i<k+1; ++i)
        MinArry[i] = a[i];
    int pos = k + 1;
    //K個數插入排序
    for(int i=1; i<k; ++i)
    {
        int Tmp = MinArry[i];
        int j;
        for(j=i; j>0 && MinArry[j-1]>Tmp; j--)
            MinArry[j] = MinArry[j-1];
        MinArry[j] = Tmp;
    }
    for(int pos=k+1; pos<n; ++pos)
    {
        MinArry[k+1] = a[pos];  //不斷讀入數列中的數到陣列末尾
        int InsertNum = MinArry[k+1];
        if(InsertNum < MinArry[k])
        {
            int i;
            for(i=k+1; i>0 && MinArry[i-1]>InsertNum; --i)
                MinArry[i] = MinArry[i-1];
            MinArry[i] = InsertNum;  //插入合適的位置
        }
    }
    return MinArry;
}
 

快速排序演算法的變種：如果選定了基準值，一趟迴圈後基準值的位置為j，j左邊的元素都是小於它的，j右邊的元素都是大於它的。如果j正好等於k-1，那麼數列下標為0到k-1的元素就是最小的k個數，函式返回；如果j小於k-1，那麼在j的右邊遞迴的使用快速排序，它會使新的基準值的位置右移，同理j大於k-1時在j的左側使用快排，讓新的基準值位置左移，直到基準值的最終在位置k-1上；

void Swap(int &a, int &b)
{
    int c = a;
    a = b;
    b = c;
}

void Qsort(int *a, int Left, int Right, int k)
{
    if(Left < Right)
    {
        int pivot = a[Left];
        int i = Left + 1, j = Right;
        for(;;)
        {
            while(a[i] < pivot)
                ++i;
            while(a[j] > pivot)
                --j;
            if(i > j)
                break;
            Swap(a[i++], a[j--]);
        }
        Swap(a[j], a[Left]);
        if(j < k-1)
            Qsort(a, j+1, Right, k);
        else if(j > k-1)
            Qsort(a, Left, j-1, k);
        else
            return;
    }
}

void Select(int *a, int n, int k)
{
    Qsort(a, 0, n-1, k);
}

時間複雜度分析：假設每次快排陣列長度都是上一次的一半，又T(N)=N+N/2+N/4+N/8+…=2N=O(N)。最壞情況分析：如果數列是已經排序的，每次排序只能排除掉一個數，有T(N)=N+N-1+N-2+N-3+…+0=O(N^2)。

堆排序：通過建立一個K個數的堆的方式，最小的K個數利用最大堆（反之求最大的K個數用到最小堆），不斷讀入數列與堆頂比較。如果小於堆頂表明堆頂不是最小的K個元素之一了，淘汰堆頂並插入。

void swap(int *v, int i, int j)
{
    int tmp = v[i];
    v[i] = v[j];
    v[j] = tmp;
}
void siftup(int *v, int n)
{
    int c;
    for(int i = n-1; i>0 && v[i] > v[c=(i-1)/2]; i = c)
        swap(v, i, c);
}

void siftdown(int *v, int n)
{
    int c;
    for(int i = 0; (c = 2*i+1) <= n-1; i = c)
    {    
        if(c+1 <= n-1 && v[c] < v[c+1])
            ++c;
        if(v[i] >= v[c])
            break;
        swap(v, i, c);
    }
}
void TopK(int *a, int n, int k)
{
    int *heap = new int[k];
    for(int i = 0; i < k; ++i)
        heap[i] = a[i];          //堆初始化資料
    for(int i = 1; i < k; ++i)
        siftup(heap, i+1);       //建堆
    for(int i = k; i < n; ++i)   //與堆頂元素比較，如果小於堆頂則替換堆頂
    {
        if(a[i] < *heap)
        {
            *heap = a[i];
            siftdown(heap, k);
        }
    }
    for(int i = 0; i < k; ++i)
        cout << heap[i] << " ";
    cout << endl;
    delete[] heap;
}