从一亿个数字中选出最大的100个

2019独角兽企业重金招聘Python工程师标准>>>

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

转载于:https://my.oschina.net/somereasons/blog/1601992