python演算法與資料結構-快速排序(36)

Se7eN_HOU發表於2019-06-25
Python演算法資料結構排序

 

一、快速排序的介紹

　　快速排序（英語：Quicksort），又稱劃分交換排序（partition-exchange sort），通過一趟排序將要排序的資料分割成獨立的兩部分，其中一部分的所有資料都比另外一部分的所有資料都要小，然後再按此方法對這兩部分資料分別進行快速排序，整個排序過程可以遞迴進行，以此達到整個資料變成有序序列。

二、快速排序的原理

  1. 從數列中挑出一個元素，稱為"基準"（pivot），
  2. 重新排序數列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的後面（相同的數可以到任一邊）。在這個分割槽結束之後，該基準就處於數列的中間位置。這個稱為分割槽（partition）操作。
  3. 遞迴（recursive）把小於基準值元素的子數列和大於基準值元素的子數列排序。

  4. 遞迴的最底部情形，是數列的大小是零或一，也就是永遠都已經被排序好了。雖然一直遞迴下去，但是這個演算法總會結束，因為在每次的迭代（iteration）中，它至少會把一個元素擺到它最後的位置去。

三、快速排序的步驟

  1. 設定兩個變數i、j，排序開始的時候：i=0，j=N-1；
  2. 以第一個陣列元素作為關鍵資料，賦值給key，即key=A[0]；
  3. 從j開始向前搜尋，即由後開始向前搜尋(j--)，找到第一個小於key的值A[j]，將A[j]和A[i]的值交換；
  4. 從i開始向後搜尋，即由前開始向後搜尋(i++)，找到第一個大於key的A[i]，將A[i]和A[j]的值交換；
  5. 重複第3、4步，直到i=j； (3,4步中，沒找到符合條件的值，即3中A[j]不小於key,4中A[i]不大於key的時候改變j、i的值，使得j=j-1，i=i+1，直至找到為止。找到符合條件的值，進行交換的時候i， j指標位置不變。另外，i==j這一過程一定正好是i+或j-完成的時候，此時令迴圈結束）。

四、快速排序的圖解

 

 

五、快速排序的python程式碼實現

def quick_sort(alist,start,end):
    # 遞迴的推出條件，遞迴一定要有出口
    if start>=end:
        return
    
    # 設定起始元素為要尋找為準的基準元素
    k = alist[start]
    # 設定變數i記錄從左到右的查詢
    i = start
    # 設定變數j記錄從右到左的查詢
    j = end
    
    # i<j說明還沒有i和j還沒有碰面，需要繼續比較
    while i<j:
        
        # i<j,並且此時的資料要是都比k的話（從右到左比較）
        while i<j and alist[j]>=k:
            # j就遞減，一直往前找，
            j -= 1
        # 出了while迴圈就說明找到需要交換的資料了
        temp = alist[j]
        alist[j] = alist[i]
        alist[i] = temp
        
        # i<j 並且此時的資料要是都比k小的話（從左右到比較）
        while i<j and alist[i]<=k:
            # i就遞增，一直往後找
            i += 1
        # 出了while迴圈就說明找到需要交換的資料了
        temp = alist[j]
        alist[j] = alist[i]
        alist[i] = temp
    # 然後對左邊的資料使用遞迴繼續排序
    quick_sort(alist,start,i-1)
    # 然後對右邊的資料使用遞迴繼續排序
    quick_sort(alist,i+1,end)

#建立一個陣列
numlist = [6,1,2,7,9,5,4,3,10,8]
print("排序前：%s"%numlist)
quick_sort(numlist,0,len(numlist)-1)
print("排序後：%s"%numlist)

執行結果為：

排序前：[6, 1, 2, 7, 9, 5, 4, 3, 10, 8]
排序後：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

六、快速排序的C言語程式碼實現

#include <stdio.h>

// 建立快速排序函式
void quick_sort(int arr[],int start,int end)
{
    // 遞迴的推出條件，遞迴一定要有出口
    if (start>=end)
    {
        return;
    }
    // 設定起始元素為要尋找為準的基準元素
    int k = arr[start];
    // 設定變數i記錄從左到右的查詢
    int i = start;
    // 設定變數j記錄從右到左的查詢
    int j = end;
    
    // i<j說明還沒有i和j還沒有碰面，需要繼續比較
    while (i<j)
    {
        // i<j,並且此時的資料要是都比k的話（從右到左比較）
        while (i<j&&arr[j]>=k)
        {
            // # j就遞減，一直往前找，
            j--;
        }
        // 出了while迴圈就說明找到需要交換的資料了
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
        
        // i<j 並且此時的資料要是都比k小的話（從左右到比較）
        while (i<j&&arr[i]<=k)
        {
            // i就遞增，一直往後找
            i++;
        }
        // 出了while迴圈就說明找到需要交換的資料了
        temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    // 然後對左邊的資料使用遞迴繼續排序
    quick_sort(arr, start, i-1);
    // 然後對右邊的資料使用遞迴繼續排序
    quick_sort(arr, i+1, end);
}

int main(int argc, const char * argv[])
{
    // 快速排序的函式宣告
    void quick_sort(int arr[],int start,int end);
    // 建立需要排序的陣列
    int array[] = {6,1,2,7,9,5,4,3,10,8};
    // 呼叫快速排序
    quick_sort(array, 0, 9);
    // 列印驗證
    for (int i=0; i<10; i++)
    {
        printf("%d ",array[i]);
    }
    return 0;
}

執行結果為：

1 2 3 4 5 6 7 8 9 10

七、快速排序的時間複雜度

  • 最優時間複雜度：O(nlogn)
  • 最壞時間複雜度：O(n2)

八、快速排序的穩定性

　　快速排序不是一種穩定的排序演算法，也就是說，多個相同的值的相對位置也許會在演算法結束時產生變動。

 

相關文章