C语言三个数曲最大,从一亿个数字中选出最大的100个

有道经典面试题.从一亿个数字中选出最大的100个.

实现的方法很多,这里都讨论一下.

首先想到的使用排序的方法,排序方法很多,为了避免对所有元素排序造成浪费,这里选用每次取出最大元素的排序方法.

1. 最简单的,起泡法

借用起泡排序的手法.起泡排序,目的是遍历N次数组,每一次都把最大的元素挪到后面.可想而知,如果遍历100次数组,那么数组最后的100个元素就是TOP100

时间复杂度:遍历100次,当然是100N.

public void getMaxN_bubble(int[] arr) {

for (int i = 0; i < TopNum; i++) {

for (int j = 1; j < arr.length - i; j++) {

if (arr[j - 1] > arr[j])

swap(arr, j - 1, j);

}

}

}

实际测试: 随机数:25000ms,顺序数组(理论最好情况)6497ms,逆序数组(理论最坏情况)11956ms

这个测试结果很出乎我意料,理论上,在起泡排序时,逆序数组在每次遍历时每个元素都要调整,应该是最慢的.然而随机数最慢.不知道是不是jvm做了优化.

2. 堆排序

另一种通过取出最大元素来排序的方法是堆排序.堆排序分为两步,第一步是建堆,所需时间为N/2 * logN, 然后,取100次堆顶,并调整堆.所需时间为100*logN,

public void getMaxN_heap(int[] arr) {

buildHeap(arr);

for (int i = 1; i <= TopNum; i++) {

swap(arr, arr.length - i, 0);

int downNode = adjustHeapNode(arr, 1, arr.length - i);

while (downNode > 0)

downNode = adjustHeapNode(arr, downNode, arr.length - i);

}

int[] topNums = new int[TopNum];

for (int i = 0; i < TopNum; i++) {

topNums[i] = arr[arr.length - 1 - i];

}

}

public void buildHeap(int[] arr) {

int currentPos = arr.length >> 1;

while (currentPos > 0) {

int downNode = adjustHeapNode(arr, currentPos, arr.length);

while (downNode > 0)

downNode = adjustHeapNode(arr, downNode, arr.length);

currentPos--;

}

}

/**

* 选出父子中最小的那个,并交换到父节点

*

* @param arr 作为堆的数组

* @param nodePos 节点位置

* @param length 有效的堆的长度

* @return 如果发生了交换, 下沉节点的位置.如果没有交换, 返回-1

*/

public int adjustHeapNode(int[] arr, int nodePos, int length) {

int maxChildPos;//左右子中大的那个

if ((nodePos << 1) > length)//没有左子

return -1;

else if ((nodePos << 1) <= length && (nodePos << 1) + 1 > length)//只有左子

maxChildPos = (nodePos << 1);

else//有左右子

maxChildPos = arr[(nodePos << 1) - 1] > arr[(nodePos << 1)] ? (nodePos << 1) : (nodePos << 1) + 1;

if (arr[nodePos - 1] < arr[maxChildPos - 1]) {

swap(arr, nodePos - 1, maxChildPos - 1);

return maxChildPos;

}

return -1;

}

实际测试:随机数:1000ms,顺序数组(最坏情况)1900ms,逆序数组(最好情况)140ms

这个成绩比冒泡快不少.成绩也符合预期.

3. 维护Top100有序数组

除了这两种,还有一种方法是遍历一次数组,并维护一个Top100的有序数组,遍历的时候,如果发现arr[i]比top100数组中最小的那个元素还大,说明在已经遍历的数据中,arr[i]是top100当中的一员,所以把arr[i]插入top100中,并删掉最小的那个.

arr[i]插入top100的时候,也要保证top100仍然是有序的.因此,怎么把arr[i]插入到top100就需要使用一些技巧,遍历top100查找对应位置是可以的.但更有效率的方式是使用折半查找,可以将插入的时间复杂度从N减少到logN.

这样总体的复杂度就是N*(100/2*log100),其中log100是查找元素的代价.100/2是移动top100元素的代价.

public void getMaxN_HalfFind(int[] arr) {

int[] top100 = new int[TopNum];

for (int i = 0; i < TopNum; i++) {

top100[i] = arr[i];

}

//排序(从小到大)

Sort.qsort(top100, 0, top100.length - 1);

for (int i = TopNum; i < arr.length; i++) {

if (arr[i] < top100[0])

continue;

else if (arr[i] > top100[TopNum - 1])

insertAndRemoveFirst(top100, TopNum - 1, arr[i]);

else {

int start = 0, end = TopNum - 1;

while (true) {

int halfIndex = (start + end) / 2;

if (top100[halfIndex] == arr[i]) {

insertAndRemoveFirst(top100, halfIndex, arr[i]);

break;

} else if (end - start <= 1) {

insertAndRemoveFirst(top100, start, arr[i]);

break;

} else if (top100[halfIndex] > arr[i]) {

end = halfIndex;

} else if (top100[halfIndex] < arr[i]) {

start = halfIndex;

}

}

}

}

}

private void insertAndRemoveFirst(int[] arr, int index, int value) {

for (int i = 0; i < index; i++) {

arr[i] = arr[i + 1];

}

arr[index] = value;

}

实测性能:随机数:110ms,顺序数组(最坏情况)5077ms,逆序数组(最好情况)100ms

这个时间比堆排序还要快,可是理论值算出的时间可是比堆排序要慢几倍的.我对此理解为,在随机数的情况下,top100中很快装入了大的数字,虽然不是top100,但也成功的排除了很多数.

在源数组顺序排序(最坏情况)时,每遍历一个数字,都要对top100数组产生插入和移动,此时效率就不行了.用时要长于堆排序

总结:

数据随机的情况下,3是最快的方法.而且,3不需要把整个数组加载到内存中就可以执行.适合数据量更大(比如10亿)的情况下进行排序.可以加载一点,计算一点.因此,我觉得3是最好的方法.