一、題目描述

描述：

輸入n個整數，輸出其中最小的k個。

輸入：

1. 輸入 n 和 k
2. 輸入一個整數陣列

輸出：

輸出一個整數陣列

樣例輸入：

5 2
1 3 5 7 2

樣例輸出：

1 2

二、Top K問題

對於 Top K 問題有很多種解法。

解法一：排序

相信很多人會首先想到這種方法，先把陣列按升序/降序進行排序，然後輸出 K 個最小/最大的數。

• 常規的排序方法時間複雜度至少是Θ(nlog2n)。（快排或堆排序）
• 可能你會說，我們可以使用線性時間的排序演算法。當然可以，但通常它們對輸入的陣列有一定的要求。比如計數排序要求 n 個數都是正整數，且它們的取值範圍不太大。

解法二：部分排序 O(n∗k)

由於我們只需要找出最小/最大的 k 個數，所以我們可以進行部分排序，比如簡單選擇排序 和 氣泡排序，它們每一趟都能把一個最小/最大元素放在最終位置上，所以進行 k 趟就能把 n 個數中的前 k 個排序出來。

部分簡單選擇排序：

void select_sort(int A[], int n, int k)
{
    for(int i=0; i<k; ++i) { // k趟
        int Min = i;         // 記錄最小元素的位置

        for(int j=i+1; j<n; ++j)
            if
 
(A[j] < A[Min])
                Min = j;

        if(Min != i)  // 與A[i]交換
        {
            int tmp = A[Min];
            A[Min] = A[i];
            A[i] = tmp;
        }
    }
}

部分氣泡排序：

void bubble_sort(int A[], int n, int k)
{
    for(int i=0; i<k; ++i)  // k趟
    {
        bool flag = false
 
;
        for(int j=n-1; j>i; --j)  // 一趟冒泡過程
            if(A[j-1] > A[j])
            {
                int tmp = A[j-1];
                A[j-1] = A[j];
                A[j] = tmp;
                flag = true;
            }
        if(flag == false)  // 已經有序
            return ;
    }
}

那麼，O(nlog2n) 與 O(n∗k) 哪一個更好呢？這取決於 k 的大小。在 k 較小的情況下，即 k<=log2n，可以選擇部分排序。

解法三：快排劃分 O(n∗log2k)

根據基於快排partition操作的《第k順序統計量的求解》，我們知道，當我們求出第 k 順序統計量時，位於它前面的元素都比它小，位於它後面的元素都比它大。這時，陣列的前 k 個數就是最小的 k 個數。

int partition(int A[], int low, int high)
{
    int pivot = A[low];
    while(low < high)
    {
        while(low < high && A[high]>=pivot)
            --high;
        A[low] = A[high];
        while(low < high && A[low]<=pivot)
            ++low;
        A[high] = A[low];
    }
    A[low] = pivot;
    return low;
}


int topK(int A[], int low, int high, int k)
{
    if(k <= 0)
        return -1;
    if(low == high)
        return low;

    int pos = partition(A, low, high);
    int i = pos - low + 1;
    if(i == k)
        return pos;  // 返回前k個數的
    else if(i > k)
        return topK(A, low, pos, k);
    else
        return topK(A, pos+1, high, k-i);
}

我們說這個演算法的平均時間複雜度是線性的，更準確地說，是 O(n∗log2k)。另外，為了避免特殊資料下的演算法退化，最好使用隨機化版本的劃分操作。

解法四：大根堆 O(n∗log2k)

參見《堆排序》，可以用大小為 k 的大根堆來儲存最小的 k 個數。大根堆的堆頂元素就是最小 k 個數中最大的一個。每次新考慮一個數 X：

• 如果 X 比堆頂的元素 Y 大，則不需要改變原來的堆，因為這個元素比最小的 k 個數都大。

• 如果 X 比堆頂元素 Y 小，那麼用 X 替換堆頂的元素 Y。在 X 替換堆頂元素 Y 之後，大根堆的結構可能被破壞，需要進行向下調整。調整過程的時間複雜度是 O(log2k) 。

遍歷完成以後，陣列的前 k 個數就是最小的 k 個數，但是它們並非有序，而是以堆的形式存在。C++程式碼如下：

void AdjustDown(int A[], int i, int len)  
{  
    int temp = A[i];  // 暫存A[i]  

    for(int largest=2*i+1; largest<len; largest=2*largest+1)  
    {  
        if(largest!=len-1 && A[largest+1]>A[largest])  
            ++largest;         // 如果右子結點大  
        if(temp < A[largest])  
        {  
            A[i] = A[largest];  
            i = largest;         // 記錄交換後的位置  
        }  
        else  
            break;  
    }  
    A[i] = temp;    // 被篩選結點的值放入最終位置  
}

/* 建堆 */
void BuildMaxHeap(int A[], int len)
{
    for(int i=len/2-1; i>=0; --i)  // 從i=n/2-1到0，反覆調整堆
        AdjustDown(A, i, len);
}


/* 維護 A[0...k-1] 這個大根堆 */
void topK(int A[], int n, int k)
{
    BuildMaxHeap(A, k);  // 先用前面的k個數建大根堆
    for(int i=k; i<n; ++i)
    {
        if(A[i] < A[0])  // 如果小於堆頂元素，替換之
        {
            int tmp = A[0];
            A[0] = A[i];
            A[i] = tmp;
            AdjustDown(A, 0, k);  // 向下調整
        }
    }
}

注意：找最小的 k 個數，就維護一個大根堆；找最大的 k 個數，就維護一個小根堆。

三、解題報告

第二部分已經講解地很清楚了，幾種解法都可以，只要注意輸入輸出的格式就行了。