问题: 一个数组长度为n, 求出其最小的k个元素并从小到大输出

遇到这样一个问题: 一个数组长度为n, 求出其最小的k个元素并从小到大输出

想到三种解决方法:

1. 最简单的, 给数组排个序, 然后把前面k个元素输出, OK.

优点是简单明了. 缺点是做了很多额外的工作: k个元素后面的没有必要.

2. 比上面好一些, 就是使用一个堆, 或者排序树. 首先把数组中前k个元素插入这个堆(或者排序二叉树中). 然后, 对后面所有的元素,

    a. 将这个元素插入堆或者排序二叉树中;

    b. 从这个堆或者排序二叉树中移除最大的元素.

如果是堆来实现的话,可以参考堆排序; 如果是排序树来实现的话,可以用现成的TreeSet: (注:这里有个要求,就是输入数组中的元素均不相同)

private static void solveSet(int[] data, int count) {
TreeSet set = new TreeSet();
for (int i=0; i<count; i++) {
set.add(data[i]);
}
for (int i=count+1; i<data.length; i++) {
set.add(data[i]);
set.pollLast();
}
System.out.println("By set     " + set);
}

因为堆和排序树的插入删除都比较快, 所以它的性能肯定强于整个数组排序.

我的测试结果, 用一亿条数据, 时间长度对比为

ms used for treeset 660

ms used for sort 2153

OK, 那么还有没有更快的方法? 想到了以前的,从数组中选择第k小的元素的Hoare算法.

也是类似的,从数组中选择第k小的元素, 没有必要对整个数组进行排序, 而是一个类似于快速排序的过程:

   a) 首先从数组中选择一个数m

   b) 把数组中的元素整理, 比m小的放在左边, 比m大的放在右边. 小的部分和大的部分顺序无所谓, 只要求都比m小(大)就可以;

   c) 整理之后, 如果m的位置恰好是k, 那么第k小的就是m. 直接返回m并结束.

   d) 否则, 如果m的位置 > k , 说明要查找的元素位于左边那部分. 则对左边的部分进行同样的处理;

        如果m的位置 < k , 说明要查找的元素位于右边那部分, 则对右边的部分进行同样的处理

回到最开始的问题. 有了这个思路, 那么类似的, 我们可以对数组, 找到第k小的元素. 这时上面的算法已经保证了再k左边的元素都是比k小的. 那么简单了, 对左边的元素排个序就OK了. 当然, 这比较适合要找的元素个数, 远远小于数组长度的情况(比如从一亿个元素中找到最小的10个).

首先, 找到第k小的代码如下:

class Hoare {

public static void main(String[] argu) {
int testSize = 100;
int[] t1 = new int[100];
Random r = new Random();
for (int i=0; i<testSize; i++) {
t1[i] = r.nextInt();
}
int[] s = Arrays.copyOf(t1, testSize);
Arrays.sort(s);
for (int i=0; i<testSize; i++) {
int[] d = Arrays.copyOf(t1, testSize);
int k = select(d, i, 0, testSize - 1);
boolean verified = (s[i] == k);
System.out.println(s[i] + " " + k + " " + verified);
if (!verified) {
System.err.println("ERRRRR!!!!!!");
return;
}
}
System.out.println("All verified!");

}

public static int partition(int[] list, int left, int right, int pivotIndex) {
int pivotValue = list[pivotIndex];
swap (list, pivotIndex, right);
int storeIndex = left;
for ( int i=left; i<=right; i++) {
if (list[i] < pivotValue) {
swap (list, storeIndex, i);
storeIndex = storeIndex + 1;
}
}
swap (list, right, storeIndex);
//Sysstem.out.println("partion finished:" + storeIndex);
return storeIndex;
}

private static void swap(int[] list, int pivotIndex, int right) {
int t = list[pivotIndex];
list[pivotIndex] = list[right];
list[right] = t;
}

public static int select(int[] list, int k, int left, int right) {
//select a pivot value list[pivotIndex]
while ( true ) {
int pivotIndex = (left + right) / 2;
int pivotNewIndex = partition (list, left, right, pivotIndex);
if (k == pivotNewIndex) {
return list[k];
}
if (k < pivotNewIndex) {
right = pivotNewIndex - 1;
} else {
left = pivotNewIndex + 1;
}
}
} //end func
}

使用这个算法, 找到第k小的.找到后, 肯定就可以保证前面的元素都是小于k的(但是无序), 所以还得对前面的元素再次排个序. 因为这次要排序的元素很少, 速度就快了.

private static void solveHoare(int[] data, int count) {
int k = Hoare.select(data, count, 0, data.length - 1);
int[] temp = Arrays.copyOfRange(data, 0, count);
Arrays.sort(temp);
System.out.println("Final data " + Arrays.toString(temp));
}

对比下来,对于要找的元素个数, 远远小于数组长度的情况, 这种算法是最快的,
当数组的长度是一亿的时候, 列出最小的前100个元素, 时间分别为:

ms used for treeset 9315

ms used for sort 2373

ms used for selectk 201