算法與數據結構之美-排序(下)

開篇思考

如何利用快排的思想，在O(n)內查找數組中的第K大元素？
leetcode:https://leetcode-cn.com/problems/kth-largest-element-in-an-array/

上篇博客中講到了 冒泡、選擇、插入排序，時間複雜度都是O(n^2),適用於小規模數據排序，本篇博客中將介紹歸併排序和快速排序，適用於大規模的數據。

歸併排序

原理

歸併排序的使用的是分治思想，將一個數組分解成兩個數組，在對前後兩個部分進行排序後，在將兩部分進行合併，就實現了數組的排序。排序過程如下圖所示：

歸併排序採用了分治的思想，分治通過遞歸來實現；遞歸算法的關鍵是推導出遞推公式，然後找到終止條件：

• 遞推公式

merge_sort(p,r) = merge(merge_sort(p,q),merge_sort(q+1,r));
merge_sort(p,r) 表示的是對下標爲p到r的數組進行排序，
merge_sort(p,q)和merge_sort(q+1,r)數組前後兩部分分別進行排序；
採用merge方法，將兩個排序好的子數組進行排序即可；

• 終止條件

p>=r

merge是如何對兩個已排序的數組進行排序？
首先，申請一個大小爲r-p+1的臨時數組tmp;
設定兩個遊標i，j分別指向A[p…q]和A[q+1…r]的第一個元素，在比較這兩個元素A[i]和A[j],如果A[i]<=A[j],就把A[i]放入臨時數組中，並且i後移一位，否則就是將A[j]放入數組tmp中，j後移一位；直到一個數組中的所有元素放入到數組tmp之後，再把另一個數組的剩餘的元素以此加到tmp數組的末尾，最後在把tmp數組拷貝到原數組中A[p…r]中，即可。

歸併排序代碼

public class mergeSort {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.println("請輸入數組長度:");
        int n = sc.nextInt();
        System.out.println("請輸入數組:");
        int[] a = new int[n];
        for(int i = 0;i<n;i++)
        {
            a[i] = sc.nextInt();
        }
        mergeSortInternally(a,0,n-1);

        for(int i=0;i<n;i++)
        {
            System.out.println(a[i]+" ");
        }
    }

    //遞歸調用函數
    public static void mergeSortInternally(int[] a,int p,int r){
        //遞歸終止條件
        if(p>=r) return;
        int q = p+(r-p)/2;
        mergeSortInternally(a,p,q);
        mergeSortInternally(a,q+1,r);
        //最後將前後兩部分在進行排序
        merge(a,p,q,r);
    }
    //merge排序函數
    public static void merge(int[] a,int p,int q,int r){
        int[ ] tmp = new int[r-p+1];  //創建臨時數組
        int i = p;
        int j = q+1;
        int k = 0;//tmp數組的下標
        while(i<=q&&j<=r)
        {
            if(a[i]<=a[j])
            {
                tmp[k++] = a[i];
                i++;
            }else{
                tmp[k++] = a[j];
                j++;
            }
        }
        //判斷兩個數組中哪個還有剩餘元素
        int start = i;
        int end = q;
        if(j<=r) {
            start = j;
            end = r;
        }
        //將剩餘數組中的元素拷貝至temp數組中
        while(start <= end){
            tmp[k++] = a[start++];
        }
        //再將tmp數組中的元素全部拷貝到數組A中
        for(i = 0;i<=r-p;i++)
        {
            a[i+p] = tmp[i];
        }
    }
}

性能分析

• 歸併排序是穩定的排序算法，穩定的關鍵在於merge函數，在合併的過程中如果A[p…q]和A[q+1…r]之間有值相同的元素，就可以先把A[p…q]中的元素放入到tmp數組中，就保證了值相同的元素在合併前後的順序不變；
• 歸併排序的時間複雜度是O(nlog(n));
• 歸併排序不是原地排序，空間複雜度是O(n);

