python算法與數據結構-快速排序算法(36)

 

1、快速排序的介紹

  快速排序(英語:Quicksort),又稱劃分交換排序(partition-exchange sort),經過一趟排序將要排序的數據分割成獨立的兩部分,其中一部分的全部數據都比另一部分的全部數據都要小,而後再按此方法對這兩部分數據分別進行快速排序,整個排序過程能夠遞歸進行,以此達到整個數據變成有序序列。python

2、快速排序的原理

  1. 從數列中挑出一個元素,稱爲"基準"(pivot),
  2. 從新排序數列,全部元素比基準值小的擺放在基準前面,全部元素比基準值大的擺在基準的後面(相同的數能夠到任一邊)。在這個分區結束以後,該基準就處於數列的中間位置。這個稱爲分區(partition)操做。
  3. 遞歸(recursive)把小於基準值元素的子數列和大於基準值元素的子數列排序。
  4. 遞歸的最底部情形,是數列的大小是零或一,也就是永遠都已經被排序好了。雖然一直遞歸下去,可是這個算法總會結束,由於在每次的迭代(iteration)中,它至少會把一個元素擺到它最後的位置去。算法

3、快速排序的步驟

  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. 重複第三、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-完成的時候,此時令循環結束)。

4、快速排序的圖解

 

 

5、快速排序的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]

6、快速排序的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

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

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

8、快速排序的穩定性

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

相關文章
相關標籤/搜索