2. 程式人生 > >演算法圖解之快速排序

演算法圖解之快速排序

阿新 • • 發佈：2019-06-01

分而治之(又稱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");    //輸出程式執行時間
        
    }
}

輸出結果，如圖:

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

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

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

相關推薦

演算法圖解之快速排序

分而治之(又稱D&C) 書中舉了一個例子，假設你是農場主，有一塊土地，如圖所示:   你要將這塊地均勻分成方塊，且分出的方塊要儘可能大。     從圖上看，顯然是不符合預期結果的。那麼如何將一塊地均勻分成方塊，並確保分出的方塊是最大的呢？使用D&

資料結構與演算法C++之快速排序（續）

上一篇部落格資料結構與演算法C++之快速排序介紹了快速排序演算法。 但是上面實現的快速排序有兩個缺點： （一）對於近乎有序的陣列，演算法的計算複雜度由O(nlogn)退化到O(n2) （二）如果陣列中存在大量重複的元素，那麼演算法的計算複雜度也會退化到O(n2) （一）對於近乎有序的

資料結構與演算法C++之快速排序

快速排序是一種比歸併排序還要快的排序演算法，具體原理如下圖所示 對上圖所示的陣列，首先隨機選取一個參照元素，一般選取最左邊的元素4為參照元素，然後將陣列排序成以4為分界點，左邊都是小於4的元素，右邊都是大於4的元素，按照這種方式進行不斷遞迴，就可實現整個陣列的排序。 上圖顯示的是程式

排序演算法大雜燴之快速排序

排序演算法大雜燴主幹文章傳送門 快速排序 接著主文章結構繼續分析快速排序 快速排序實現主流上分為兩種，第一種為快排的開山鼻祖 C

java八大排序演算法(五)之快速排序——三數取中法

圖解排序演算法(五)之快速排序——三數取中法 快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：通過一趟排序將要排序的資料分割成獨立的兩部分，其中一部分的所有資料都比另外一部分的所有資料都要小，然後再按此方法對這兩部分資料分別進行快速排序，整個排序過程可以遞迴進行，

排序演算法總結之快速排序

一，快速排序介紹 快速排序與歸併排序一樣，也是基於分治的遞迴演算法，體現在：在每一趟快速排序中，需要選出樞軸元素，然後將比樞軸元素大的陣列元素放在樞軸元素的右邊，比樞軸元素小的陣列元素都放在樞軸元素的左邊。然後，再對分別對 樞軸元素左邊 和 樞軸元素右邊的元素進行快速排序。 二，快速排序演算法分析

排序演算法5之快速排序

快速排序 很早就聽說了快速排序的大名，然後看演算法導論的相關視訊也感覺講的很有意思，現在總結一下。針對待排序陣列{a1,a2……an}快速排序可以分解為三步： 尋找基準數，比較通常就是選擇待排序的首專案或者中間專案； 2.根據與基準數的大小關係， 將待排

圖解排序演算法（五）之快速排序

選取一個樞紐，使它左邊的值都比它小，右邊的值比它大。（假定選陣列第一個元素值） int Partition(int* array, int low, int high) { int pivotkey; pivotkey = array[low];

《算法圖解》之快速排序

pre pivot else col style int ESS 清晰 quick 這個就明顯代碼清晰，且效率會比選擇排序要好的。 用到了遞歸的喲~：） def quicksort(array): if len(array) < 2:

經典排序演算法之--快速排序

快速排序是一種高效但不穩的排序演算法，不穩性取決於比較基數的選擇帶有隨機性，其排序原理應用百度百科如下： 設要排序的陣列是A[0]……A[N-1]，首先任意選取一個數據（通常選用陣列的第一個數）作為關鍵資料，然後將所有比它小的數都放到它前面，所有比它大的數都放到它後面，這個過程稱為一趟快速排

c#程式碼實現排序演算法之快速排序

快速排序的平均時間複雜度為O（nlog2n），最好時間複雜度為O（nlog2n），最壞時間複雜度為O（n²），空間複雜度為O（log2n），是一種不穩定的演算法。 1.劃分：選定一個記錄作為軸值，以軸值為基準將整個序列劃分為兩個子序列r(1)…r(i-1)和r(i+1)…r(n)

基礎演算法--排序：之快速排序

與簡單排序不同，快序排序所需的比較次數較少，是內部排序中速度較快的一種排序方法。    演算法思想： 分-------------- 將待排序集合劃分為2部分 （一部分小於準則值，一部分大於等於準則值）      &n

常見排序演算法之快速排序

文章目錄 前言 思路 實現過程 基本演算法 切分方法 複雜度分析 最優時間複雜度的數學證明 演算法改進 切換到插入排序 三取樣切分 三向

PHP排序演算法之快速排序

原理：找到當前陣列中的任意一個元素（一般選擇第一個元素），作為標準，新建兩個空陣列left、rignt，遍歷整個陣列元素，如果遍歷到的元素比當前的元素小就放到陣列left，比當前的元素大放到rignt，然後再對新陣列進行同樣的操作。 遞迴：遞迴是一種函式呼叫自身的機制。遞迴必須要有邊界條件，也就是遞迴出口（

排序演算法之快速排序【java實現】

快速排序是最常用的排序演算法之一，它的平均時間複雜度是O(nlogn)，但是它是一個不穩定的演算法。 步驟： 我們要找到一個基值，將小於基值的放在它的左邊，大於它的放在它的右邊。基值我們直接用陣列最左邊的值就行。每次排序會把基值放在正確的位置上，在根據這個值把陣列分成左右兩部分，在進行遞迴處

排序演算法之快速排序（關鍵詞：資料結構/演算法/排序演算法/快速排序）

快速排序 實現 def partition(nums, left, right): middle = (left+right) // 2 pivot = nums[middle] swap(nums, middle, right) # 現在主元 pivot 等於 num

java版排序演算法之快速排序

快速排序的思想 快速排序是通過切分的方式將大陣列切分為左右兩個子陣列，分別對兩個子陣列進行遞迴的切分，當左右兩個子陣列都有序時整個陣列便有序了。 程式碼實現 public clas

資料結構與演算法之快速排序

快速排序顧名思義，在大部分情況下都能快速的將資料進行排序。百度百科快速排序的定義：通過一趟排序將要排序的資料分成獨立的兩部分，其中一部分的資料比另一部分的所有資料都要小，然後再按照這個方法對這兩部分進行快速排序，排序以遞迴進行，從而達到將整個資料變成有序序列。快速排序的平均執

排序演算法之快速排序的非遞迴實現

在之前的部落格中提到過快速排序的三種實現方式，不過都是通過遞迴來實現，今天我們將會利用棧來實現快速排序。 -----------------------------------Stack.h----------------------------------------

程式猿修仙之路--演算法之快速排序到底有多快

  快排