剑指offer(40-最小的K个数) 题解

最新推荐文章于 2022-07-02 22:58:12 发布

法号画工师

最新推荐文章于 2022-07-02 22:58:12 发布

阅读量108

点赞数

分类专栏：剑指offer 文章标签：算法数据结构 java

本文链接：https://blog.csdn.net/weixin_45453028/article/details/107452719

版权

剑指offer 专栏收录该内容

30 篇文章 0 订阅

订阅专栏

剑指offer-40-最小的K个数

微信搜索【程序员画工师】关注更多Java编程技术、数据结构与算法、面试题相关内容。

题目

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

思路1

最简单的办法是先排序，然后取前k个数即可，时间复杂度为O（nlogn）。

上代码


import java.util.ArrayList;
import java.util.Arrays;
public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int[] nums, int k) {
        ArrayList<Integer> list = new ArrayList<>();
        if(nums.length <= 0 || nums.length < k){
            return list;
        }
        Arrays.sort(nums);
        for(int i = 0;i < k;i ++){
            list.add(nums[i]);
        }
        return list;
    }
}

思路2

冒泡排序的方法：将最小的数依次冒泡排至最后，取后k个数。因为只取后k个数，所以冒泡排序的外部循环只要k次即可。时间复杂度为 O（n*k）。

上代码


import java.util.ArrayList;
import java.util.Arrays;
public class Solution {
 public ArrayList<Integer> GetLeastNumbers_Solution(int[] nums, int k) {
        ArrayList<Integer> list = new ArrayList<>();
        if(nums.length <= 0 || nums.length < k){
            return list;
        }
        int temp = 0;
        for(int i = 0;i < k;i ++){
            for(int j = 0;j < nums.length - 1 - i;j++){
                if(nums[j] < nums[j+1]){
                    temp = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = temp;
                }
            }
        }
        for(int i = nums.length-k;i<nums.length;i++){
            list.add(nums[i]);
        }
        return list;
    }
}

思路3-Partiton

基于partiton函数，基于数组的第k个数字来调整，则使得比第k个数字小的数字都位于数组的左边，比第k个数字大的所有数字都位于数组的右边。这样处理之后，位于数组左边的k个数字即是最小的k个数字。注意：这k个数字不一定是排序的。

上代码


import java.util.ArrayList;
import java.util.Arrays;
public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int[] nums, int k) {
        ArrayList<Integer> ret = new ArrayList<>();
        if (k > nums.length || k <= 0){
            return ret;
        }
        int left=0,right=nums.length-1;
        int index = partition(nums,left,right);
        while(index!=k-1){
            if(index<k-1)
                index = partition(nums,index+1,right);
            else
                index = partition(nums,left,index-1);
        }
        for (int i = 0; i < k; i++){
            ret.add(nums[i]);
        }
        return ret;
    }
    public static int partition(int[] nums,int left,int right){
        int pivot = nums[left];
        while(left<right){
            while (left<right && nums[right]>=pivot)
                right--;
            if(left<right)
                nums[left] = nums[right];
            while (left<right && nums[left]<pivot)
                left++;
            if(left<right)
                nums[right] = nums[left];
        }
        nums[left] = pivot;
        return left;
    }
}

思路4

可以先创建一个大小为k的数据容器来存储最小的k个数字，接下来我们每次从输入的n个整数中读入一个数。
　　如果容器中已有的数字少于k个，则直接把这次读入的整数放入容器之中；
　　如果容器中已有k个数字了，也就是容器已满，此时我们不能再插入新的数字而只能替换已有的数字。
　　找出这已有的k个数中的最大值，然后拿这次待插入的整数和最大值进行比较。如果待插入的值比当前已有的最大值小，则用这个数替换当前已有的最大值；如果待插入的值比当前已有的最大值还要大，那么这个数不可能是最小的k个整数之一，于是我们可以抛弃这个整数。
　　因此当容器满了之后，我们要做3件事情：一是在k个整数中找到最大数；二是有可能在这个容器中删除最大数；三是有可能要插入一个新的数字。如果用一个二叉树来实现这个数据容器，那么我们能在O(logk)时间内实现这三步操作。因此对于n个输入数字而言，总的时间效率就是O(nlogk)。
借助于PriorityQueue来实现，它默认是一个小顶堆，但是可以重写来实现大顶堆。

上代码


import java.util.PriorityQueue;
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int[] nums, int k) {
        if (k > nums.length || k <= 0)
            return new ArrayList<>();
        PriorityQueue<Integer> maxHeap = new PriorityQueue<>((o1, o2) -> o2 - o1);//PriorityQueue默认是一个小顶堆，重写实现大顶堆
        for (int num : nums) {
            maxHeap.add(num);
            if (maxHeap.size() > k)
                maxHeap.poll();
        }
        return new ArrayList<>(maxHeap);
    }
}