快速排序

原理分析

快速排序(Quicksort)：排序數組下標從p到r的一組數據，選擇p到r之間的任意一個數據作爲privot(分區點)，遍歷p到r之間的數據，將小於privot的放到左邊，將大於privot的放到右邊，將privot放到中間；

採用分治遞歸的思想分別遞歸排序下標從p到q-1和q+1到r之間的數據，直到區間縮小爲1，就是所有的數據都有序了。

遞推公式：
quick_sort(p...r)=quick_sort(p...q-1)+quick_sort(q+1...r);
終止條件：
p>=r

快速排序中需要一個partition()分區函數，隨機選擇一個privot對A[p…r]分區，函數返回privot的下標；通過遊標i將A[p…r-1]分爲兩部分，A[p…i-1]都是小於privot的，暫且叫"已處理區間",A[i…r-1]就是未處理區間；每次從未處理區間A[i…r-1]中取出一個元素A[j],與privot進行對比，如果小於privot,則將其加入已處理區間的尾部，就是A[i]的位置；

快速排序代碼

import java.util.Scanner;

public class quickSort {
    public static void main(String[] args){
        Scanner sc  = new Scanner(System.in);
        System.out.println("請輸入數組大小:");
        int N = sc.nextInt();
        System.out.println("請依次輸入數組中的元素:");
        int[] a = new int[N];
        for(int i=0;i<N;i++)
            a[i] = sc.nextInt();
        quickSortInternally(a,0,N-1);
        for(int i=0;i<N;i++)
            System.out.println(a[i]+" ");
    }
    //快排遞歸函數，p,r爲下標
     public static void quickSortInternally(int[] a,int p,int r){
         if(p>=r) return;
         int q = partition(a,p,r);//獲取分區點
         quickSortInternally(a,p,q-1);
         quickSortInternally(a,q+1,r);
     }
     //獲取分區點函數
     public static int  partition(int[] a,int p,int r){
         int privot = a[r];
         int i = p;
         for(int j = p;j<=r;j++)
         {
             if(a[j]<privot)
             {
                 swap(a,i,j);
                 i++;
             }
         }
         swap(a,i,r);
         return i;
     }

     //交換
    public static void swap(int[] a,int i,int j){
         int temp = a[i];
         a[i] = a[j];
         a[j] = temp;
    }
}

性能分析

• 快排是一種原地、不穩定排序算法；
• 快排的時間複雜度是O(nlogn),只有在極端情況下，纔會退化成O(n^2);

解答開篇

選擇數組區間A[0…n-1]的最後一個元素A[n-1]作爲pivot，對數組A[0…n-1]原地分區，這樣數組就分成了三部分，A[0…p-1]、A[p]、A[p+1…n-1]；

如果p+1=K，那A[p]就是要求解的元素；如果K>p+1, 說明第K大元素出現在A[p+1…n-1]區間，我們再按照上面的思路遞歸地在A[p+1…n-1]這個區間內查找。同理，如果K<p+1，那我們就在A[0…p-1]區間查找。

代碼

import java.util.Scanner;

public class kthSmallest {
      public static int kthSmallest(int[] a,int k ){
        if(a==null||a.length<k)
            return -1;
        //分區函數
        int partition = partition(a,0,a.length-1);
        while(partition+1!=k)
        {
            if(partition+1<k){
                partition = partition(a,partition+1,a.length-1);
            }else{
                partition = partition(a,0,partition-1);
            }
        }
        return a[partition];
    }
    //設定分區函數
    public static int partition(int[] a,int p,int r){

        int privot = a[r];
        int i=p;

        for(int j=p;j<r;j++){
            if(a[j]<=privot){
                swap(a,i,j);
                i++;
            }
        }
        swap(a,i,r);
        return i;
    }
    public static void swap(int[] a,int i,int j){
        if(i==j)
            return;
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}