演算法圖解之快速排序

分而治之(又稱D&C)

書中舉了一個例子，假設你是農場主，有一塊土地，如圖所示:

 

你要將這塊地均勻分成方塊，且分出的方塊要儘可能大。

 

 

從圖上看，顯然是不符合預期結果的。

那麼如何將一塊地均勻分成方塊，並確保分出的方塊是最大的呢？使用D&C策略。

(1)D&C演算法是遞迴的;
(2)使用D&C解決問題的過程包括兩個步驟:
a.找出基線條件，這種條件必須儘可能簡單;
b.不斷將問題分解(或者說縮小規模)，直到符合基線條件;

就如何保證分出的方塊是最大的呢？《演算法圖解》中的快速排序一章提到了歐幾里得演算法。

什麼是歐幾里得演算法?
歐幾里得演算法又稱輾轉相除法，是指用於計算兩個正整數a,b的最大公約數。
應用領域有數學和計算機兩個方面。

舉個程式碼例子說一下歐幾里得演算法:

package cn.pratice.simple;

public class Euclid {

    
    public static void main(String[] args) {
        int m = 63;
        int n = 18;
        int remainer = 0;
        while(n!=0) {
            remainer = m % n;
            m = n;
            n = remainer;
        }
        
        System.out.println(m);
    }
}

 

最終的結果是9，正好63和18的最大公因數也是9.
其中也體現著分而治之的思想。記住，分而治之並非可用於解決問題的演算法而是一種解決問題的思路。

再舉個例子說明，如圖所示:

 

需要將這些數字相加，並返回結果，使用迴圈很容易完成這種任務，以Java為例:

 

package cn.pratice.simple;

public class Euclid {

    
    public static void main(String[] args) {
        int []num = new int[] {2,4,6};
        int total = 0;
        for (int i = 0; i < num.length; i++) {
            total += num[i];
                    
        }
        System.out.println(total);
    }
}

快速排序

快速排序是一種常用的排序演算法，比選擇排序快的多。
程式碼示例如下(快速排序):

package cn.pratice.simple;

public class QuickSort {
    
    //宣告靜態的 getMiddle() 方法，該方法需要返回一個 int 型別的引數值，在該方法中傳入 3 個引數
    public static int getMiddle(int[] list,int low,int high) {
        
        int tmp = list[low];//陣列的第一個值作為中軸(分界點或關鍵資料)
        
        while(low<high) {
            
            while(low<high && list[high]>tmp) {
                high--;
            }
            
            list[low] = list[high];//比中軸小的記錄移到低端
            
            while(low<high&&list[low]<tmp) {
                low++;
            }
            
            list[high]=list[low];//比中軸大的記錄移到高階
        }
        
        list[low] = tmp;//中軸記錄到尾
        
        return low;
    }
    
    //建立靜態的 unckSort() 方法，在該方法中判斷 low 引數是否小於 high 引數，如果是則呼叫 getMiddle() 方法，將陣列一分為二，並且呼叫自身的方法進行遞迴排序
    public static void unckSort(int[] list,int low,int high) {
        
        if(low<high) {
            
            int middle = getMiddle(list,low,high);//將list陣列一分為二
            unckSort(list,low,middle-1);//對低字表進行遞迴排序
            unckSort(list,middle+1,high);//對高字表進行遞迴排序
        }
    }
    
    //宣告靜態的 quick() 方法，在該方法中判斷傳入的陣列是否為空，如果不為空，則呼叫 unckSort() 方法進行排序
    public static void quick(int[] str) {
        if(str.length>0) {
            //檢視陣列是否為空
            unckSort(str,0,str.length-1);
        }
    }
    
    //測試
    public static void main(String[] args) {
        
        int[] number = {13,15,24,99,14,11,1,2,3};
        System.out.println("排序前:");
        for (int i : number) {
            System.out.print(i+" ");
        }
        
        quick(number);
        
        System.out.println("\r排序後:");
        for (int i : number) {
            System.out.print(i+" ");
        }
    }
}

