【编程题目】查找最小的 k 个元素

5.查找最小的 k 个元素（数组）
题目：输入 n 个整数，输出其中最小的 k 个。
例如输入 1，2，3，4，5，6，7 和 8 这 8 个数字，则最小的 4 个数字为 1，2，3 和 4。

算法里面学过查找第k小的元素的O（n）算法

试着实现了一下：

注意new 初始化二维数组的方式

int (* a)[5] = new int[8][5];

/*
5.查找最小的 k 个元素（数组）
题目：输入 n 个整数，输出其中最小的 k 个。
例如输入 1，2，3，4，5，6，7 和 8 这 8 个数字，则最小的 4 个数字为 1，2，3 和 4。
*/

#include <iostream>
#include <algorithm>
using namespace std;

bool compare(int a, int b) //降序排列
{
    return a > b;
}

//找到 一共有 n个 元素的 数组S 中 第k小 的数字  整个算法中，对除以5后余下的数字都做了特殊处理
int Select(int * S, int k, int n)
{
    if (n < ) //对少于5个的做特殊处理
    {
        sort(S, S + n);
        return S[k - ];
    }
    int subn = n/ + ((n %  == ) ?  : );
    int subnn = n/;
    int (* subS)[] = new int[subn][];
    for (int i = ; i < subnn; i++)
    {
        for (int j = ; j < ; j++)
        {
            subS[i][j] = S[i *  + j];
        }
        sort(subS[i], subS[i] + , compare); //5个一组,每组从大到小排序
    }
    for (int j = ; j < n % ; j++)
    {
        subS[subn - ][j] = S[subn *  + j - ];
    }
    sort(subS[subn - ], subS[subn - ] + n % , compare); 

    int * M = new int [subn];
    for (int i = ; i < subn; i++)
    {
        M[i] = subS[i][]; //M 中存储每组数字的中位数
    }

    int Mn = subnn;
    int m = Select(M, Mn/ + (Mn %  == ) ?  : , Mn);
    delete [] M;

    int * S1 = new int [n]; //存放小于等于m的数字
    int * S2 = new int [n];
    int S1n = ; //记录有多少小于等于m的数字
    int S2n = ;

    //找到相应的S1 与 S2中的元素
    for (int i = ; i < subnn; i++)
    {
        if (subS[i][] <= m)
        {
            for (int j = ; j < ; j++)
            {
                if (j < )
                {
                    if (subS[i][j] <= m)
                    {
                        S1[S1n++] = subS[i][j];
                    }
                    else
                    {
                        S2[S2n++] = subS[i][j];
                    }
                }
                else
                {
                    S1[S1n++] = subS[i][j];
                }
            }
        }
        else
        {
            for (int j = ; j < ; j++)
            {
                if (j > )
                {
                    if (subS[i][j] <= m)
                    {
                        S1[S1n++] = subS[i][j];
                    }
                    else
                    {
                        S2[S2n++] = subS[i][j];
                    }
                }
                else
                {
                    S2[S2n++] = subS[i][j];
                }
            }
        }
    }
    if (subnn != subn) //多余的数字特别处理
    {
        for (int j = ; j < n % ; j++)
        {
            if (subS[subn - ][j] > m)
            {
                S2[S2n++] = subS[subn - ][j];
            }
            else
            {
                S1[S1n++] = subS[subn - ][j];
            }
        }
    }

    if (k == S1n)
    {
        delete [] S1;
        delete [] S2;
        return m;
    }
    else if (k < S1n)
    {
        return Select(S1, k, S1n);
    }
    else
    {
        return Select(S2, k - S1n, S2n);
    }

    delete [] S1;
    delete [] S2;
}

int main()
{
    int a[] = {,,,,,,,};
    int m = Select(a, , );

    return ;
}

不过，我的代码看起来好长，好难受啊...

网上有用堆做的，对堆不是很了解，要补一下知识。

看了用堆的方法的原理，理论上会比我现在实现的这个算法慢一点

方法是用堆维护k个最小元素

下面来自：https://github.com/julycoding/The-Art-Of-Programming-By-July/blob/master/ebook/zh/02.01.md

解法二

咱们再进一步想想，题目没有要求最小的k个数有序，也没要求最后n-k个数有序。既然如此，就没有必要对所有元素进行排序。这时，咱们想到了用选择或交换排序，即：

1、遍历n个数，把最先遍历到的k个数存入到大小为k的数组中，假设它们即是最小的k个数；
2、对这k个数，利用选择或交换排序找到这k个元素中的最大值kmax（找最大值需要遍历这k个数，时间复杂度为O（k））；
3、继续遍历剩余n-k个数。假设每一次遍历到的新的元素的值为x，把x与kmax比较：如果x < kmax ，用x替换kmax，并回到第二步重新找出k个元素的数组中最大元素kmax‘；如果x >= kmax，则继续遍历不更新数组。

每次遍历，更新或不更新数组的所用的时间为O（k）或O（0）。故整趟下来，时间复杂度为n*O（k）=O（n*k）。

解法三

更好的办法是维护容量为k的最大堆，原理跟解法二的方法相似：

• 1、用容量为k的最大堆存储最先遍历到的k个数，同样假设它们即是最小的k个数；
• 2、堆中元素是有序的，令k1<k2<...<kmax（kmax设为最大堆中的最大元素）
• 3、遍历剩余n-k个数。假设每一次遍历到的新的元素的值为x，把x与堆顶元素kmax比较：如果x < kmax，用x替换kmax，然后更新堆（用时logk）；否则不更新堆。

这样下来，总的时间复杂度:O（k+（n-k）*logk）=O（n*logk）。此方法得益于堆中进行查找和更新的时间复杂度均为：O(logk)（若使用解法二：在数组中找出最大元素，时间复杂度：O（k））。

堆的实现代码：来自http://www.cnblogs.com/panweishadow/p/3632639.html

public static void FindKMin(int[] sort, int k)
{
    int[] heap = sort;
    int rootIndex = k /  - ;
    while (rootIndex >= )
    {
        reheap(heap, rootIndex, k - );
        rootIndex--;
    }

    for (int i = k, len=heap.Length; i < len; i++)
    {
        if (heap[i]<heap[])
        {
            heap[] = heap[i];
            reheap(heap, , k - );
        }
    }

    Console.WriteLine("The {0} min element =",k);
    for (int i = ; i < k; i++)
    {
        Console.Write(heap[i] + " ");
    }
}

private static void reheap(int[] heap, int rootIndex, int lastInddex)
{
    int orphan = heap[rootIndex];
    bool done = false;
    int leftIndex = rootIndex *  + ;
    while (!done && leftIndex <= lastInddex)
    {
        int largerIndex = leftIndex;
        if (leftIndex+ <= lastInddex)
        {
            int rightIndex = leftIndex + ;
            if (heap[rightIndex] > heap[leftIndex])
            {
                largerIndex = rightIndex;
            }
        }

        if (orphan < heap[largerIndex])
        {
            heap[rootIndex] = heap[largerIndex];
            rootIndex = largerIndex;
            leftIndex = rootIndex *  + ;
        }
        else
        {
            done = true;
        }
    }

    heap[rootIndex] = orphan;
}