剑指offer——最小的k个数

题目描述

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

最容易想到的方法是排序，然后找出前k个数，但这种思路明显是不可能是面试官想要的。

解法1：

利用快速排序种partition思路，partition方法可以让数组分为三部分，小于某个数的部分，等于某个数的部分，大于某个数的部分（下面代码中等于和大于这个数做了同样的处理）。如果此时这个数的下标是k，那么正好这个数的左边就是题目要求的数字（即使等于这个数的数字有多个，在本题种也不影响，因为这为只要这个数的下标是k，就满足题意），如果这个数的下标大于k，那么就在这个数的左边继续partition,如果这个数的下标小于k，那么就在这个数的右边继续partition，直到满足题意。这个思路还可以解决第k大（第k小）的数这种问题，因为如果一个数下标为k，左边都是小于它的，右边都是大于等于它的，那么这个数就是第k大的。时间复杂度O（n)，但是会改变数组数字顺序。

import java.util.ArrayList;
import java.util.Random;
import java.util.Arrays;
public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        ArrayList<Integer> res = new ArrayList<>();
        if(input.length==0 || input== null || k>input.length || k==0){
            return res;
        }
        //当数组长度与k相等时，调用下面的方法，可能会出现数组越界的情况，但k小于数组长度时不会
        //因为此时，当index=lengt-1时，k一定小于等于index,等于index退出循环，小于index，会
        //执行partition(input,0,index-1)，所以一定不会越界。
        if(input.length == k){
            for(int i:input){
                res.add(i);
            }
            return res;
        }
        int index = partition(input,0,input.length-1);
        while(k != index){
            if(k>index){
                index = partition(input,index+1,input.length-1);
            }else{
                index = partition(input,0,index-1);
            }
        }
        for(int i=0;i<index;i++){
            res.add(input[i]);
        }
        return res;
    }
    public int partition(int[] array,int start,int end){
        //Random.nextInt()方法参数必须大于0，start有可能等于end，处理这种特殊情况
        int randInt = start>=end?start:start+new Random().nextInt(end-start);
        int temp = array[randInt];
        int less = start-1;
        swap(array,randInt,end);
       for(int i=start;i<end;i++){
           if(array[i]<temp){
               swap(array,++less,i);
           }
       }
       swap(array,++less,end);
       return less;
    }
    public void swap(int[] array,int i,int j){
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

解法2  用PriorityQueue实现的类大顶堆

思路来自牛客网这道题目的评论区，一位大佬写得很好，搬运一下

要找最小的k个数，可以维护一个类大顶堆，遍历数组，当堆的长度小于k时，将数字进堆，等于k后，继续遍历，如果数组中的数字小于类大顶堆对顶的元素，堆顶元素出堆，将数组中的元素入堆，PriorityQueue实现的类大顶堆会自动调整，将堆中最大的元素置于堆顶。遍历结束，堆中的数字就是要求的数字。

import java.util.ArrayList;
import java.util.PriorityQueue;
import java.util.Comparator;
public class Solution {
   public ArrayList<Integer> GetLeastNumbers_Solution(int[] input, int k) {
       ArrayList<Integer> result = new ArrayList<Integer>();
       int length = input.length;
       if(k > length || k == 0){
           return result;
       }
        //构造类大顶堆，利用匿名内部类构造Comparator对象,不传入第二个参数，默认为小顶堆
        PriorityQueue<Integer> maxHeap = new PriorityQueue<Integer>(k, new Comparator<Integer>() {
 
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2.compareTo(o1);
            }
        });
        for (int i = 0; i < length; i++) {
            if (maxHeap.size() != k) {
                maxHeap.offer(input[i]);
            } else if (maxHeap.peek() > input[i]) {
                maxHeap.poll();
                maxHeap.offer(input[i]);
            }
        }
        for (Integer integer : maxHeap) {
            result.add(integer);
        }
        return result;
    }
}