尋找最大的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個數，也就是尋找這些數中最小的那個值。

 

喜歡聊技術或者聊觀點，能夠加入公號：【花生讀書匯】

一塊兒：勵志，成長，學習，分享。