剑指Offer：最小的K个数

输入n个整数（不重复），找出其中最小的k个数。例如输入4、5、1、6、2、7、3、8这8个数字，则输出最小的4个数为1、3、2、4。

解法一：O(n)的解法，但是会修改原数组

      从面试题[数组中出现次数超过一半的数字](http://blog.csdn.net/qq_25343557/article/details/79319564)中受到启发，在该题中我们在寻找下标为n/2的数字，那么我们可以转变思路，找下标为k-1的数字，找到后该数左边的就是前k个数字了（包括k-1的数字）。

实现代码：

private static void GetKLeastNumbers(int[] inPut,int[] outPut,int k){
	if(inPut==null||outPut==null){
		throw new RuntimeException("inPut==null||outPut==null");
	}
	if(k<=0||k>inPut.length){
		throw new RuntimeException("k<=0||k>inPut.length");
	}
	int left = 0;
	int right = inPut.length-1;
	int index = Partition(inPut, left, right);
	while(index != k-1){
		if(index > k-1){
			index = Partition(inPut, left, index-1);
		}else{
			index = Partition(inPut, index+1, right);
		}
	}
	for(int i=0;i<k;i++){
		outPut[i] = inPut[i];
	}
}

//划分
private static int Partition(int arr[],int left,int right){
	int x = arr[left];//将最左边的值作为主元
	int i = left;
	for(int j=left+1;j<=right;j++){
		if(arr[j]<x){
			i++;
			swap(arr,i,j);
		}
	}
	swap(arr,left,i);
	return i;//返回划分位置
}

//交换
private static void swap(int arr[],int i,int j){
	int temp = arr[j];
	arr[j] = arr[i];
	arr[i] = temp;
}

解法二：O(nlogk)的解法，不会修改原数组

      我们可以先创建一个大小为 k 的数据容器来存储最小的 k 个数字，接下来我们每次从输入的 n 个整数中读入一个数 如果容器中已有的数字少 于 k 个，则直接把这次读入的整数放入容器之中：如果容器中己有 k 个数 字了，也就是容器己满，此时我们不能再插入新的数字而只能替换已有的数字。找出这己有的 k 个数中的最大值，然后与这次待插入的整数和最大值进行比较。如果待插入的值比当前己有的最大值小，则用这个数替换当前已有的最大值；如果待插入的值比当前已有的最大值还要大，那么这个 数不可能是最小的 k 个整数之一，于是我们可以抛弃这个整数。

      因此当容器满了之后，我们要做 3 件事情：一是在 k 个整数中找到最大数；二是有可能在这个容器中删除最大数；三是有可能要插入一个新的数字。如果用一个二叉树来实现这个数据容器，那么我们能在 O(logk）时间 内实现这三步操作 因此对于n 个输入数字而言，总的时间效率就是O(nlogk))。

      我们可以选择用不同的二叉树来实现这个数据容器。由于每次都需要 找到k个整数中的最大数字，我们很容易想到用最大堆。在最大堆中，根 结点的值总是大于它的子树中任意结点的值 于是我们每次可以在 0(1)得 到已有的k 个数字中的最大值，但需要 O(logk）时间完成删除及插入操作 。

      我们自己从头实现一个最大堆需要一定的代码，这在面试短短的几十分钟内很难完成 我们还可以采用红黑树来实现我们的容器。红黑树通过把结点分为红、黑两种颜色并根据一些规则确保树在一定程度上是平衡的， 从而保证在红黑树中查找、删除和插入操作都具需要 O(logk）时间。在Java中TreeSet是基于红黑树实现的，我们就可以直接拿过来用。
下面是基于TreeSet 的参考代码：

private static void GetKLeastNumbers(int[] inPut,TreeSet<Integer> container,int k){
	if(inPut==null||container==null){
		throw new RuntimeException("inPut==null||container==null");
	}
	if(k<=0||k>inPut.length){
		throw new RuntimeException("k<=0||k>inPut.length");
	}
	for(int i=0;i<inPut.length;i++){
		int num = inPut[i];
		if(container.size()<k){
			container.add(num);
		}else{
			//容器满了之后，我们要做 3 件事情
			if(container.last()>num){//容器中的最大值与num比较
				container.remove(container.last());//删除最大值
				container.add(num);//插入新值，替换最大值
			}
		}
	}
}

解法比较：

      基于函数 Partitiaon 的第一种解法的平均时间复杂度是 O(n)，比第二种思路要快，但同时它也有明显的限制，比如会修改输入的数组。

      第二种解法虽然要慢一点，但它有两个明显的优点。一是没有修改输入的数据。我们每次只是从输入数组中读入数字，所有的写操作都是在容器container中进行的。二是该算法适合海量数据的输入(包括百度在内的多家公司非常喜欢与海量输入数据相关的问题）。假设题目是要求从海量的数据中找出最小的 k 个数字，由于内存的大小是有限 的，有可能不能把这些海量的数据一次性全部载入内存。这个时候，我们 可 以从 辅 助 存 储 空 间 (比如硬盘 ) 中每次读入一个 数字，根 据 GetKLeastNumbers 的方式判断是不是需要放入容器container 即可。这种思路只要求内存能够容纳 container 即可，因此它最适合的情形就是 n 很大并且k较小的问题。