有道经典面试题.从一亿个数字中选出最大的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是最好的方法.