剑指offer-30-最小的k个数-java

题目及测试

package sword030;
/* 题目：输入n个整数，找出其中最小的k个数。
 * 例如输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。




*/

import java.util.List;

public class main {
	
	public static void main(String[] args) {
		int[][] testTable = {{1,3,4,2,2,3},{1,1,1,1,2}};
		int[] testTable2={3,3};
		for (int i=0;i<testTable.length;i++) {
			test(testTable[i],testTable2[i]);
		}
	}
		 
	private static void test(int[] ito,int ito2) {
		List<Integer> rtn;
		Solution solution=new Solution();
		long begin = System.currentTimeMillis();
		for (int i = 0; i < ito.length; i++) {
		    System.out.print(ito[i]+" ");		    
		}
		System.out.println();
		//开始时打印数组
		System.out.println("ito2="+ito2);
		rtn = solution.kSmallest(ito,ito2);//执行程序
		long end = System.currentTimeMillis();	
		
		System.out.println(ito + ": rtn=" );
		System.out.println( " rtn=" );
		for (int i = 0; i < rtn.size(); i++) {
		    System.out.print(rtn.get(i)+" ");
		}//打印结果几数组
		
		System.out.println();
		System.out.println("耗时：" + (end - begin) + "ms");
		System.out.println("-------------------");
	}

}

解法1（成功）

这道题最简单的思路莫过于把输入的n个整数排序，排序之后位于最前面的k个数就是最小的k个数。这种思路的时间复杂度是O(nlogn）。

解法一：O(n)的算法，只有当我们可以修改输入的数组时可用
我们同样可以基于Partition函数来解决这个问题。如果基于数组的第k个数字来调整，使得比第k个数字小的所有数字都位于数组的左边，比第k个数字大的所有数字都位于数组的右边。这样调整之后，位于数组中左边的k个数字就是最小的k个数字。

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

因此当容器满了之后，我们要做3件事；一是在k个整数中找到最大数；二是有可能在这个容器中删除最大数；三是有可能要插入一个新的数字。如果用一个二叉树来实现这个容器，那么我们能在O(logk）时间内实现这三步操作。因此对于n个输入的数字而言，总的时间效率是O(nlogk).
我们可以选择用不同的二叉树来实现这个数据容器。由于每次都需要找到k个整数中的最大数字，我们很容易想到用最大堆。在最大堆中，根节点的值总是大于它的子树中的任意结点的值。于是我们每次可以在O(1）得到已有的k个数字中的最大值，但需要O(logk)时间完成删除及插入操作。

package sword030;

import java.util.*;

class Solution {
	public List<Integer> kSmallest(int[] nums, int k) {
		List<Integer> result = new ArrayList<Integer>();
		int length = nums.length;
		if(length == 0) {
			return result;
		}
		if(length < k) {
			return result;
		}
		int begin = 0;
		int end = length - 1;
		while(true) {
			int mid = partition(nums, begin, end);
			if(mid == k || mid == k - 1) {
				break;
			}
			if(mid > k) {
				end = mid - 1;
			}else {
				begin = mid + 1;
			}
		}
		for(int i=0;i<k;i++) {
			result.add(nums[i]);
		}
		return result;
	}

	private void swap(int[] nums, int i, int j) {
		int temp = nums[i];
		nums[i] = nums[j];
		nums[j] = temp;
	}

	// 从begin到end（都包括），进行分割，返回中间点，左边的小于等于它，右边的大于等于它
	private int partition(int[] nums, int begin, int end) {
		if (begin == end) {
			return begin;
		}
		int baseNum = nums[begin];
		int base = begin;
		int i = begin;
		int j = end;
		while (i <= j) {
			while (i <= j) {
				int now = nums[j];
				if(now>= baseNum) {
					j--;
					continue;
				}else {
					swap(nums, base, j);
					base = j;
					break;
				}
			}
			while (i <= j) {
				int now = nums[i];
				if(now <= baseNum) {
					i++;
					continue;
				}else {
					swap(nums, i, base);
					base = i;
					break;
				}
			}
		}		
		nums[i] = baseNum;
		return i;

	}
}