[剑指Offer]最小的K个数-优快云博客

原创

[剑指Offer]最小的K个数

2016-04-29 14:29:06 山代王阅读数 7383 更多

分类专栏：数据结构与算法算法整理（Java版）

本文链接： https://blog.youkuaiyun.com/shakespeare001/article/details/51280814

题目描述

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

输入

int[] input：待搜索的数组
int k：需要找出最小的数量

输出

当k大于input长度时，返回空（非null）
当k小于input长度时，返回input中最小的k个数字

思路一

要求数组中最小的k个数，最容易想到的就是利用冒泡排序的思想，每一轮排序把剩余数组中最小的一个数字放到前面已排序的后面，只要进行K轮即可。代码如下：

    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        if(input == null)
            return null;
        ArrayList<Integer> list = new ArrayList<Integer>(k);
        if(k > input.length)
            return list;
        int temp;
        for(int i = 0; i < k; i++){
            for(int j = i + 1; j < input.length; j++){
                if(input[i] > input[j]){
                    temp = input[i];
                    input[i] = input[j];
                    input[j] = temp;
                }
            }
            list.add(input[i]);
        }
        return list;
    } 
 
 
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

该方法的优点是，思路清晰，易于理解，时间复杂度为O(kn)。缺点就是，时间复杂度大了点，关键是改变了原有的输入数组。

思路二

利用快速排序划分的思想，每一次划分就会有一个数字位于以数组从小到达排列的的最终位置index；
位于index左边的数字都小于index对应的值，右边都大于index指向的值；
所以，当index > k-1时，表示k个最小数字一定在index的左边，此时，只需要对index的左边进行划分即可；
当index < k - 1时，说明index及index左边数字还没能满足k个数字，需要继续对k右边进行划分；
代码如下：

public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        if(input == null)
            return null;
        ArrayList<Integer> list = new ArrayList<Integer>(k);
        if(k > input.length)
            return list;
        int low = 0;
        int high = input.length - 1;
        int index = partition(input,low,high);
        while(index != k-1){
            if(index > k-1){
                high = index - 1;
            }else{
                low = index + 1;
            }
            index = partition(input,low,high);
        }
       for(int i = 0; i < k; i++){
           list.add(input[i]);
       }
        return list;
    }
    //划分操作
    public int partition(int[] array,int start,int end){
        int pivot = array[start];
        while(start < end){
            while(start < end && array[end] >= pivot) end--;
            array[start] = array[end];
            while(start < end && array[start] <= pivot) start++;
            array[end] = array[start];
        }
        array[start] = pivot; 
        return start;
    }
 
 
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

这种方式的优点是时间复杂度较小为O(n)，缺点就是需要修改输入数组。当我们不能对原有输入数组进行改变的时候，可以使用如下思路。

思路三

可以先创建一个大小为k的数据容器来存储最小的k个数字，从输入的n个整数中一个一个读入放入该容器中，如果容器中的数字少于k个，按题目要求直接返回空；
如果容器中已有k个数字，而数组中还有值未加入，此时就不能直接插入了，而需要替换容器中的值。按以下步骤进行插入：
1. 先找到容器中的最大值；
2. 将待查入值和最大值比较，如果待查入值大于容器中的最大值，则直接舍弃这个待查入值即可；如果待查入值小于容器中的最小值，则用这个待查入值替换掉容器中的最大值；
3. 重复上述步骤，容器中最后就是整个数组的最小k个数字。

对于这个容器的实现，我们可以使用最大堆的数据结构，最大堆中，根节点的值大于它的子树中的任意节点值。Java中的TreeSet类实现了红黑树的功能，它底层是通过TreeMap实现的，TreeSet中的数据会按照插入数据自动升序排列（按自然顺序）。因此我们直接将数据依次放入到TreeSet中，数组就会自动排序。
代码如下：

public static ArrayList<Integer> GetLeastNumbers_Solution3(int [] input, int k) {
        if(input == null)
            return null;
        ArrayList<Integer> list = new ArrayList<Integer>(k);
        if(k > input.length)
            return list;
        TreeSet<Integer> tree = new TreeSet<Integer>();
        for(int i = 0 ; i < input.length; i++){
            tree.add(input[i]);
        }
        int i = 0;
        for(Integer elem : tree){
            if(i >= k)
                break;
            list.add(elem);
            i++;
        }
        return list;
    }
 
 
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19