面试系列 | 文件里存储了10亿条销量数据, 如何找出前1000大的数据?

题目: 我有一个文件, 里面存储了10亿个商品销量数据, 如何找出前1000大的数据?

 

分析: 

第一种最容易想到的方法是将数据全部排序，在排序后的集合中进行查找，最快的排序算法的时间复杂度一般为O（nlogn），如快速排序。但是在32位的机器上，每个float类型占4个字节，10亿个浮点数就要占用400MB的存储空间，对于一些可用内存小于400M的计算机而言，很显然是不能一次将全部数据读入内存进行排序的。显然该方法并不高效，因为题目的目的是寻找出最大的10000个数即可，而排序却是将所有的元素都排序了，做了很多的无用功。

 

第二种方法为局部淘汰法，该方法与排序方法类似，用一个容器保存前10000个数，然后将剩余的所有数字——与容器内的最小数字相比，如果所有后续的元素都比容器内的10000个数还小，那么容器内这个10000个数就是最大10000个数。如果某一后续元素比容器内最小数字大，则删掉容器内最小元素，并将该元素插入容器，最后遍历完这10亿个数，得到的结果容器中保存的数即为最终结果了。此时的时间复杂度为O（n+m^2），其中m为容器的大小，即10000。

 

第三种方法是分治法，将10亿个数据分成100份，每份100万个数据，找到每份数据中最大的10000个，最后在剩下的100份数据里面找出最大的10000个。如果100万数据选择足够理想，那么可以过滤掉10亿数据里面99%的数据。100万个数据里面查找最大的10000个数据的方法如下：用快速排序的方法，将数据分为2堆，如果大的那堆个数N大于10000个，继续对大堆快速排序一次分成2堆，如果大的那堆个数N大于10000个，继续对大堆快速排序一次分成2堆，如果大堆个数N小于10000个，就在小的那堆里面快速排序一次，找第10000-n大的数字；递归以上过程，就可以找到第1w大的数。参考上面的找出第1w大数字，就可以类似的方法找到前10000大数字了。此种方法需要每次的内存空间为10^64=4MB，一共需要101次这样的比较。

 

第四种方法是Hash法。如果这10亿个书里面有很多重复的数，先通过Hash法，把这10亿个数字去重复，这样如果重复率很高的话，会减少很大的内存用量，从而缩小运算空间，然后通过分治法或最小堆法查找最大的10000个数。

 

第五种方法采用最小堆。首先读入前10000个数来创建大小为10000的最小堆，建堆的时间复杂度为O（mlogm）（m为数组的大小即为10000），然后遍历后续的数字，并于堆顶（最小）数字进行比较。如果比最小的数小，则继续读取后续数字；如果比堆顶数字大，则替换堆顶元素并重新调整堆为最小堆。整个过程直至10亿个数全部遍历完为止。然后按照中序遍历的方式输出当前堆中的所有10000个数字。该算法的时间复杂度为O（nmlogm），空间复杂度是10000（常数）。

 

实际运行： 实际上，最优的解决方案应该是最符合实际设计需求的方案，在时间应用中，可能有足够大的内存，那么直接将数据扔到内存中一次性处理即可，也可能机器有多个核，这样可以采用多线程处理整个数据集。

 

最小堆找出Top N数据

这种情况下, 可以用堆来做, 我在内存中维护一个1000数的小顶堆, 根据堆的性质, 每一个节点都比它的左右子节点要小

[56, 30, 71, 18, 29, 93, 44, 75, 20, 65, 68, 34]

-----------------------

        18

       /  \

      29   71 ← 93, 44, 75, 20, 65, 68, 34

     /  \

    56   30

先取前N个数, 构成小顶堆

然后再从文件中读取数据, 并且和堆顶比较大小, 如果比堆顶还小, 直接丢弃

如果比堆顶大, 就替换堆顶, 并调整最小堆

 

93比堆顶的18大, 将18替换下来

        93

        /  \

      29   71 ← 18, 44, 75, 20, 65, 68, 34

      /  \

    56   30

 

