剑指Offer——数组的最小的前K个数

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

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        /*
        思路1：将数组排序，然后取前K个数，时间复杂度为O（nlogn）
        思路2：受快速排序的启发，如果当地K个数的左边全部小于他，右边全部大于他，那么前K个数就是
              最小的K个数，时间复杂度为o（n），缺点是会改变数组本身
        思路3：利用大小为K的最大堆，把数组中的数字逐个放进去，当要放进去的元素小于最大堆的堆顶元素
              时，将堆顶元素弹出，放入当前元素，这样最后留在最大堆中的元素就是最小的K个数，时间
              复杂度为O（nlogK），有点是不用改变数组本身，时间复杂度低，空间复杂度为O（1），适合
              处理海量数据
        */
        //思路2实现
        ArrayList<Integer> aList = new ArrayList<Integer>();
        if(input == null || k>input.length){
            return aList;
        }
        int index = partition(input,0,input.length-1);
        while(index != k-1){
            if(index > k-1){
                index = partition(input,0,index-1);
            }
            else if(index<k-1){
                index = partition(input,index+1,input.length-1);
            }
        }
        for(int i = 0;i<=index;i++){
            aList.add(input[i]);
        }
        return aList;
    }
    public int partition(int[] arr,int begin,int end){
        if(arr == null || begin>end){
            return -1;
        }
        int small = begin-1;
        for(int index = begin; index<end;index++){
            if(arr[index]<arr[end]){
                small++;
                if(small != index){
                    swap(arr,index,small);
                }
            }
        }
        small++;
        swap(arr,small,end);
        return small;
    }
    public void swap(int[] arr,int i ,int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

import java.util.ArrayList;
import java.util.Comparator;
import java.util.PriorityQueue;
public class FirstKthNum {
        //思路3实现
        public static ArrayList<Integer> getFirstKthNum(int[] input,int k){
        ArrayList<Integer> aList = new ArrayList<>();
        if(input == null ||k<1){
            return  aList;
        }
        //用PriorityQueue来作为堆的实现
        PriorityQueue<Integer> pQueue = new PriorityQueue<>(k, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });
        for(int i = 0; i<input.length;i++){
            if(pQueue.size()<k){
                pQueue.add(input[i]);
            }
            else{
                int curMax = pQueue.peek();
                if(input[i] < pQueue.peek()){
                    pQueue.poll();
                    pQueue.add(input[i]);
                }

            }
        }

        for(Integer i:pQueue){
            aList.add(i);
        }
        return  aList;
    }
    public static void main(String args[]){
        //int[] pop = {1,2,3,4,5};
        int[] a = {4,3,5,1,2};
        ArrayList<Integer> al = getFirstKthNum(a,0);
        for (Integer s:al
                ) {
            System.out.println(s);
        }
        System.out.print(al.size());

    }

}