寻找最小的 k 个数

题目

输入n个整数，输出其中最小的k个。

思路一

使用排序的方法来解决该问题。快速排序所费时间复杂度为O(n*logn).排序完成过后，只需要取前k个数值即是最小的k个数。

int array[] = {34, 9, 27, 36, 80, 12, 5, 100};
const int length = sizeof(array)/sizeof(array[0]);

void PrintArray(int a[], int len){
    if(NULL == a || len < 0)
        return ;

    for(int i=0; i<len; i++)
        cout << a[i] << " ";
    cout << endl;
}

void swap(int &a, int &b){
    int temp = a;
    a = b;
    b = temp;
} 

int partition(int (&r)[length], int low, int high){
    if(NULL == r || low < 0 || high < 0 || low > high)
        return -1;
    int criterionValue = r[low];
    while(low < high){
        while(low < high && r[high] >= criterionValue)
            --high;
        swap(r[low], r[high]);
        while(low < high && r[low] <= criterionValue)
            ++low;
        swap(r[high], r[low]);
    }
    return low;
}

void QuickSort(int (&s)[length], int low, int high){
    if(NULL == s || low < 0 || high < 0 || low > high)
        return ;
    if(low < high){
        int criterionLoc = partition(s, low, high);
        QuickSort(s, low, criterionLoc-1);
        QuickSort(s, criterionLoc+1, high);
        cout << "------" << endl;
        PrintArray(s, length);
    }
}

void MinNumber(int a[], int k){
    if(NULL == a || k < 0 || k > length)
        return ;
    for(int i=0; i<k; i++)
        cout << a[i] << " ";
    cout << endl;
}

int main(){
    PrintArray(array, length);
    QuickSort(array, 0, length-1);
    PrintArray(array, length);
    MinNumber(array, 3);

    return 0;
}

思路二

在思路一中，我们是将所有的数据都进行有序排列，因此时间复杂度比较高，而实际上，我们只需要得到最小的k个数即可，而没有必要对所有的数都进行排序，因此我们可以用如下的方法：
>
1. 先选取数组中前k个数，假设这k个数即是最小的k个数；
2. 遍历前k个数，找出其中的最大值kmax，遍历后length-k个数，找出其中的kmin值；
3. 比较kmax与kmin的值，若kmax大于kmin，则交换他们的位置。并且重复步骤2；
4. 若kmax小于等于kmin，则结束循环，打印出前k个数即可。

#include<iostream>
using namespace std;

int array[] = {14, 90, 89, 7, 34, 25, 33, 76};
const int length = sizeof(array)/sizeof(array[0]);

void PrintArray(int a[], int len){
    if(NULL == a || len < 0)
        return ;
    for(int i=0; i<len; i++)
        cout << a[i] << " ";
    cout << endl;
}

void swap(int &a, int &b){
    int temp = a;
    a = b;
    b = temp;
} 

int SelectKMax(int a[], int k){
    if(NULL == a || k < 1 || k > length)
        return -1;
    int kMax = 0;
    for(int i=0; i<k; i++)
        if(a[kMax] < a[i])
            kMax = i;

    return kMax;
}

int SelectMin(int a[], int k, int len){
    if(NULL == a || k < 1 || k > len)
        return -1;
    int kmin = 0;
    for(int i=k; i<len; i++)
        if(a[kmin] > a[i])
            kmin = i;

    return kmin;
}

void SelectKMinNumber(int (&r)[length], int k, int len){
    if(NULL == r || k < 1 || k > len)
        return ;
    int kMax = SelectKMax(r, k);
    int kmin = SelectMin(r, k, len);
    while(r[kMax] > r[kmin]){
        swap(r[kMax], r[kmin]);
        kMax = SelectKMax(r, k);
        kmin = SelectMin(r, k, len);
    }
    for(int i=0; i<k; i++)
        cout << r[i] << " ";
    cout << endl;
}

int main(){
    SelectKMinNumber(array, 4, length);
    return 0;
}

思路三

在思路2中最耗时的操作就是遍历来获取kmax和kmin，他们的复杂度分布为O(k)和O(length-k)，由于其中的数据时无序的，我们只需要找到最大数或者最小数即可，那么我们可以考虑使用堆，求kmax时，在前k个数中使用最大堆，可以很容易获得kmax，并且复杂度也降为O(logk)；后length-k中求kmin，可以使用最小堆，这样就很容易求得kmin了，然后再重复上述的比较步骤，整体的复杂度会降低很多。

但是整体的代码会比较复杂，尤其是在写求最小堆进而求得kmin时，更容易出错，所以此时一般都是建议只写求最大堆的部分，而后面的比较部分则就是用kmax依次与后面的length-k个数进行比较即可

#include<iostream>
using namespace std;

int array[] = {14, 90, 89, 7, 34, 25, 33, 76};
const int length = sizeof(array)/sizeof(array[0]);
const int k = 4;

void PrintArray(int a[], int len){
    if(NULL == a || len < 0)
        return ;
    for(int i=0; i<len; i++)
        cout << a[i] << " ";
    cout << endl;
}

void swap(int &a, int &b){
    int temp = a;
    a = b;
    b = temp;
}

void BigHeapAdjust(int (&r)[length], int pos, int len){
    int temp = r[pos];
    int child = 2*pos + 1;
    while(child < len){
        if(child+1 < len && r[child+1] > r[child])
            ++child;
        if(r[pos] < r[child]){
            r[pos] = r[child];
            pos = child;
            child = 2*pos + 1;
        }else {
            break;
        }
        r[pos] = temp;
    }
}

/*这部分的代码很容易出错，因为这是将数组中数据分为两部分进行求最大堆和最小堆，第一部分
下标数组很容易界定，只需要注意该部分的长度即可，而第二部分则不光需要注意长度，还要注意下
标，因为下标不对，那么整个数组到最后求出来的就是很混乱的，因此需要将传输进来的pos值对应数组中的值时，都移动k*/
void SmallHeapAdjust(int (&s)[length], int pos, int len){
    int temp = s[pos+k];
    int child = 2*pos + 1;
    while(child < len){
        if(child+1 < len && s[child+1+k] < s[child+k] )
            ++child;
        if(s[pos+k] > s[child+k]){
            s[pos+k] = s[child+k];
            pos = child;
            child = 2*pos + 1;
        } else {
            break;
        }
        s[pos+k] = temp;
    }
}

void BuildingBigHeap(int (&b)[length], int len){
    for(int i=(len-1)/2; i>=0; --i){
        BigHeapAdjust(b, i, len);
    }
    cout << "BuildingBigHeap : ";
    PrintArray(b, len);
}

void BuildingSmallHeap(int (&d)[length], int len){
    for(int i=(len-1)/2; i>=0; i--)
        SmallHeapAdjust(d, i, len);
    cout << "BuildingSmallHeap : ";
    PrintArray(d, length);
}

void SelectKMin(int (&arr)[length], int k){
    BuildingBigHeap(arr, k);
    BuildingSmallHeap(arr, length-k);
    while(arr[0] > arr[k]){
        swap(arr[0], arr[k]);
        BuildingBigHeap(arr, k);
        BuildingSmallHeap(arr, length-k);
    }
    for(int i=0; i<k; i++)
        cout << arr[i] << " ";
    cout << endl;
}

int main(){
    SelectKMin(array, k);
    return 0;
}