此示例來自Java陣列排序：Java快速排序（Quicksort）法

沒有什麼比程式碼示例來的直接痛快。

再談大O表示法

快速排序的獨特之處在於，其速度取決於選擇的基準值。

常見的大O執行時間圖，如下:

 

上述圖表中的時間是基於每秒執行10次操作計算得到的。這些資料並不準確，這裡提供它們只是想讓你對這些執行時間的差別有大致認識。實際上，計算機每秒執行的操作遠遠不止10次。 在該節中，作者說合並排序比選擇排序要快的多。合併排序，用數學公式表示為O(n log n)，而選擇排序為O(n的2次方)。
合併程式碼排序例子如下:

package cn.pratice.simple;

import java.util.Arrays;

public class MergeSort {



    private static void mergeSort(int[] original) {
        if (original == null) {
            throw new NullPointerException("The array can not be null !!!");
        }
        int length = original.length;
        if (length > 1) {
            int middle = length / 2;
            int partitionA[] = Arrays.copyOfRange(original, 0, middle);// 拆分問題規模
            int partitionB[] = Arrays.copyOfRange(original, middle, length);
            // 遞迴呼叫
            mergeSort(partitionA);
            mergeSort(partitionB);
            sort(partitionA, partitionB, original);
        }
    }

    private static void sort(int[] partitionA, int[] partitionB, int[] original) {
        int i = 0;
        int j = 0;
        int k = 0;
        while (i < partitionA.length && j < partitionB.length) {
            if (partitionA[i] <= partitionB[j]) {
                original[k] = partitionA[i];
                i++;
            } else {
                original[k] = partitionB[j];
                j++;
            }
            k++;
        }
        if (i == partitionA.length) {
            while (k < original.length) {
                original[k] = partitionB[j];
                k++;
                j++;
            }
        } else if (j == partitionB.length) {
            while (k < original.length) {
                original[k] = partitionA[i];
                k++;
                i++;
            }
        }
    }

    private static void print(int[] array) {
        if (array == null) {
            throw new NullPointerException("The array can not be null !!!");
        }
        StringBuilder sb = new StringBuilder("[");
        for (int element : array) {
            sb.append(element + ", ");
        }
        sb.replace(sb.length() - 2, sb.length(), "]");
        System.out.println(sb.toString());
    }
    
    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();    //獲取開始時間

        int original[] = new int[] { 13,15,24,99,14,11,1,2,3 };
        for (int i = 0; i < original.length; i++) {
            System.out.print(original[i]+" ");
        }
        mergeSort(original);
        print(original);
        long endTime = System.currentTimeMillis();    //獲取結束時間

        System.out.println("程式執行時間：" + (endTime - startTime) + "ms");    //輸出程式執行時間
        
    }
}

此示例來自
java實現合併排序演算法

比較快速排序與合併排序

還是以上面的程式碼例子為例:
快速排序程式碼例子，如下:

