标签：map arr 数字 Offer int 个数 40 num 数组

题目信息

• 时间： 2019-06-30

• 题目链接：Leetcode

• tag： 快排

• 难易程度：中等

• 题目描述：

  输入整数数组 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]

提示

1.0 <= k <= arr.length <= 10000
2.0 <= arr[i] <= 10000                              

解题思路

本题难点

多种解题方案，快排，大根堆，二叉搜索树，计数排序

具体思路

快速排序的思想。快排的划分函数每次执行完后都能将数组分成两个部分，小于等于分界值 pivot 的元素的都会被放到数组的左边，大于的都会被放到数组的右边，然后返回分界值的下标。

我们的目的是寻找最小的 k 个数。假设经过一次 partition 操作，分界值 pivot元素位于下标 j，也就是说，左侧的数组有 j 个元素，是原数组中最小的 j 个数。那么：

• k = j： 我们就找到了最小的 k 个数，就是左侧的数组；：
• k < j： 则最小的 k 个数一定都在左侧数组中，我们只需要对左侧数组递归地 parition 即可；
• k > j：则左侧数组中的 j 个数都属于最小的 k 个数，我们还需要在右侧数组中寻找最小的 k−j 个数，对右侧数组递归地 partition 即可。

代码

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        if(arr.length == 0 || k == 0){
            return new int[0];
        }
        //快排查找前k个数，第k个数的数组下标为k-1
        return findKthSmallest(arr,0,arr.length-1,k-1);
    }

    public int[] findKthSmallest(int[] arr,int l ,int h , int k){
      // 每快排切分1次，找到排序后下标为j的元素，如果j恰好等于k就返回j以及j左边所有的数；
        int j = partition(arr,l,h);
        if(j == k){
            return Arrays.copyOf(arr, j + 1);
        }
      // 否则根据下标j与k的大小关系来决定继续切分左段还是右段。
        return j > k ? findKthSmallest(arr,l,j-1,k):findKthSmallest(arr,j+1,h,k);        
    }

  	 // 快排切分，返回下标j，使得比nums[j]小的数都在j的左边，比nums[j]大的数都在j的右边。
    public int partition(int[] arr,int l,int h){
        //切分元素
        int privot = arr[l];
        int i = l,j = h + 1;
        while(true){
            while(i != h && arr[++i] < privot);
            while(j != l && arr[--j] > privot);
            if(i >= j){
                break;
            }
            swap(arr,i,j);
        }
        swap(arr,l,j);
        return j;
    }
    public void swap(int[] arr,int i,int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

复杂度分析：

• 时间复杂度 O(N) ： 找下标为k的元素，第一次切分的时候需要遍历整个数组 (0 ~ n) 找到了下标是 j 的元素，假如 k 比 j 小的话，那么我们下次切分只要遍历数组 (0~k-1)的元素就行啦，总之可以看作每次调用 partition 遍历的元素数目都是上一次遍历的 1/2，因此时间复杂度是 N + N/2 + N/4 + ... + N/N = 2N, 因此时间复杂度是 O(N)。
• 空间复杂度 O(logN) ： 递归调用的期望深度为O(logN)，每层需要的空间为 O(1)，只有常数个变量。

其他优秀解答

解题思路

本题是求前 K 小，因此用一个容量为 K 的大根堆，每次 poll 出最大的数，那堆中保留的就是前 K 小啦（注意不是小根堆！小根堆的话需要把全部的元素都入堆，那是 O(NlogN)，就不是 O(NlogK)）这个方法比快排慢。

代码

// 保持堆的大小为K，然后遍历数组中的数字，遍历的时候做如下判断：
// 1. 若目前堆的大小小于K，将当前数字放入堆中。
// 2. 否则判断当前数字与大根堆堆顶元素的大小关系，如果当前数字比大根堆堆顶还大，这个数就直接跳过；
//    反之如果当前数字比大根堆堆顶小，先poll掉堆顶，再将该数字放入堆中。
class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        if (k == 0 || arr.length == 0) {
            return new int[0];
        }
        // 默认是小根堆，实现大根堆需要重写一下比较器。
        Queue<Integer> pq = new PriorityQueue<>((v1, v2) -> v2 - v1);
        for (int num: arr) {
            if (pq.size() < k) {
                pq.offer(num);
            } else if (num < pq.peek()) {
                pq.poll();
                pq.offer(num);
            }
        }
        
        // 返回堆中的元素
        int[] res = new int[pq.size()];
        int idx = 0;
        for(int num: pq) {
            res[idx++] = num;
        }
        return res;
    }
}

解题思路

BST 相对于前两种方法没那么常见，但是也很简单，和大根堆的思路差不多，与前两种方法相比，BST 有一个好处是求得的前K大的数字是有序的。

代码

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        if (k == 0 || arr.length == 0) {
            return new int[0];
        }
        // TreeMap的key是数字, value是该数字的个数。
        // cnt表示当前map总共存了多少个数字。
        TreeMap<Integer, Integer> map = new TreeMap<>();
        int cnt = 0;
        for (int num: arr) {
            // 1. 遍历数组，若当前map中的数字个数小于k，则map中当前数字对应个数+1
            if (cnt < k) {
                map.put(num, map.getOrDefault(num, 0) + 1);
                cnt++;
                continue;
            } 
            // 2. 否则，取出map中最大的Key（即最大的数字), 判断当前数字与map中最大数字的大小关系：
            //    若当前数字比map中最大的数字还大，就直接忽略；
            //    若当前数字比map中最大的数字小，则将当前数字加入map中，并将map中的最大数字的个数-1。
            Map.Entry<Integer, Integer> entry = map.lastEntry();
            if (entry.getKey() > num) {
                map.put(num, map.getOrDefault(num, 0) + 1);
                if (entry.getValue() == 1) {
                    map.pollLastEntry();
                } else {
                    map.put(entry.getKey(), entry.getValue() - 1);
                }
            }
            
        }

        // 最后返回map中的元素
        int[] res = new int[k];
        int idx = 0;
        for (Map.Entry<Integer, Integer> entry: map.entrySet()) {
            int freq = entry.getValue();
            while (freq-- > 0) {
                res[idx++] = entry.getKey();
            }
        }
        return res;
    }
}

解题思路

数据范围有限时直接计数排序就行了：O(N)

代码

class Solution {
    public int[] getLeastNumbers(int[] arr, int k) {
        if (k == 0 || arr.length == 0) {
            return new int[0];
        }
        // 统计每个数字出现的次数
        int[] counter = new int[10001];
        for (int num: arr) {
            counter[num]++;
        }
        // 根据counter数组从头找出k个数作为返回结果
        int[] res = new int[k];
        int idx = 0;
        for (int num = 0; num < counter.length; num++) {
            while (counter[num]-- > 0 && idx < k) {
                res[idx++] = num;
            }
            if (idx == k) {
                break;
            }
        }
        return res;
    }
}

标签：map,arr,数字,Offer,int,个数,40,num,数组
来源： https://www.cnblogs.com/ID-Wangqiang/p/13218657.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。