10亿数据中取最大的100个数据

思路1：利用堆排序实现
（1）取前m个元素（例如m=100），建立一个小顶堆。保持一个小顶堆得性质的步骤，运行时间为O（lgm);建立一个小顶堆运行时间为m*O（lgm）=O(m lgm);
（2）顺序读取后续元素，直到结束。每次读取一个元素，如果该元素比堆顶元素小，直接丢弃。如果大于堆顶元素，则用该元素替换堆顶元素，然后保持最小堆性质。最坏情况是每次都需要替换掉堆顶的最小元素，因此需要维护堆的代价为(N-m)*O(lgm);最后这个堆中的元素就是10亿个数据中最大的100个。时间复杂度为O(N lgm）。

public class HeapSelect {

    public static void main(String[] args) {

        // 假设数组arrs中存储10亿个数字，（这里用100个数代替）
        int[] arrs = new int[100];
        for (int i = 0; i < arrs.length; i++) {
            arrs[i] = (int) (Math.random() * 1000);
        }

        // 先取出10个数字，构建最小堆
        int[] arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = arrs[i];
        }

        HeapSelect heapSelect = new HeapSelect();
        heapSelect.heapSort(arr, arr.length - 1);

        for (int i = 10; i < arrs.length; i++) {
            if (arrs[i] > arr[0]) {
                arr[0] = arrs[i];
                heapSelect.heapSort(arr, arr.length - 1);
            }
        }
    }

    public void heapSort(int[] arrays, int e) {
        if (e > 0) {
            initSort(arrays, e);// 初始化堆，找出最大的放在堆顶
            // snp(arrays);
            arrays[0] = arrays[e] + arrays[0];
            arrays[e] = arrays[0] - arrays[e];
            arrays[0] = arrays[0] - arrays[e];
            // snp(arrays);
            heapSort(arrays, e - 1);
        } else {
            // snp(arrays);
        }
    }

    public void initSort(int[] arrays, int e) {
        int m = (e + 1) / 2;
        for (int i = 0; i < m; i++) {
            boolean flag = buildHeap(arrays, e, i);
            // 如果孩子之间有交换，就要重新开始
            if (flag) {
                i = -1;
            }
        }
    }

    // 返回一个标记，如果有根与孩子交换就要重新从顶根开始查找不满足最大堆树结构
    public boolean buildHeap(int arrays[], int e, int i) {
        int l_child = 2 * i + 1;// 左孩子
        int r_child = 2 * i + 2;// 右孩子
        if (r_child > e) { // 判断是否有右孩子，没有右孩子的话直接比较左孩子，小于左孩子则交换
            if (arrays[i] < arrays[l_child]) {
                arrays[i] = arrays[i] + arrays[l_child];
                arrays[l_child] = arrays[i] - arrays[l_child];
                arrays[i] = arrays[i] - arrays[l_child];
                return true;
            } else {
                return false;
            }
        }
        // 在根与两个孩子之间找出最大的那个值进行交换
        if (arrays[i] < arrays[l_child]) {
            if (arrays[l_child] > arrays[r_child]) {
                // 交换根与左孩子的值
                arrays[i] = arrays[i] + arrays[l_child];
                arrays[l_child] = arrays[i] - arrays[l_child];
                arrays[i] = arrays[i] - arrays[l_child];
                return true;
            } else {
                // 交换根与右孩子的值
                arrays[i] = arrays[i] + arrays[r_child];
                arrays[r_child] = arrays[i] - arrays[r_child];
                arrays[i] = arrays[i] - arrays[r_child];
                return true;
            }
        } else if (arrays[i] < arrays[r_child]) {
            // 交换根与右孩子的值
            arrays[i] = arrays[i] + arrays[r_child];
            arrays[r_child] = arrays[i] - arrays[r_child];
            arrays[i] = arrays[i] - arrays[r_child];
            return true;
        }
        return false;
    }// buildHeap

}

思路2：根据快速排序划分的思想
（1）递归对所有数据分成[a,b）b（b,d]两个区间，(b,d]区间内的数都是大于[a,b)区间内的数
（2）对(b,d]重复(1)操作，直到最右边的区间个数小于100个。注意[a,b)区间不用划分
（3）返回上一个区间，并返回此区间的数字数目。接着方法仍然是对上一区间的左边进行划分，分为[a2,b2）b2（b2,d2]两个区间，取（b2,d2]区间。如果个数不够，继续(3)操作，如果个数超过100的就重复1操作，直到最后右边只有100个数为止。

基于该思想，下面的例子中我们将尝试在100个数里面找出10个最大的数

public class QuickSelect {

    public static void main(String[] args) {
        int[] array = new int[100];
        for (int i = 0; i < array.length; i++) {
            array[i] = (int) (Math.random() * 1000);
        }

        quickSort(array, 0, array.length - 1);

        for (int i = array.length-10; i < array.length; i++) {// 数组后10位数既是最大的10位数
            System.out.print(array[i] + " ");
        }
    }

    private static int len = 10;
    /**
     * 多次调用快排，将数组中最大的10位数移动至最右边。
     * 
     * @param array
     * @param left
     * @param right
     */
    public static void quickSort(int[] array, int left, int right) {
        int pivot;
        if (left < right) {
            pivot = partition(array, left, right);//取出枢轴

            if (right - pivot + 1 > len) {//如果pivot右边的数大于10个，再次重复操作（1）
                quickSort(array, pivot + 1, right);
            } else if (right - pivot + 1 < len) {//pivot右边的数小于10个，执行操作（2）
                len = len - (right - pivot + 1);
                quickSort(array, left, pivot - 1);
            }

            // 对左右数组递归调用快速排序，直到顺序完全正确
        }
    }

    /**
     * pivotValue作为枢轴，较之小的元素排序后在其左，较之大的元素排序后在其右
     * 
     * @param array
     * @param left
     * @param right
     * @return
     */
    public static int partition(int[] array, int left, int right) {
        int pivot = array[left];
        while (left < right) {
            while (left < right && array[right] >= pivot) {
                --right;
            }
            // 将比枢轴小的元素移到低端，此时right位相当于空，等待低位比pivot大的数补上
            array[left] = array[right];
            while (left < right && array[left] <= pivot) {
                ++left;
            }
            // 将比枢轴大的元素移到高端，此时left位相当于空，等待高位比pivot小的数补上
            array[right] = array[left];
        }
        // 当left == right，完成一趟快速排序，此时left位相当于空，等待pivotkey补上
        array[left] = pivot;

        return left;
    }
}

思路3：分块查找
先把10亿个数分成100份，每份1000w个数，然后在1000w个数中分别找出最大的100个数，最后在100*100个数中找出最大的100个。这里我想可以用分布式的处理，多台主机才会更快。