【剑指Offer学习】【题29：最小的K个数】

题目：
输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。

思路：
1、快速排序
2、堆排序

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

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

程序：

public class subject29 {
	public static int[] GetLeatNumbers_Solution(int[] input, int k){
		if(input == null || input.length == 0 || k <= 0 || k > input.length) {
			return null;
		}
		int[] output = new int[k];
		int start = 0;
		int end = input.length - 1;
		int index = partition(input, start, end);
		while(index != k-1) {
			if(index < k - 1) {
				start = index + 1;
				index = partition(input, start, end);
			}else {
				end = index - 1;
				index = partition(input, start, end);
			}
		}
		for(int i = 0; i < k; i ++) {
			output[i] = input[i];
		}
		return output;
	}
	//快速查找的partition函数
	public static int partition(int[] array, int left, int right) {
		int pivot = array[left];
		if(left >= right) {
			return -1;
		}
		while(left < right) {
			while(left < right && array[right] > pivot) {
				right --;
			}
			if(left < right) {
				array[left] = array[right];
				left ++;
			}
			while(left < right && array[left] < pivot) {
				left ++;
			}
			if(left < right) {
				array[right] = array[left];
				right --;
			}
		}
		array[left] = pivot;
		return left;
	}
	public static void main(String args[]) {
		int[] arr = new int[] { 4, 5, 1, 6, 2, 7, 3, 8 };
		int num = 7;
		int[] result = GetLeatNumbers_Solution(arr, num);
		for (int i = 0; i < result.length; i++) {
			System.out.print(result[i]);
		}
	}
}

public class subject29 {
	public static int[] GetLeatNumbers_Solution(int[] input){
		if(input.length ==0) {
			return input;
		}
		for(int i = input.length / 2; i >= 0; i --) {
			buildMaxHeap(input, i, input.length);
		}
		for(int i = input.length - 1; i > 0; i --) {
			swap(input, 0, i);
			buildMaxHeap(input, 0, i);
		}
		return input;
	}
	public static void buildMaxHeap(int[] array, int i, int n) {
		int child;
		int father;
		for(father = array[i]; leftChild(i) < n; i = child) {
			child = leftChild(i);
			if(child != n-1 && array[child] < array[child + 1]) {
				child ++;
			}
			if(father < array[child]) {
				array[i] = array[child];
			}else {
				break;
			}
		}
		array[i] = father;
	}
	//交换元素位置
	public static void swap(int[] array, int i, int j) {
		int temp = array[i];
		array[i] = array[j];
		array[j] = temp;
	} 
	//获取到左孩子结点
	public static int leftChild(int i) {
		return 2 * i + 1;
	}
	public static void main(String args[]) {
		int[] arr = new int[] { 4, 5, 1, 6, 2, 7, 3, 8 };
		int num = 3;
		int[] result = GetLeatNumbers_Solution(arr);
		for (int i = 0; i < 3; i++) {
			System.out.print(result[i]);
		}
	}
}
```j