方法1：
对于这道题第一个想到的方法可能是把所有的数都排好序，然后从所有的数中取前1000个数。
但是对于亿级别的数排序可不是一件容易的事，所以这个方法肯定行不通。
方法2：
采用分治的思想，在这些数中随便选择一个数，然后以这个数为界限，把所有的数分成两堆，左边的部分都大于这个数，右边的部分都小于这个数。
如果左边的数的个数大于1000，那么便可以从左边的数进行查找，
如果左边的数的个数小于1000，那么就从右边的数中在随机选择一个数，再把数分成两堆，从剩下的数中找出（1000-上一次左边的数的个数）这么多个数字。
依次进行下去，直到找齐1000个数。
这样做的时间复杂度我们可以计算一下：
第一次排序所要用的时间为O(n),以后每次排序的时候数据量都减半，时间记为n/2，所有的时间加起来为n+n/2+n/4+...，最后所得的时间肯定小于2n
所以用这种方法的时间复杂度为n
但是空间复杂度呢？？？
因为数据量过大，我们无法将所有的数据一次性读到内存中进行排序，所以第一次排序时可能造成内存溢出的情况。
方法3：
采用二叉堆的方法，关于二叉堆，可以在我的 https://www.cnblogs.com/rao11/p/11976960.html 博客中查看代码。
因为二叉堆中的小顶堆的顶元素一定时所有元素中最小的，所以可以让这上亿个数中的前1000个组成一个小顶堆，然后用这个1000个数在内存中进行计算，那么怎么进行计算呢？
把所有的数存放到硬盘中， 从1001个数开始，每个数传入内存与小顶堆的堆顶元素进行比较，如果这个数比堆顶元素大，那么就让这个数与堆顶元素进行交换，得到新的小顶堆。
然后把新的小顶堆进行有序处理，使得它组成一个有序的小顶堆，然后依次进行手术操作，直到比较完所有的数。
这样做可以不用占用大量的内存，时间复杂度也为O(n)。
下面时代码：
package com.rao.linkList;
import java.util.Arrays;
import java.util.Random;
/**
* @author Srao
* @className TopN
* @date 2019/12/3 19:30
* @package com.rao.linkList
* @Description 查找亿级别数中的前1000个数
*/
public class TopN {
/**
* 构建小顶堆,从最后一个非叶子节点开始构建
* @param arr：要查找的数组
* @param length：要构建堆的大小，不用把全部的数组都参与构建
* @return
*/
public int[] buildHeap(int[] arr, int length){
for (int i = (length-1)/2; i>=0; i--){
upAdjust(arr, i, length);
}
return arr;
}
/**
* 下沉函数
* @param arr：要操作的数组
* @param parent：以哪个节点作为父节点
* @param length：要操作的数组的长度
* @return
*/
public int[] upAdjust(int[] arr, int parent, int length){
//先把父节点保存起来
int temp = arr[parent];
//获得子节点的下标
int child = 2*parent+1;
//如果父节点比子节点大，那么进行子节点上浮
while (child < length){
//选择左右孩子中小的那个进行比较,因为每次都要判断是用左孩子还是右孩子进行比较，所以这个判断放循环里面
if (child+1 < length && arr[child+1] < arr[child]){
child++;
}
//以根节点为中心，每次都是让根节点与子节点进行比较
if (arr[child] > temp){
break;
}else {
arr[parent] = arr[child];
parent = child;
child = parent*2+1;
}
}
//这时arr[child] > arr[parent]
arr[parent] = temp;
//返回数组
return arr;
}
/**
* 把小顶堆中堆顶的数与数组中第i个数进行交换
* @param arr：要筛选的数组
* @param i：要交换的数的下标
* @param length：小顶堆的长度
*/
public void swap(int[] arr, int i, int length){
if (arr[i] < arr[0]){
return;
}
//两数交换
int temp = arr[i];
arr[i] = arr[0];
arr[0] = temp;
//然后重新调整小顶堆
upAdjust(arr, 0, length);
}
/**
*
* @param arr：要进行筛选的数
* @param length：要查找前n个数,即小顶堆的大小
* @return
*/
public int[] findTopN(int[] arr, int length){
//先构建一个小顶堆
int[] heap = buildHeap(arr, length);
//再依次循环所有数组中的数，如果有比小顶堆堆顶大的数，就把这个数换成堆顶的数
for (int i = length; i < heap.length; i++){
swap(heap, i, length);
}
//返回小顶堆
return heap;
}
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("原数组：");
System.out.println(Arrays.toString(arr1));
topN.findTopN(arr1, 5);
System.out.println("调整后数组：");
System.out.println(Arrays.toString(arr1));
// 第二组测试
int[] arr2 = new int[1000];
for(int i=0; i<arr2.length; i++) {
arr2[i] = i + 1;
}
System.out.println("原数组：");
System.out.println(Arrays.toString(arr2));
topN.findTopN(arr2, 50);
System.out.println("调整后数组：");
System.out.println(Arrays.toString(arr2));
// 第三组测试
Random random =new Random();
int[] arr3 = new int[1000];
for(int i=0; i<arr3.length; i++) {
arr3[i] = random.nextInt();
}
System.out.println("原数组：");
System.out.println(Arrays.toString(arr3));
topN.findTopN(arr3, 50);
System.out.println("调整后数组：");
System.out.println(Arrays.toString(arr3));
}
}