然后对小顶堆进行调整, 保持小顶堆的性质(29和93换位置, 然后30和93换位置)

 

        29

        /  \

      30   71 ← 18, 44, 75, 20, 65, 68, 34

     /  \       -------

    56   93

 

        30

        /  \

      44  71 ← 18, 29, 75, 20, 65, 68, 34

      /  \      ----------

    56   93

 

        44

        /  \

      56  71 ← 18, 29, 30, 20, 65, 68, 34

      /  \      --------------

    75   93

        .

        .

        .

        65

        /  \

      68  71 ← 18, 29, 30, 20, 44, 56, 34

      /  \      -----------------------------

    75   93

 

所有数据都处理完毕后, 小顶堆内就是topN

这样的话, 数据只需要读取一次, 不会存在数据多次读写问题

 

下面是参考代码:

package com.neeyoo.normal;​import java.util.Random;​/** * Created by NeeYoo. * Created on 2019/12/26. * Description: */public class TopN {​    // 一般都用数组来表示堆，n结点的父结点下标就为(n – 1) / 2。它的左右子结点下标分别为2 * n + 1 和 2 * n + 2。    private int parent(int n) {        return (n - 1) / 2; // 父节点    }​    private int left(int n) {        return 2 * n + 1; // 左孩子    }​    private int right(int n) {        return 2 * n + 2; // 右孩子    }​    // 构建堆    private void buildHeap(int n, int[] data) {        for (int i = 1; i < n; i++) {            int t = i;            // 调整堆            while (t != 0 && data[parent(t)] > data[t]) {                int temp = data[t];                data[t] = data[parent(t)];                data[parent(t)] = temp;                t = parent(t);            }        }    }​    // 调整data[i]    private void adjust(int i, int n, int[] data) {        if (data[i] <= data[0]) {            return;        }        // 置换堆顶        int temp = data[i];        data[i] = data[0];        data[0] = temp;        // 调整堆顶        int t = 0;        while ((left(t) < n && data[t] > data[left(t)])                || (right(t) < n && data[t] > data[right(t)])) {            if (right(t) < n && data[right(t)] < data[left(t)]) {                // 右孩子更小，置换右孩子                temp = data[t];                data[t] = data[right(t)];                data[right(t)] = temp;                t = right(t);            } else {                // 否则置换左孩子                temp = data[t];                data[t] = data[left(t)];                data[left(t)] = temp;                t = left(t);            }        }    }​    // 寻找topN，该方法改变data，将topN排到最前面    public void findTopN(int n, int[] data) {        // 先构建n个数的小顶堆        buildHeap(n, data);        System.out.println("-------------------构建完成,开始调整----------------------");        // n往后的数进行调整        for (int i = n; i < data.length; i++) {            adjust(i, n, data);        }    }​    // 打印数组    public void print(int[] data) {        for (int i = 0; i < data.length; i++) {            System.out.print(data[i] + " ");        }        System.out.println();    }​​    public static void main(String[] args) {        TopN topN = new TopN();​        // 第一组测试        int[] arr1 = new int[]{56, 30, 71, 18, 29, 93, 44, 75, 20, 65, 68, 34};        System.out.println("原数组：");        topN.print(arr1);        topN.findTopN(5, arr1);        System.out.println("调整后数组：");        topN.print(arr1);​        // 第二组测试        int[] arr2 = new int[1000];        for (int i = 0; i < arr2.length; i++) {            arr2[i] = i + 1;        }        System.out.println("原数组：");        topN.print(arr2);        topN.findTopN(50, arr2);        System.out.println("调整后数组：");        topN.print(arr2);​        // 第三组测试        Random random = new Random();        int[] arr3 = new int[1000000];        for (int i = 0; i < arr3.length; i++) {            arr3[i] = random.nextInt();        }        System.out.println("原数组：");        topN.print(arr3);        long startTime = System.currentTimeMillis();        topN.findTopN(50, arr3); // 1亿数据99ms, 1千万数据17ms, 1百万数据8ms        System.out.println("耗时: " + (System.currentTimeMillis() - startTime) + "毫秒");        System.out.println("调整后数组：");        topN.print(arr3);    }}​