數據結構與算法（5）——排序與搜索Ⅲ

一、希爾排序

1.簡介

希爾排序(Shell Sort)是插入排序的一種。也稱縮小增量排序，是直接插入排序算法的一種更高效的改進版本。希爾排序是非穩定排序算法。該方法因DL．Shell於1959年提出而得名。希爾排序是把記錄按下標的一定增量分組，對每組使用直接插入排序算法排序；隨着增量逐漸減少，每組包含的關鍵詞越來越多，當增量減至1時，整個文件恰被分成一組，算法便終止。

2.希爾排序過程

希爾排序的基本思想是：將數組列在一個表中並對列分別進行插入排序，重複這過程，不過每次用更長的列（步長更長了，列數更少了）來進行。最後整個表就只有一列了。將數組轉換至表是爲了更好地理解這算法，算法本身還是使用數組進行排序。

例如，假設有這樣一組數[ 13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10 ]，如果我們以步長爲5開始進行排序，我們可以通過將這列表放在有5列的表中來更好地描述算法，這樣他們就應該看起來是這樣(豎着的元素是步長組成)：

13 14 94 33 82
25 59 94 65 23
45 27 73 25 39
10

然後我們對每列進行排序：

10 14 73 25 23
13 27 94 33 39
25 59 94 65 82
45

將上述四行數字，依序接在一起時我們得到：[ 10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45 ]。這時10已經移至正確位置了，然後再以3爲步長進行排序：

10 14 73
25 23 13
27 94 33
39 25 59
94 65 82
45

排序之後變爲：

10 14 13
25 23 33
27 25 59
39 65 73
45 94 82
94

最後以1步長進行排序（此時就是簡單的插入排序了）

3.希爾排序的分析

程序實現：

def shell_sort(alist):
    n = len(alist)
    # 初始步長
    step = n // 2
    #最外層：控制step長度
    while step>=1:
        # 外層：按步長進行插入排序
        for i in range(step,n):
            j=i
            #內層：按照上面的例子，這一步就是完成每一列的排序
            while j>=step and alist[j] < alist[j - step]:
                alist[j], alist[j - step] = alist[j - step], alist[j]
                j-=step #j每次都是和前面距離長度爲step的位置比較
        step //= 2

li = [23, 86, 52, 13, 45, 76, 19, 33, 62]
print(li)
shell_sort(li)
print(li)

4.時間複雜度

• 最優時間複雜度：根據步長序列的不同而不同
• 最壞時間複雜度：O(n^2)
• 穩定想：不穩定

二、快速排序

1.簡介

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

2.步驟

從數列中挑出一個元素，稱爲"基準"（pivot），
重新排序數列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的後面（相同的數可以到任一邊）。在這個分區結束之後，該基準就處於數列的中間位置。這個稱爲分區（partition）操作。
遞歸地（recursive）把小於基準值元素的子數列和大於基準值元素的子數列排序。
遞歸的最底部情形，是數列的大小是零或一，也就是永遠都已經被排序好了。雖然一直遞歸下去，但是這個算法總會結束，因爲在每次的迭代（iteration）中，它至少會把一個元素擺到它最後的位置去。

3.快速排序的分析

代碼實現：

def quick_sort(alist, start, end):
    """快速排序"""
    # 遞歸的退出條件
    if start >= end:
        return
    # 設定起始元素爲要尋找位置的基準元素
    mid=alist[start]
    low=start
    high=end
    while low < high:
        # 如果low與high未重合，high指向的元素不比基準元素小，則high向左移動
        while low < high and alist[high] >= mid:
            high -= 1
        # 將high指向的元素放到low的位置上
        alist[low] = alist[high]

        while low < high and alist[low] <mid:
            low += 1
        # 將high指向的元素放到low的位置上
        alist[high] = alist[low]
    # 退出循環後，low與high重合，此時所指位置爲基準元素的正確位置
    # 將基準元素放到該位置
    alist[low] = mid
    # 對基準元素左邊的子序列進行快速排序
    quick_sort(alist, start, low - 1)
    # 對基準元素右邊的子序列進行快速排序
    quick_sort(alist, low + 1, end)

li = [23, 86, 52, 13, 45, 76, 19, 33, 62]
print(li)
quick_sort(li,0,len(li)-1)
print(li)

4.時間複雜度

• 最優時間複雜度：O(nlogn)
• 最壞時間複雜度：O(n^2)
• 穩定性：不穩定

從一開始快速排序平均需要花費O(nlogn)時間的描述並不明顯。但是不難觀察到的是分區運算，數組的元素都會在每次循環中走訪過一次，使用O(n)的時間。在使用結合（concatenation）的版本中，這項運算也是O(n)。

在最好的情況，每次我們運行一次分區，我們會把一個數列分爲兩個幾近相等的片段。這個意思就是每次遞歸調用處理一半大小的數列。因此，在到達大小爲一的數列前，我們只要作log n次嵌套的調用。這個意思就是調用樹的深度是O(logn)。但是在同一層次結構的兩個程序調用中，不會處理到原來數列的相同部分；因此，程序調用的每一層次結構總共全部僅需要O(n)的時間（每個調用有某些共同的額外耗費，但是因爲在每一層次結構僅僅只有O(n)個調用，這些被歸納在O(n)係數中）。結果是這個算法僅需使用O(n log n)時間。