No5、查找最小的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

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          {
                while(array[high] >= num && low                         high--;
                array[low] = array[high];

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

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

      假设中枢数最后的位置是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 		{
			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			{
				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			{
				a[i] = list[i+pos+1];
			}
			getMinK(a, index-pos-1);
		}
	}

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  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)