29 最小的K个数

输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。

考点不是排序啊。如果输入的数据大于内存你怎么排序？

最小堆和最小堆的时间复杂度都是n*logn，但是最小堆在k个数之后添加的话需要调整堆，但是最大堆只要每次和顶端的比较就可以啦。另外最小堆不能解决数字动态增加的情况。

 

最大堆思路(todo)

1.取数组前K个元素建最大堆。

2将数组剩余元素一次与最大堆堆顶元素比较，如果比堆顶元素小，则删除堆顶元素，该元素入堆。

我们先来复习一下堆排序:

 

import java.util.Arrays;

/**
 * Created by chengxiao on 2016/12/17.
 * 堆排序demo
 */
public class HeapSort {
    public static void main(String []args){
        int []arr = {9,8,7,6,5,4,3,2,1};
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void sort(int []arr){
        //1.构建大顶堆
        for(int i=arr.length/2-1;i>=0;i--){
            //从第一个非叶子结点从下至上，从右至左调整结构
            adjustHeap(arr,i,arr.length);
        }
        //2.调整堆结构+交换堆顶元素与末尾元素
        for(int j=arr.length-1;j>0;j--){
            swap(arr,0,j);//将堆顶元素与末尾元素进行交换
            adjustHeap(arr,0,j);//重新对堆进行调整
        }

    }

    /**
     * 调整大顶堆（仅是调整过程，建立在大顶堆已构建的基础上）
     * @param arr
     * @param i
     * @param length
     */
    public static void adjustHeap(int []arr,int i,int length){
        int temp = arr[i];//先取出当前元素i
        for(int k=i*2+1;k<length;k=k*2+1){//从i结点的左子结点开始，也就是2i+1处开始
            if(k+1<length && arr[k]<arr[k+1]){//如果左子结点小于右子结点，k指向右子结点
                k++;
            }
            if(arr[k] >temp){//如果子节点大于父节点，将子节点值赋给父节点（不用进行交换）
                arr[i] = arr[k];
                i = k;
            }else{
                break;
            }
        }
        arr[i] = temp;//将temp值放到最终的位置
    }

    /**
     * 交换元素
     * @param arr
     * @param a
     * @param b
     */
    public static void swap(int []arr,int a ,int b){
        int temp=arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
}

 

/*
*基于堆排序算法，构建最大堆。时间复杂度为O(nlogk)
*如果用快速排序，时间复杂度为O(nlogn)；
*如果用冒泡排序，时间复杂度为O(n*k)
*/
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        ArrayList<Integer> list=new ArrayList<Integer>();
        //检查输入的特殊情况
        if(input==null || input.length<=0 || input.length<k){
            return list;
        }
        //构建最大堆
        for(int len=k/2-1; len>=0; len--){
            adjustMaxHeapSort(input,len,k-1);
        }
        //从第k个元素开始分别与最大堆的最大值做比较，如果比最大值小，则替换并调整堆。
        //最终堆里的就是最小的K个数。
        int tmp;
        for(int i=k; i<input.length; i++){
            if(input[i]<input[0]){
                tmp=input[0];
                input[0]=input[i];
                input[i]=tmp;
                adjustMaxHeapSort(input,0,k-1);
            }
        }
        for(int j=0; j<k; j++){
            list.add(input[j]);
        }
        return list;
    }
     
    public void adjustMaxHeapSort(int[] input, int pos, int length){
        int temp;
        int child;
        for(temp=input[pos]; 2*pos+1<=length; pos=child){
            child=2*pos+1;
            if(child<length && input[child]<input[child+1]){
                child++;
            }
            if(input[child]>temp){
                input[pos]=input[child];
            }else{
                break;
            }
        }
        input[pos]=temp;
    }
}

 

 

 

 

 

以下方法是用PriorityQueue类去实现的,也比较简洁

import java.util.*;
//用最大堆保存这k个数，每次只和堆顶比，如果比堆顶小，删除堆顶，新数入堆。
public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        ArrayList<Integer> res = new ArrayList<>();
        if (input.length < k)
            return res;
        //(n, m) -> m - n是lambda表达式，传入一个比较器，规则是大的反而小，所以得到一个大顶堆，默认的是一个小顶堆
        PriorityQueue<Integer> queue = new PriorityQueue<Integer>((n, m) -> m - n);
        for (int num : input) {
            queue.offer(num);
            if (queue.size() > k)
            queue.poll();
        }
        while (!queue.isEmpty()) 
            res.add(queue.poll());
        return res;
        }
}

下面这个方法也可以采取,用了collections.sort()方法

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        List<Integer> list = new ArrayList<Integer>();
        ArrayList<Integer> res = new ArrayList<Integer>();
        if(input.length < k || input.length==0){
            return res;
        }
        for(int i=0;i<input.length;i++){
            list.add(input[i]);
        }
        Collections.sort(list);
        for(int i = 0;i<k;i++){
            res.add(list.get(i));
        }
        return res;
    }
}

可以将整型输入数组直接从小到大排序
java.util.Arrays.sort(input);

 输入可以借鉴一下(出自https://blog.csdn.net/chainiao_zhang/article/details/77740213)

public class PopSortSolution {  
    public static void main(String[] args){  
        Scanner scanner = new Scanner(System.in);  
        System.out.println("请输入一个数组，以空格隔开：");  
        String str = scanner.nextLine();  
        System.out.println("请输入K的值：");  
        int k = scanner.nextInt();  
        scanner.close();                        //scanner使用后需要close,否则报警告。  
        String[] temp = str.split(" ");  
        int[] array = new int[temp.length];  
        for(int i = 0; i<temp.length; i++){  
            array[i] = Integer.parseInt(temp[i]);  
        }  
        Solution solution = new Solution();  
          
        //GetLeastNumbet_Solution函数必须声明为static才能引用  
        System.out.println("最小" + k +"个数是：" +solution.GetLeastNumbers_Solution(array, k));  
    }