剑指 Offer 40. 最小的k个数

剑指 Offer 40. 最小的k个数

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

思路一：排序后，选取前k个数值返回。由于是简单题，所以自己实现快排，不调用sort函数。

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        quickSort(arr, 0, arr.length - 1);
        // 截取我们想要的结果
        return Arrays.copyOf(arr, k);
    }
    private void quickSort(int[] arr, int l, int r) {
        // 索引异常 返回
        if(l > r) return;
        int i = l;
        int j = r;
        while(i < j){
        	// 找到第一个小于基准的元素
            while(i < j && arr[j] >= arr[l]) j--;
            // 找到第一个大于基准的元素
            while(i < j && arr[i] <= arr[l]) i++;
            // 交换，直到遍历结束
            swap(arr,i,j);
        }
        // 将基准放到中间。
        swap(arr,l,i);
        // 分别向基准的 左右 递归
        quickSort(arr,l,i-1);
        quickSort(arr,i+1,r);
    }
    // 交换函数
    private void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
}

思路二：我们可以通过思路一来对算法进行优化，因为只是想要前K小的元素，并没有要求需要排序，所以我们可以在对左右进行递归时，可以判断到底是向左还是向右，减少递归次数。

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        if (k >= arr.length) return arr;
        return  quickSort(arr,k, 0, arr.length - 1);
    }
    private int[] quickSort(int[] arr,int k, int l, int r) {
        int i = l;
        int j = r;
        while(i < j){
            while(i < j && arr[j] >= arr[l]) j--;
            while(i < j && arr[i] <= arr[l]) i++;
            swap(arr,i,j);
        }
        swap(arr,l,i);
        // 如果要找的k个最小数比当前基准的索引小，就往左边递归
        // 如果比当前基准的索引大，就往右边递归
        // 如果相等就直接返回
        if(k < i)   quickSort(arr,k,l,i-1);
        if(k > i)   quickSort(arr,k,i+1,r);

        return Arrays.copyOf(arr,k);
    }
    private void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
}

思路三：前K个最小数，可以用大顶堆来做。

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        if(k == 0) return new int[0];
        //Queue<Integer> heap = new PriorityQueue<>(k, (i1, i2) -> Integer.compare(i2, i1));
        // 大顶堆 java默认创建的堆为小顶堆
        Queue<Integer> heap =new PriorityQueue<Integer>((n1, n2) -> n2-n1);

        for(int num: arr){
        	// 解释一下这三个短路或
        	// 1.为空？ 直接入堆：2
        	// 2.未满？ 直接入堆：3
        	// 3.能进入3说明此时的堆已经满了，此时只用考虑是否小于堆顶元素，如果小再入堆，否则跳过。
            if(heap.isEmpty() || heap.size() < k || num < heap.peek())
                heap.offer(num);
            if(heap.size() > k) 
                heap.poll();
        }
        int[] res = new int[heap.size()];
        int j = 0;
        for (int e : heap) {
            res[j++] = e;
        }
        return res;
    }
}

前两种思路的时间复杂度是优于大顶堆的，但是快排是会对改变原数组，如果不想改变的话，需要申请另外一空间，当数据集很大的时候，是不适合的，此时大顶堆更合适。