【经典面试题目】--从1百万（一亿）的数据中找top100大的数

本文主要是介绍【经典面试题目】--从1百万（一亿）的数据中找top100大的数，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

概述

一种做法是我们直接进行一个堆排序，或者快排，然后打印前100个即可，但是这样子比较耗时间；
平均下来快排都在9000多ms，而堆排就更大，32s多；所以我们不能简单粗暴的直接快排或者堆排，要对其进行相对的优化；（这种做法不可取，要优化！！！）

---

下面我们看具体方法：

方法一：基于quicksort实现的原理如下

（ps:前提是快排是要懂得，不懂得可以请各位移步去看我这一篇博文：快速排序）

1. 假设数组为 array[N] (N = 1 亿)，首先利用一次quicksort的原理把array分成两个部分，左边部分比基准值大， 右边部分比基准小。 得到基准值在整个数组中的位置，假设是 k.
2. 如果 k 比 99 大，原数组变成了 array [0, ...  k - 1]， 然后在数组里找前 100 最大值。 （继续递归）
3. 如果 k 比 99 小， 原数组变成了 array [k + 1, ..., N ]， 然后在数组里找前 100 - (k + 1) 最大值。（继续递归）
4. 如果 k == 99, 那么数组的前 100 个值一定是最大的。（退出）

代码部分：

//找出一亿数据里面的前100个  快排思路
//先进行一次快排  找到基准值排序后的位置 start，使得左边数全部大于它，右边数全部小于它
//然后对比 start与99的大小 因为数组从0开始的所以对比99
//  start>99的话，就从arr[0,start-1] 中找前100个最大的、
//  start<99的话，就从arr[start+1,end] 中找前100-(start+1)个最大的
//  start==99的话，那么数组的前 100 个值一定是最大的 (不用排序直接返回 因为只是要前100最大的，没有要求说对这100个数再进行排序)
public class FastTake100 {public static void quickSort(int[] arr, int left, int right, int k) {//1.一次快排找出基准值最后的位置:startif (left >= right) {return;}int start = left;int end = right;int num = arr[left];//以最左边为基准值while (start < end) {while (start < end && num >= arr[end]) {end--;}while (start < end && num <= arr[start]) {start++;}if (start < end) {int temp = arr[start];arr[start] = arr[end];arr[end] = temp;}}arr[left] = arr[start];arr[start] = num;//2.进行判断 然后继续递归if (start < k - 1) {//start<99的话，就从arr[start+1,right] 中找前100-(start+1)个最大的quickSort(arr, start + 1, right, k - start - 1);} else if (start > k - 1) {//start>99的话，就从arr[0,start-1] 中找前100个最大的quickSort(arr, 0, start - 1, k);} else {//start==99的话，那么数组的前 100 个值一定是最大的 直接返回即可return;}}public static void main(String[] args) {int[] arr = new int[100000000];for (int i = 0; i < arr.length; i++) {arr[i] = (int) (Math.random() * 100000000);}int k = 100;//开始时间long one = System.currentTimeMillis();quickSort(arr, 0, arr.length - 1, k);//结束时间long two = System.currentTimeMillis();//打印耗时System.out.println(two - one);//打印top100for (int i = 0; i < 100; i++) {System.out.println(arr[i]);}}
}

总结： 基于quicksort原理的方法运行时间不稳定（每次运行时间相差大）；不管是固定中枢轴，还是中枢轴采用三数取中法，每次运行时间差距都挺大，30ms-1000ms不等。

---

方法二：minHeap（小顶堆实现）

最大堆 max-heap（大顶堆）：每个节点的键值（key）都大于或等于其子节点键值
最小堆 min-heap（小顶堆）：每个节点的键值（key）都小于或等于其子节点键值

# 当前节点 i：1.则其父节点： i/2 （因为/默认就是向下取整）或者(i-1) /2；2.两个孩子节点：2i+1;  2i+2;

有些小伙伴可能想到，既然是找top100，为什么不是用大顶堆来实现，而是用小顶堆呢？
在写之前，我也有这样的想法，带着疑惑我们来看下面的分析：
（ps:前提是堆排序是要懂得，不懂得可以请各位移步去看我这一篇博文：堆排序实现）

知道堆排序的具体步骤以及相应的代码已经看懂，会自己写出来后，我们来看看本题的分析：

1. 先new一个100大小的数组 value[100]；
2. 然后我们直接把原始数组arr的前100个数初始化给value；（看清楚哦，前100个数是指：是0-99的下标的值，这里不对arr进行堆排序）；
3. 把value数组，进行小顶堆化，这样堆顶的元素value[0]就是最小的；
4. 核心：我们 设 i 从k开始，到arr的长度结束；每次比较value[0]与arr[i]的的大小，只要arr[i] > value[0] ，我们就把arr[i] 赋值给value[0]，此时堆顶元素就是一个比较大的元素，然后我们重新进行一次heapify（小顶堆化），再把堆顶置于最小，继续与arr[i]比较，重复上述过程直到遍历完整个arr数组；（每次都会把最小的元素替换掉）
5. 遍历完以后，我们的value数组里存的就是 top100大的数字了；
6. 打印value数组，就可以看到结果；

下面看代码：

import java.util.Random;
找出一亿数据里面的前100个  堆排思路 利用minHeap 小顶堆
public class HeapTake100 {public static int[] heapSort(int[] arr) {//new 一个数组存储top100的元素int[] value=new int[100];//初始化value数组for (int i = 0; i < 100; i++) {value[i]=arr[i];}//把value数组构建成小顶堆buildHeap(value);for (int i = 100; i <arr.length ; i++) {//若满足条件就赋值if (value[0]<arr[i]){value[0]=arr[i];//重新小顶堆化heapify(value,0,value.length);}}return value;}//从第一个非叶子节点开始 往上遍历建立堆public static void buildHeap(int[] arr) {//数组的长度/2 - 1 就是：第一个非零节点的位置int n=arr.length;for (int i = n / 2 - 1; i >= 0; i--) {heapify(arr, i, n);}}//heapify 真正用来调整堆的方法public static void heapify(int[] arr, int i, int len) {int left = 2 * i + 1;int right = 2 * i + 2;int max = i;if (left < len && arr[left] < arr[max]) {max = left;}if (right < len && arr[right] < arr[max]) {max = right;}if (max != i) {swap(arr, max, i);heapify(arr, max, len);}}//堆排序用来交换的方法public static void swap(int[] arr, int i, int j) {int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}//执行的主函数public static void main(String[] args) {int[] arr = new int[100000000];for (int i = 0; i < arr.length; i++) {arr[i] = (int) (Math.random() * 100000000);}//计算消耗时间long t1=System.currentTimeMillis();int[] value=heapSort(arr);long t2=System.currentTimeMillis();System.out.println(t2-t1);//打印结果数组for (int i : value) {System.out.println(i);}}
}

问题

---

那么又有人问了：为什么不用大顶堆？

假如使用大顶堆，当value[0] < arr[i] 时候，我们替换，会发现value[0] 始终是整个堆里最大的，这样子操作，只是每次把value[0] 换了一个最大的，也就是最后只找到 top1大的元素；

-------当然实践出真知，各位可以自己去动手尝试一下写，然后看看要是改成大顶堆，每次用大顶堆最后一个元素进行比较交换，看看会会出现什么样的结果。

总结：

基于最小堆方法运行时间很稳定（每次运行时间相差很小 基本都是52ms左右）；

这篇关于【经典面试题目】--从1百万（一亿）的数据中找top100大的数的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---