寻找最大的K个数（一）：快排和选择

最新推荐文章于 2018-07-05 13:42:53 发布

weixin_33725807

最新推荐文章于 2018-07-05 13:42:53 发布

阅读量270

点赞数

文章标签： python 大数据 java

原文链接：https://my.oschina.net/u/1013545/blog/898140

版权

2019独角兽企业重金招聘Python工程师标准>>>

接下来两天，和大家一起聊一聊这个问题：寻找最大的K个数。

问题如下：

有很多个无序的数（我们这里假设为正整数），而且各不相等，怎么选出最大的K个数。

例如：2，5，7，1，3，9，3，6，7，8，5

最大的5个数为：7，9，6，7，8

相信很多人都被这个问题给虐过。

当你还是一个菜鸟的时候，你以为很简单。so easy!

声明一个数组，数组从大到小排序，然后取前K个数，不就结了。so easy!

如果数很大呢，例如1000个，那就声明大小为1000的数组。还是 so easy!

如果有1亿个呢？还要声明大小为1亿的数组吗？

额，这个，我要想想！

下面介绍的解法没有好坏之分，不同的情况选择不同的解法，才是一个好程序员。

文章会分为三个篇幅来介绍：

第一部分：常规解法，包括快速排序，选择排序。

第二部分：第一部分的优化版。

第二部分：是处理大数据量的解法，包括使用最小堆排序，还有一个终极算法，时间复杂度为线性（不过需要有前提条件）。

解法一：使用快速排序或选择排序。

将数组排序，是我们能够想到的第一个解决方案。

在所有的排序中快速排序和堆排序时间复杂度是最低的。

快排思路：使用快速排序，将数组全排序，这样我只需要从后向前查找Ｋ的数，即为我们要找的前K个最大的数。

PS: 这里默认数组长度都比K大

下面是快速排序的代码：

package com.xylx.utils.selectK;

public class QuickSortSelectK {
    public static void main(String[] args) {
        int[] arr = Constans.getLengthArr(100);
        System.out.println("排序前：");
        Constans.printArr(arr);
        quickSort(arr, 0, arr.length-1);
        System.out.println("排序后:");
        Constans.printArr(arr);
        System.out.println("排序是否正确: "+Constans.isOk(arr));
        Constans.selectK(arr);
    }

    //从后向前查找
    /**
     * 要点：从后向前查找，
     * 移动数据位置不要忘记判断条件
     *　一次排序后，数组会一分为二，分别是start到left-1 和　right+1<end
     *  记住，分别进行快排的时候，不要忘记添加判断条件
     * @param arr
     * @param start
     * @param end
     */
    public static void quickSort(int[] arr, int start, int end){
        int left = start;
        int right = end;
        int key = arr[left];
        while (left < right) {
            while (left < right && arr[right] > key) {
                right--;
            }
            if (left < right) {
                int tmp = arr[left];
                arr[left] = arr[right];
                arr[right] = tmp;
                left++;
            }
            while (left < right && arr[left] < key) {
                left++;
            }
            if (left < right) {
                int tmp = arr[right];
                arr[right] = arr[left];
                arr[left] = tmp;
                right--;
            }
        }
        if (start < left-1) {
            quickSort(arr, start, left-1);
        }
        if (right + 1 < end) {
            quickSort(arr, right+1, end);
        }
    }
}

关于快速排序想必大家也都知道，所以就不多说了。

这个类需要一个辅助类，辅助类主要是用来生成给定大小的数组，校验排序是否正确，以及数组输出。源码如下：

package com.xylx.utils.selectK;
import java.util.Random;
/**
 */
public class Constans {
    private static int JI_ZHUN = 1000; //数组元素随机数的基数
    private static int K = 10; 
    /**
     * 生成长度为length的int类型数组
     * @param length
     * @return
     * @throws Exception
     */
    public static int[] getLengthArr(int length) {
        if (length<1) {
            length = 100;
        }
        int[] arr = new int[length];
        Random random = new Random();
        for (int i=0; i<length; i++) {
            arr[i] = random.nextInt(JI_ZHUN);
        }
        return arr;
    }
    public static void printArr(int[] arr) {
        System.out.println("数组输出:\n");
        for (int i=0; i<arr.length; i++) {
            System.out.print(arr[i]+"    ");
        }
        System.out.println();
    }
    /**
     * 校验排序是否正确
     * @param arr
     * @return
     */
    public static boolean isOk(int[] arr) {
        for (int i=0; i<arr.length-1; i++) {
            if (arr[i+1] < arr[i]) {
                return false;
            }
        }
        return true;
    }
    public static void selectK(int[] arr) {
        System.out.println("最大的K个数：");
        for (int i=arr.length-K; i<arr.length; i++) {
            System.out.print(arr[i]+"    ");
        }
        System.out.println();
    }
}

上面的代码都是自己写的并且经过测试，拷贝下来就能直接运行。

你一定能够注意到，上面的快速排序是将所有的数据进行了排序，而我们需要的只是前K个数，也就是我们多排了N-K个数。假设数组长度为N。

那么怎么避免多做N-K个数的排序呢？我们可以选择选择排序算法。

选择排序：每一次从待排序数据中选择最小（最大）的一个数，放在序列的起始（结束）位置，直到所有待排序数据全部排序完成。这里需要注意：当排完前K个数后，我们就要终止排序。

代码如下（辅助类同上）：

package com.xylx.utils.selectK;

/**
 * Created by baidu on 17/5/8.
 */
public class SelectSortSelectK {
    public static void main(String[] args) {
        int arr[] = Constans.getLengthArr(100);
        System.out.println("排序前：");
        Constans.printArr(arr);
        selectSort(arr);
        System.out.println("排序后:");
        Constans.printArr(arr);
        Constans.selectK(arr);
    }

    /**
     * 注意要点：
     *  注意下标的位置，以及数据的及时复位
     * @param arr
     */
    public static void selectSort(int[] arr) {
        int index = arr.length-1;
        int tmp = Integer.MIN_VALUE;
        int tmpIndex = 0;
        for (int i=arr.length-1; i>0; i--) {

            for (int j=0; j<=i; j++) {
                if (arr[j] > tmp) {
                    tmp = arr[j];
                    tmpIndex = j;
                }
            }
            arr[tmpIndex] = arr[index];
            arr[index] = tmp;
            if (arr.length-index == Constans.K) {
                break;
            }
            tmp = Integer.MIN_VALUE;
            index--;
        }
    }
}

前面快速排序的时间复杂度为O(N*log2N)，选择排序的时间复杂度为O(N*K)。至于选择快速排序还是选择排序需要看K的大小。也就是计算下面的公式：

N*log2N>N*K

明天我们会介绍另外两个算法：快速排序的优化版，利用二分搜索策略。

快速排序的优化版：

一次快速排序会将数组分位两部分Sa和Sb。Sb的任意值都比Sa的任意值要大。所以就会有两种情况出现：

1，Sb.length>=K，我们只需要关心Sb就好了

2，Sb.length<K，我们关心的是Sb和Sa中K-Sb.length个最大的数

二分搜索策略：寻找最大的K个数，也就是寻找这些数中最小的那个值。

喜欢聊技术或者聊观点，可以加入公号：【花生读书汇】

一起：励志，成长，学习，分享。

【花生读书汇】