No5、查找最小的 k 个元素（数组）

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

例如输入 1，2，3，4，5，6，7 和 8 这 8 个数字，则最小的 4 个数字为 1，2，3 和 4。

编程之美原题，只不过编程之美上是求n个整数的k个最大的数

1、拿到题目第一个想法是排序，排序完了之后再取前K个最小的，这样的时间复杂度是O(n*lgn)+O(k) = O(n*lgn)...当然..这个不行，但是我们可以从最简单的方法向外延伸

2、观察上面的排序，是将n个数全部排序，其实我们不需要知道所有的顺序，我们只需要知道最小的k个数。所以，采取部分选择排序，每次遍历寻找最小的数，然后取出，遍历k次就能获得最终结果，这样的时间复杂度是O(n*k)，当k<lgn的时候还是要比第一种的时间复杂度要好的..

3、第二种方法取出的k个数是有顺序的，而题目不需要有顺序，所以我们需要将把求顺序的时间去掉，还能进一步优化。再继续思考，我们所求的k个数是最小的，相当于将数组分为三部分，A-n-B，A的长度为k，n左边的数都比n小，n右边的数都比n大.....看到这里是不是很熟悉，对了，快排...只能说这是一个部分快排算法...

快排的算法如下：

public void QuickSort(int[] array,int head,int tail)
{
if(head >= tail)
return;

int low = head;
int high = tail;
int num = array[low];

while(low < high)
{
while(array[high] >= num && low < high)
high--;
array[low] = array[high];

while(array[low]<=num && low<high)
low++;
array[high] = array[low];
}

array[low] = num;

QuickSort(array,head,low-1);
QuickSort(array,low+1,tail);
}

快排是取范围内的第一个数作为中枢，遍历完后数组中中枢数左边的是比中枢数小的数，中枢数右边是比中枢数大的数。题目中还要求了k个数字的限制，所以，我们在递归的时候需要对进入递归的条件做一下处理：

假设中枢数最后的位置是index，范围的开头是head，结尾时tail，那么我们考虑的是head~index之间的数：

1、如果head~index中数字的个数大于k，那么所有的k个最小的数都在左边区域中，所以左边子数组进入递归；

2、如果head~index中数字的个数等于k，那么输出左边区域的数字；

3、如果head~index中数字的个数小于k，那么最小的k个数分成了两个部分，一部分是head~index中的全部的数字，一部分是index~tail中的最小的k-len(head~index)个数字...使用一个memory保存第一部分，将第二部分进入递归即可

代码如下：

public void getMinK(int[] list,int index)
{
if(index == 0 || list.length == 0)
return;

int pos = 0;
int num = list[0];
int low = 0;
int high = list.length-1;
//快排分区域
while(low < high)
{
while(list[high] >= num && high>low)
high--;
list[pos] = list[high];
pos = high;
list[pos] = num;

while(list[low] <= num && high >low)
low++;
list[pos] = list[low];
pos = low;
list[pos] = num;
}
//实现的时候，每次进入递归的都是新建的一个数组，相当于每次的head都是0
if(pos+1>index)         //当左边区域的个数大于k
{
int[] a = new int[pos];            //新建一个数组，里面包含左边区域的个数，然后在这个数组里面挑选最小的k个数子
for(int i = 0;i<pos;i++)
{
a[i] = list[i];
}
getMinK(a, index);
}

else if(pos+1 == index)                      //直接输出
{
String result = "";
for(int i = 0;i<=pos;i++)
{
result = result + " " + list[i];
}
System.out.println(result);
}
else                                            //当左边区域的个数小于k
{
String result = "";                     //输出左边区域的数字
for(int i = 0;i<=pos;i++)
{
result = result + " " + list[i];
}
System.out.println(result);

int[] a = new int[list.length-pos-1];       //新建一个数组，里面存储了右边区域的数字，然后从里面取k-len(左边区域)个最小值
for(int i = 0;i<list.length-pos-1;i++)
{
a[i] = list[i+pos+1];
}
getMinK(a, index-pos-1);
}
}

这样的平均时间复杂度是O(N*lgk)，计算方法与快排的时间复杂度的计算方法类似

4、前面的实现貌似有点麻烦..就这么着吧..重点在于思想...用方法3的前提是有一个数组能存n个数据，如果n非常大的话数据就不能都装入内存中，所以我们需要考虑其他的方法了...n太大，我们可以从k入手。在内存中维持一个容量为k的桶，维持桶中数字的最大值。先将前K个数放进桶中，依次将剩下的n-k个数尝试放进桶中。如果新的数字小于桶的最大值，那么需要将桶的最大值拿出桶外，将新的数字放入桶中，并更新桶中数字的最大值..相当于时刻保证桶中的数字永远是目前涉及到的数字中的最小值.有点动态规划的意思....

这个方法里面需要考虑一个问题，每次桶中的数字更新的话都需要获得桶中的最大值，遍历的时间复杂度是o(k)，遍历永远是最笨的方法...每次都是最大值，什么算法能快速的维持一个数组的最大值，很明显是最大堆..我们将桶内部的存储格式设置成一个最大堆，堆顶的数字永远是堆中最大的数字。如果堆更新，重建堆的时间复杂度是O(lgk)，是要优于O(k)的...所以我们可以用堆排序的思想来解答这个问题..

堆排序算法：

public class HeapSort {
public static void HeapAdjust(int[] array,int start,int end)
{
for(int i = start * 2;i <= end;i = i * 2)
{
if(i < end && array[i+1] > array[i])
i++;

if(array[start] >= array[i])
break;

int temp = array[i];
array[i] = array[start];
array[start] = temp;

start = i;
}

}
public static void main(String[] args) {
int[] array = {-1,3,4,43,23,4,43,5,34,35,3,4,43,53,3,42,3};
int length = array.length-1;

for(int i = length/2;i>0;i--)
HeapAdjust(array, i, length);

for(int i = length;i>0;i--)
{
System.out.println(array[1]);
array[1] = array[i];

HeapAdjust(array, 1, i);
}
}
}

我们只要建立个堆，然后每次插入数据后整理这个最大堆，就能得到最后结果了...代码不写了..

时间复杂度也是O(Nlgk)