public static int getMiddle(int[] list,int low,int high) {
        
        int tmp = list[low];//陣列的第一個值作為中軸(分界點或關鍵資料)
        
        while(low<high) {
            
            while(low<high && list[high]>tmp) {
                high--;
            }
            
            list[low] = list[high];//比中軸小的記錄移到低端
            
            while(low<high&&list[low]<tmp) {
                low++;
            }
            
            list[high]=list[low];//比中軸大的記錄移到高階
        }
        
        list[low] = tmp;//中軸記錄到尾
        
        return low;
    }
    
    //建立靜態的 unckSort() 方法，在該方法中判斷 low 引數是否小於 high 引數，如果是則呼叫 getMiddle() 方法，將陣列一分為二，並且呼叫自身的方法進行遞迴排序
    public static void unckSort(int[] list,int low,int high) {
        
        if(low<high) {
            
            int middle = getMiddle(list,low,high);//將list陣列一分為二
            unckSort(list,low,middle-1);//對低字表進行遞迴排序
            unckSort(list,middle+1,high);//對高字表進行遞迴排序
        }
    }
    
    //宣告靜態的 quick() 方法，在該方法中判斷傳入的陣列是否為空，如果不為空，則呼叫 unckSort() 方法進行排序
    public static void quick(int[] str) {
        if(str.length>0) {
            //檢視陣列是否為空
            unckSort(str,0,str.length-1);
        }
    }
    
    //測試
    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();    //獲取開始時間

        int[] number = { 13,15,24,99,14,11,1,2,3,2,32,4321,432,3,14,153,23,42,12,34,15,312,12,43,3214,43214,43214,43214,12,2432,12,34,24,4532,1234};

        quick(number);
        
    
        for (int i : number) {
            System.out.print(i+" ");
        }
        long endTime = System.currentTimeMillis();    //獲取結束時間

        System.out.println("程式執行時間：" + (endTime - startTime) + "ms");    //輸出程式執行時間
        
    }
}

輸出結果，如圖:

半天看不到輸出結果，而程式仍在執行中。如果將陣列中的元素還原為原來那幾個，則很快看到結果。

合併程式碼例子，如下:

package cn.pratice.simple;

import java.util.Arrays;

public class MergeSort {



    private static void mergeSort(int[] original) {
        if (original == null) {
            throw new NullPointerException("The array can not be null !!!");
        }
        int length = original.length;
        if (length > 1) {
            int middle = length / 2;
            int partitionA[] = Arrays.copyOfRange(original, 0, middle);// 拆分問題規模
            int partitionB[] = Arrays.copyOfRange(original, middle, length);
            // 遞迴呼叫
            mergeSort(partitionA);
            mergeSort(partitionB);
            sort(partitionA, partitionB, original);
        }
    }

    private static void sort(int[] partitionA, int[] partitionB, int[] original) {
        int i = 0;
        int j = 0;
        int k = 0;
        while (i < partitionA.length && j < partitionB.length) {
            if (partitionA[i] <= partitionB[j]) {
                original[k] = partitionA[i];
                i++;
            } else {
                original[k] = partitionB[j];
                j++;
            }
            k++;
        }
        if (i == partitionA.length) {
            while (k < original.length) {
                original[k] = partitionB[j];
                k++;
                j++;
            }
        } else if (j == partitionB.length) {
            while (k < original.length) {
                original[k] = partitionA[i];
                k++;
                i++;
            }
        }
    }

    private static void print(int[] array) {
        if (array == null) {
            throw new NullPointerException("The array can not be null !!!");
        }
        StringBuilder sb = new StringBuilder("[");
        for (int element : array) {
            sb.append(element + ", ");
        }
        sb.replace(sb.length() - 2, sb.length(), "]");
        System.out.println(sb.toString());
    }
    
    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();    //獲取開始時間

        int original[] = new int[] { 13,15,24,99,14,11,1,2,3,2,32,4321,432,3,14,153,23,42,12,34,15,312,12,43,3214,43214,43214,43214,12,2432,12,34,24,4532,1234};
        for (int i = 0; i < original.length; i++) {
            System.out.print(original[i]+" ");
        }
        mergeSort(original);
        print(original);
        long endTime = System.currentTimeMillis();    //獲取結束時間

        System.out.println("程式執行時間：" + (endTime - startTime) + "ms");    //輸出程式執行時間
        
    }
}

輸出結果，如圖:

通過兩者對比，我們很容易得出合併排序比快速排序快。

參考這個合併排序和快速排序執行時間比較

作者通過實驗得出一個結論:當資料量較小的時候，快速排序比合並排序執行時間要短，執行時間短就表示快，但是當資料量大的時候，合併排序比快速排序執行時間要短。
由此通過我上述的程式碼實驗和該文章作者試驗，可證實這個結論。