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

接下来两天，和你们一块儿聊一聊这个问题：寻找最大的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个数，也就是寻找这些数中最小的那个值。

 

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

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