剑指 offer 40 最小的k个数（堆 + 快排）

1 题目描述

2 算法思路

2.1 堆 

思路：

• 利用堆数据结构来辅助得到最小的k个数
• 堆的性质是可以找到最大或者最小的元素
• 我们可以使用一个大小为k的大顶堆，将元素依次遍历加入堆，如果堆的大小超过了k，就将最大的元素弹出
• 如此就保证了堆中的元素都是当前最小的k个元素
• 时间复杂度 nlogk
• 这里的大顶堆选择的是 Java中的PriorityQueue 
• PriorityQueue默认是小顶堆，需要重写比较器，使其变为最大堆

2.2 快速排序/快速选择

利用快排的思想：

• 每次快速排序时，都会在将数组变成，左边都是小于v ，右边都是大于v的。由于本题只需要求最小的k个数。
• 因此，利用快速排序的思想，每次都将数组进行排序，然后可以得到当前左边数组的个数m
• 如果 m == k ,直接返回左边的数组
• 如果 m > k ,就代表这k个数，都在左边数组中，因此继续向左边数组递归
• 如果 m <k 就代表这k 个数，还有m - k个在右边，因此要继续向右边递归查找m - k个

2.3 比较

在面试中，另一个常常问的问题就是这两种方法有何优劣。看起来分治法的快速选择算法的时间、空间复杂度都优于使用堆
的方法，但是要注意到快速选择算法的几点局限性:

1. 第一,算法需要修改原数组，如果原数组不能修改的话，还需要拷贝一份数组，空间复杂度就上去了。
2. 第二，算法需要保存所有的数据。如果把数据看成输入流的话，使用堆的方法是来一个处理一个, 不需要保存数据,只需要保存k元素的最大堆。而快速选择的方法需要先保存下来所有的数据，再运行算法。当数据量非常大的时候，甚至内存都放不下的时候，就麻烦了。所以当数据量大的时候还是用基于堆的方法比较好。

3 代码

3.1 堆

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        if( k == 0)
            return new int[0];
        Queue<Integer> heap = new PriorityQueue<>(      //重写比较器
            (v1,v2) -> v2 - v1
        );

        for(int e : arr){
            if(heap.isEmpty() || heap.size() < k || e < heap.peek()){   
                heap.offer(e);
            }
            if(heap.size() > k){
                heap.poll();
            }
        }
        int[] res = new int[heap.size()];
        int j = 0;
        for(int e:heap){
            res[j++] = e;
        }
        return res;
    }
}

3.2 快排

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {

        if(k == 0)
            return new int[0];
        else if(arr.length <= k)
            return arr;
        
        partitionArray(arr,0,arr.length - 1,k);

        int[] res = new int[k];
        for(int i = 0; i < k; i++){
            res[i] = arr[i];
        }

        return res;

    }
    void partitionArray(int[] arr,int lo,int hi,int k){
        int m  = partition(arr,lo,hi);
        if(k == m){
            return;
        }else if(k < m){
            partitionArray(arr,lo,m - 1,k);
        }else{
            partitionArray(arr,m + 1,hi,k);
        }
    }

    int partition(int[] a,int lo, int hi){
        int i = lo;
        int j = hi + 1;
        int v = a[lo];
        while(true){
            while(a[++i] < v){  //找到第一个小于v的
                if(i == hi){
                    break;
                }
            }
            while(a[--j] > v){  //找到第一个大于v的
                if(j == lo){
                    break;
                }
            }
            if(i >= j){
                break;
            }
            swap(a,i,j);
        }
        swap(a,lo,j);
        return j;
    }

    void swap(int[] a,int i, int j){
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}

 

4 提交结果