剑指offer 40. 最小的k个数

剑指offer 40. 最小的k个数

题目描述

解题思路

这道题是一个经典的 Top K 问题，是面试中的常客。Top K 问题有两种不同的解法，一种解法使用堆（优先队列），另一种解法使用类似快速排序的分治法。

虽然快速排序算法的时间、空间复杂度都优于使用堆的方法，但是要注意到快速选择算法的几点局限性：

• 第一，算法需要修改原数组，如果原数组不能修改的话，还需要拷贝一份数组，空间复杂度就上去了。

• 第二，算法需要保存所有的数据。如果把数据看成输入流的话，使用堆的方法是来一个处理一个，不需要保存数据，只需要保存 k 个元素的最大堆。而快速选择的方法需要先保存下来所有的数据，再运行算法。当数据量非常大的时候，甚至内存都放不下的时候，就麻烦了。所以当数据量大的时候还是用基于堆的方法比较好。

---

1. 计数排序

如果涉及到排序且数据范围有限，则考虑计数排序。

时间o（n），空间o（maxNum），maxNum指数据范围中最大的数。

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        //边界处理
        if (arr == null || arr.length == 0 || arr.length < k) return new int[0];
        
        int[] res = new int[k];   //保存结果
        int index = 0;   //结果数组的索引
        int[] count = new int[10001];   //计数数组
        //计数排序
        for (int i = 0; i < arr.length; i++) count[arr[i]]++;

        for (int i = 0; i < arr.length; i++) {
            while (index < k && count[i]-- > 0) {
                res[index++] = i;
            }
            if(index == k) break;
        }

        return res;
    }
}

---

2. 堆

一般我们说 topK 问题，可以用大顶堆或小顶堆来实现，

• 最大的 K 个：小顶堆
• 最小的 K 个：大顶堆

思路：我们用一个大根堆实时维护数组的前 k 小的元素。首先将前 k 个数插入大根堆中，随后从第 k+1 个数开始遍历，如果当前遍历到的数比大根堆的堆顶的数要小，就把堆顶的数弹出，再插入当前遍历到的数，最后留下的就是最小的k个数。

Java 的 PriorityQueue 默认是一个小顶堆，然而可以通过传入自定义的Comparator函数或者用 lambda 表达式来实现大顶堆。

本题构造大顶堆时的写法：

maxHeap = new PriorityQueue<Integer>((x, y) -> (y - x));

这里的 (x, y) -> (y - x) 是 Java 8 的新特性 lamda 表达式，可以理解为一个简化的函数，函数的输入形参为 x 和 y，则输出为 return y - x。

这种写法等价于下面这样：

maxHeap = new PriorityQueue<Integer>(new Comparator<Integer>(){
            public int compare(Integer num1, Integer num2) {
                return num2 - num1;
            }
        });

时间o（nlogk），空间o（k）

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        //边界处理
        if (arr == null || arr.length == 0 || k == 0 || arr.length < k) return new int[0];
        int[] res = new int[k];   //保存结果
        //构造最大堆
        PriorityQueue<Integer> maxHeap = new PriorityQueue<Integer>((x, y) -> (y - x));
        //将前k个元素添加到大顶堆中
        for (int i = 0; i < k; i++) {
            maxHeap.offer(arr[i]);
        }
        //从下标k开始，依次入堆，不断将堆中的最大元素去除，最后留下的就是最小的k个数
        for (int i = k; i < arr.length; i++) {
            if (maxHeap.peek() > arr[i]) {
                maxHeap.poll();
                maxHeap.offer(arr[i]);
            }
        }
        for (int i = 0; i < k; i++) {
            res[i] = maxHeap.poll();
        }
        return res;
    }
}

---

3. 快排思想

快速排序一次划分的模板：

    //快排划分的模板
    public void quickPartition(int[] arr, int left, int right) {
        int temp = arr[left];
        int i = left, j = right;
        while(i < j) {
            while(i < j && arr[j] >= temp) j--;
            arr[i] = arr[j];
            while(i < j && arr[i] < temp) i++;
            arr[j] = arr[i];
        }
        arr[i] = temp;
    }

复杂度分析：

class Solution {

    public int[] getLeastNumbers(int[] arr, int k) {
        //边界处理
        if (arr == null || arr.length == 0 || k == 0 || arr.length < k) return new int[0];
        int[] res = new int[k];
        quickSearch(arr, 0, arr.length - 1, k);
        for (int i = 0; i < k; i++) res[i] = arr[i];
        return res;
    }


    public void quickSearch(int[] arr, int left, int right, int k) {
        if (left >= right) return;
        //每次用快排思想切分后，返回切分点的下标
        int partitionIndex = quickPartition(arr, left, right);
        //如果切分点正好是k，则arr中的前k个元素就是最小的k个数，直接返回
        if (partitionIndex == k) return;
        //继续去左边或右边寻找
        if (partitionIndex < k) {
            quickSearch(arr, partitionIndex + 1, right, k);
        } else {
            quickSearch(arr, left, partitionIndex -  1, k);
        }
    }

    //快排划分的模板，返回切分点的下标
    public int quickPartition(int[] arr, int left, int right) {
        int temp = arr[left];
        int i = left, j = right;
        while(i < j) {
            while(i < j && arr[j] >= temp) j--;
            arr[i] = arr[j];
            while(i < j && arr[i] < temp) i++;
            arr[j] = arr[i];
        }
        arr[i] = temp;
        return i;
    }
}