Topk/k-th1.找到数组中最小的k个数

找到数组中前k个小的数

第一想法是排序，排序之后返回前k个，这种做法的复杂度为O（nlogn）

1.partition

利用第k个数字来partition，首先将比这个数字小的数字放到左边，把大于它的数字放到右边，则现在看左边有几个数字，如果大于k，则再次partition，如果小于k，则也partition，循环直到i为k-1.
此时的前k个数就是最小的k个数。
借用的思想就是快排的思想，只不过这个要partition的结束条件不是lo<hi，而是返回的mid等于k。时间复杂度为O（n）

import java.util.Arrays;
class Solution {
    public int[] getLeastNumbers(int[] nums, int k) {
        if(nums==null || nums.length==0 || k==0){
            return new int[0];
        }
        return quickSerch(nums,0,nums.length-1,k-1);
    }
    public int[] quickSerch(int[] nums,int lo,int hi,int k){
        int s=partition(nums,lo,hi);
        if(s==k){
            return Arrays.copyOf(nums,k+1);
        }else if(s>k){//说明左边的值大于k
            return quickSerch(nums,lo,s-1,k);
        }else{
            return quickSerch(nums,s+1,hi,k);
        }
    }
    public int partition(int[] nums,int lo,int hi){
        int mid=hi;
        int cur=lo;
        while(cur<mid){
            if(nums[cur]<nums[hi]){
                cur++;
            }else{
                swap(nums,cur,--mid);
            }
        }
        swap(nums,hi,mid);
        return mid;
    }
    public void swap(int[] nums,int i,int j){
        int temp=nums[i];
        nums[i]=nums[j];
        nums[j]=temp;
    }
}

2.创造大小为k的堆，堆排序

创建堆的时间复杂度为O（nlogk）。可以自己实现一个堆，也可以利用已有的api。
需要实现的是一个大小为k的大根堆，将前k个数放入堆中，然后遍历下一个数，如果这个数比堆顶元素大，说明它肯定不是前k个数（注意这里实现的是大根堆，如果是小根堆，则这个元素没法和堆顶元素比较）
如果要自己实现，就是利用一个大小为k的数组，将前k个数放入其中，然后利用sink从倒数第二层开始到头结点下沉所有节点，构造这k个数的大根堆。遍历后面的如果有更小的数，则取出最大值，放回那个值，将它下沉。直到遍历完所有节点。

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        ArrayList<Integer> list=new ArrayList<Integer>();
        if(k<=0 || input==null || k>input.length || input.length==0){
            return list;
        }
        int[] res=new int[k];
        for(int i=0;i<k;i++){
            res[i]=input[i];
        }
        for(int i=k/2-1;i>=0;i--){
            sink(res,i);
        }
        for(int i=k;i<input.length;i++){
            if(res[0]>input[i]){
                res[0]=input[i];
                sink(res,0);
            }
        }
        for(int i=0;i<k;i++){
            list.add(res[i]);
        }
        return list;
    }
    public void sink(int[] arr,int i){//这个完全没必要放最大长度，因为这里最大值又不会变，不是堆排序需要改变最大值
        int temp=arr[i];
        for(int j=2*i+1;j<arr.length;j++){
            if(j+1<arr.length && arr[j]<arr[j+1]){
                j++;
            }
            if(arr[j]>temp){
                arr[i]=arr[j];
                i=j;
            }else{
                break;
            }
        }
        arr[i]=temp;
    }
}

import java.util.PriorityQueue;
class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        if(arr.length==0 || k==0){
            return new int[0];
        }
        PriorityQueue<Integer> pq=new PriorityQueue<Integer>((Integer o1,Integer o2)->{return o2-o1;});
        for(int i=0;i<arr.length;i++){
            if(i<k){   
                pq.offer(arr[i]);
            }else{
                if(arr[i]<pq.peek()){
                    pq.poll();
                    pq.offer(arr[i]);
                }
            }
        }
        int[] res=new int[k];
        for(int i=0;i<k;i++){
            res[i]=pq.poll();
        }
        return res;
    }
}

3.二叉搜索树

利用treemap（因为有重复的树），类似于大根堆的思想来做，同样也是O（nlogk），且可以保证前k个数都是有序的，而大根堆是无序的。
也是前k个数加入map中，加入键的是此时的数字，值是数字的频数。
当遍历到k+1个数字的时候就看它和map中最大数字的大小（treemap中最大的值就是遍历的第一个键）