剑指offer-面试题40：最小的k个数

题目描述

输入整数数组 arr ，找出其中最小的 k 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。
示例 1：
输入：arr = [3,2,1], k = 2
输出：[1,2] 或者 [2,1]
示例 2：
输入：arr = [0,1,2,1], k = 1
输出：[0]
限制：
0 <= k <= arr.length <= 10000
0 <= arr[i] <= 10000

方法一（直接排序）

1.解题思路

调用排序接口，然后取前k个数

2.代码实现

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        Arrays.sort(arr);
        int[] res=new int[k];
        for(int i=0;i<k;i++){
            res[i]=arr[i];
        }
        return res;
    }
}

3.复杂度分析

• 时间复杂度：调用了排序接口，所以时间复杂度为O(n*logn)
• 空间复杂度：空间复杂度为O(logn)

方法二（自建大顶堆）

1.解题思路

首先将arr数组前k个元素赋值给res数组，然后基于res数组构建一个大小为k的大顶堆。然后在arr数组第k个到最后一个元素之间循环，如果当前元素小于堆顶元素，则将堆顶元素替换为当前元素，并且重建大顶堆。

2.代码实现

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        if(arr==null||arr.length==0||k==0) return new int[0];
        int[] res=new int[k];
        for(int i=0;i<k;i++){
            res[i]=arr[i];
        }
        //自建大小为k的大顶堆
        for(int i=k/2-1;i>=0;i--){
            adjust(res,i,k-1);
        }
        //每次都与堆顶元素比较
        for(int i=k;i<arr.length;i++){       
            if(res[0]>arr[i]){
                res[0]=arr[i];
                adjust(res,0,k-1);
            }
        }
        return res;
    }
    private void adjust(int[] arr,int s,int m){
        int temp=arr[s],j;
        for(j=2*s+1;j<=m;j=j*2+1){
            if(j<m&&arr[j]<arr[j+1]){
                j++;
            }
            if(temp>=arr[j]) break;
            arr[s]=arr[j];
            s=j;
        }
        arr[s]=temp;
    }
}

3.复杂度分析

• 时间复杂度：大顶堆插入删除元素的时间复杂度均为O(logk)，最坏情况下需要处理n个元素，所以时间复杂度为O(n*logk)
• 空间复杂度：因为需要构建大小为k的大顶堆来存储元素值，所以空间复杂度为O(logk)

方法三（快排思想）

1.解题思路

主要想法是利用快排的partition函数找到刚好为k-1的切分点。如果切分点小于k-1，则往后继续找；如果大于k-1，则往前继续找。找到之后，切分点之前的数都可以切分点对应的值，之后的数都大于切分点对应的值，所以直接取前k个数，则是最小的k个数。

2.代码实现

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        if(arr==null||arr.length==0||k==0) return new int[0];
        int low=0;
        int high=arr.length-1;
        int index=partition(arr,low,high);
        while(index!=k-1){          
            if(index<k-1){
                low=index+1;
                index=partition(arr,low,high);
            }
            else if(index>k-1){
                high=index-1;
                index=partition(arr,low,high);
            }
        }
        int[] res=new int[k];
        for(int i=0;i<k;i++){
            res[i]=arr[i];
        }
        return res;
    }
    private int partition(int[] arr,int low,int high){
        int pivot=arr[low];
        while(low<high){
            while(low<high&&pivot<=arr[high]) high--;
            swap(arr,low,high);
            while(low<high&&pivot>=arr[low]) low++;
            swap(arr,low,high);
        }
        return low;
    }
    private void swap(int[] arr,int low,int high){
        int temp=arr[low];
        arr[low]=arr[high];
        arr[high]=temp;
    }
}

3.复杂度分析

• 时间复杂度：理想情况下复杂度为O(n)，最坏情况下时间复杂度为O(n²)，最坏情况下，每一次partition范围只缩小1，需要n次查找，具体证明可以参考《算法导论》第 9 章第 2 小节。
• 空间复杂度：理想情况下空间复杂度为O(logn)，最坏情况下为O(n)，最坏情况下需要划分n次，递归栈的深度为n。

方法四（计数排序）

1.解题思路

用一个数组记录arr数组中每个元素出现的次数，然后遍历（按出现次数从小到大）这个频次数组，只要出现次数不为0，就加入到结果数组，总共加到k个就直接结束。（只适用于数组 范围已经给定的情况）

2.代码实现

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        int[] br=new int[10001];
        for(int a:arr){
            br[a]++;
        }
        int[] res=new int[k];
        int id=0;
        for(int i=0;i<br.length;i++){
            while(br[i]-->0&&id<k){
                res[id++]=i;
            }
            if (id==k) {
                break;
            }
        }
        return res;
    }
}

3.复杂度分析

• 时间复杂度：因为只需要循环n+k次，所以时间复杂度为O(n)。
• 空间复杂度：取决于arr数组中元素的范围，如果范围大小为m，则空间复杂度为O(m)。

剑指offer全集入口： 请戳这里