剑指offer——最小的k个数

题目描述：

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

解题思路：

• 解法1：和面试题39的思路3一样，都是基于快速排序的思想，找到一个基准元素的位置，如果基准元素正好是第k个数则结束，若在k个数后面，则在基准元素前面找，否则在后面找

• 解法2：分为3个步骤——

  1. 从n个数中选前k个数，将其构造为大顶堆
  2. 对k个数后面的数，将其和大顶堆堆顶元素进行比较，若大于堆顶元素，则放弃；否则则用该数替换堆顶元素
  3. 元素替换后继续调整堆，使其成为大顶堆
  

• 解法1和解法2的比较：

	基于Partition函数的解法	基于最大堆或者红黑树的解法
时间复杂度	O(n)	O(nlogk)
是否需要修改输入数组	是	否
是否适用于海量数据	否	是

解法1：

 public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
            ArrayList<Integer> list = new ArrayList<Integer>();
            if(input==null||input.length<=0)
                return list;
            if(k<=0||k>input.length)
                return list;
            int low = 0;
            int high = input.length-1;
            int index = Partition(input,low,high);
            while(index!=k-1){
                if(index>k-1){
                    high = index -1;
                    index = Partition(input,low,high);
                }
                else {
                    low = index + 1;
                    index = Partition(input,low,high);
                }
            }
            for(int i =0;i<k;i++)
                list.add(input[i]);
            return list;
        }
        public static int Partition(int[] a,int low,int high){
            int pivot = a[low];
            int i = low;
            while(low<high){
                while(low<high&&a[high]>=pivot)
                    high--;
                while(low<high&&a[low]<=pivot)
                    low++;
                if(low<high){
                    int temp = a[high];
                    a[high] = a[low];
                    a[low] = temp;
                }
            }
            a[i] = a[low];
            a[low] = pivot;
            return low;

        }

解法2：

public ArrayList<Integer> GetLeastNumbers_Solution(int[] nums, int k) {
    if (k > nums.length || k <= 0)
        return new ArrayList<>();
    PriorityQueue<Integer> maxHeap = new PriorityQueue<>((o1, o2) -> o2 - o1);
    for (int num : nums) {
        maxHeap.add(num);
        if (maxHeap.size() > k)
            maxHeap.poll();
    }
    ArrayList<Integer> ret = new ArrayList<>(maxHeap);
    return ret;
}

解法2: 用到了PriorityQueue数据结构来实现一个大顶堆，时间复杂度为O(nlogk)，同时因为申请了额外的空间，所以空间复杂度为O(k)。另外对于Comparator接口(o1,o2)->o1-o2代表升序，(o1,o2)->o2-o1代表降序

解法3： 没有用到额外的数据结构，而是自己实现了一个大顶堆，时间复杂度为O(nlogk)，但是和解法一类似，也会改变数组的结构，空间复杂度为O(1).同样适用于海量数据

/*自己实现一个大顶堆，来求最小的k个数
     * coded by Jerome
     */
     import java.util.ArrayList;
     public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        if(input==null||input.length<=0)
            return list;
        if(k<=0||k>input.length)
            return list;
        buildHeap(input,k);
        for(int i = k;i<input.length;i++){
            if(input[i]>=input[0])
                continue;
            else{
                swap(input,0,i);
                adjustDown(input,0,k);
                }
        }
        for(int i = 0;i<k;i++)
            list.add(input[i]);
        return list;
    }
    public void buildHeap(int[] input,int k){
            int len = k;
            for(int i = (k-1)/2;i>=0;i--)
                adjustDown(input,i,len);
        }
    public void adjustDown(int[] input,int i,int len){
            int temp = input[i];
            for(int j=2*i+1;j<len;j=2*j+1){
                if(j+1<len&&input[j]<input[j+1])
                    j++;
                if(input[j]<temp)
                    break;
                else{
                    input[i] = input[j];
                    i = j;
                }
            }
            input[i] = temp;
        }
   public void swap(int[] input,int i,int j){
           int temp = input[i];
           input[i] = input[j];
           input[j] = temp;
       }
}