剑指Offer+第30题+最小的k个树+java

题目　

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

思路

解法一：O(n)的算法，只有当我们可以修改输入的数组时可用

从上一题中我们可以得到启发，我们同样可以基于Partition函数来解决这个问题。如果基于数组的第k个数字来调整，使得比第k个数字小的所有数字都位于数组的左边，比第k个数字大的所有数字都位于数组的右边。这样调整之后，位于数组中左边的k个数字就是最小的k个数字。
        采用这种思路是有限制的。我们需要修改输入的数组，因为函数Partition会调整数组中数字的顺序。如果面试官要求不能修改输入的数组，我们该怎么办的呢？

解法二：O(nlogk)的算法，特别适用处理海量数据

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

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

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

 

测试算例　

　　1.功能测试（数组中存在/不存在重复数字）

　　2.边界值测试（k=1或者等于数组长度）

　　2.特殊测试（null、k<1、k大于数组长度）

代码：

package other;

import java.util.ArrayList;

public class Offer30 {
	
	public ArrayList<Integer> getLeastNumbers_1(int [] input, int k){
		ArrayList<Integer> leastNumbers = new ArrayList<>();
		if(input == null || k<=0 || k> input.length){
			System.out.print("输入的值不合法。");
			return leastNumbers;
		}
			
		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++){
			leastNumbers.add(input[i]);
		}
		
		return leastNumbers;
	}
	
	//选用partition函数
	public int partition(int [] arr, int left, int right){
		int result = arr[left];
		if(left>right)
			return -1;
		while(left<right){
			while(left<right && arr[right] >= result)
				right--;
			arr[left] = arr[right];
			while(left<right && arr[left] < result)
				left++;
			arr[right] = arr[left];
		}
		arr[left] = result;
		return left;
	}
	
	//方法2，基于堆的容器
	public ArrayList<Integer> getLeastNumbers_2(int [] input, int k){
		ArrayList<Integer> leastNumbers = new ArrayList<>();
		while(input == null || k<=0 || k> input.length){
			System.out.print("输入的值不合法。");
			return leastNumbers;
		}
		
		int [] numbers = new int[k];//用于放最小的k个数
		for(int i = 0;i<k;i++){
			numbers[i] = input[i];//先放入前k个数
		}
		for(int i = k/2-1;i>=0;i--)
			adjustHeap(numbers, i, k-1);//循环建立初始堆
		for(int i=k ;i<input.length;i++){
			if(input[i]<numbers[0]){
				numbers[0] = input[i];
				adjustHeap(numbers, 0, k-1);//重新调整最大堆
			}
		}
		
		for(int n:numbers)
			leastNumbers.add(n);
		
		return leastNumbers;
	}
	
	//最大堆的调整方法，见堆排序
	public void adjustHeap(int[] numbers, int parent, int length) {
		int temp = numbers[parent];// temp保存当前父节点
		int child = 2*parent+1;// 先获得左孩子
		
		while(child<=length){//这里是<=，若是<输出结果就不对，和堆排序对比，想想为什么，因为adjustHeap(numbers, 0, k-1);输入的length=k-1;若真实冷天，应该是k
			  // 如果有右孩子结点，并且右孩子结点的值大于左孩子结点，则选取右孩子结点
			if(child+1<=length && numbers[child]<numbers[child+1])
				child++;
			// 如果父结点的值已经大于孩子结点的值，则直接结束
			if(temp> numbers[child])
				break;
			// 把孩子结点的值赋给父结点
			numbers[parent] = numbers[child];
			// 选取孩子结点的左孩子结点,继续向下筛选
			parent = child;
			child = 2 *child+1;
		}
		numbers[parent] = temp;
	}

	public static void printArray(ArrayList<Integer> array){
		for(Integer temp:array){
			System.out.print(temp+"  ");
		}
		System.out.println();
	}
	
	
	public static void main(String[] args) {
		
		Offer30 of30 = new Offer30();
		
		//功能测试，1，输入的数组中没有相同的数字
		int [] arr11 = {4,5,1,6,2,7,3,8};
		//printArray(of30.getLeastNumbers_1(arr11, 4));
		printArray(of30.getLeastNumbers_2(arr11, 4));
		
		//功能测试，2，输入的数组中有有相同的数字
		int [] arr21 = {4,5,1,6,2,3,3,8};
		//printArray(of30.getLeastNumbers_1(arr21, 4));
		printArray(of30.getLeastNumbers_2(arr21, 4));
		
		//边界值测试，3， 输入的k=1
		int [] arr31 = {4,5,1,6,2,7,3,8};
		//printArray(of30.getLeastNumbers_1(arr31, 1));
		printArray(of30.getLeastNumbers_2(arr31, 1));
		
		//边界值测试，4， 输入的k=arr.length
		int [] arr41 = {4,5,1,6,2,7,3,8};
		//printArray(of30.getLeastNumbers_1(arr41, 8));
		printArray(of30.getLeastNumbers_2(arr41, 8));
		
		//特殊输入测试，5，k<1
		int [] arr51 = {4,5,1,6,2,7,3,8};
		//printArray(of30.getLeastNumbers_1(arr51, -1));
		printArray(of30.getLeastNumbers_2(arr51, -1));
		
		//特殊输入测试，6，k>arr.length
		int [] arr61 = {4,5,1,6,2,7,3,8};
		//printArray(of30.getLeastNumbers_1(arr61, 10));
		printArray(of30.getLeastNumbers_2(arr61, 10));
		
		//特殊输入测试，7，arr=null
		int [] arr71 = null;
		//printArray(of30.getLeastNumbers_1(arr71, 10));
		printArray(of30.getLeastNumbers_2(arr71, 10));

	}

}

运行结果：

3  2  1  4  
2  1  3  3  
1  
3  2  1  4  5  6  7  8  
输入的值不合法。
输入的值不合法。
输入的值不合法。