python實現希爾排序(已編程實現)

 

希爾排序：

觀察一下」插入排序「：其實不難發現她有個缺點：

　　若是當數據是」5, 4, 3, 2, 1「的時候，此時咱們將「無序塊」中的記錄插入到「有序塊」時，估計俺們要崩盤，

每次插入都要移動位置，此時插入排序的效率可想而知。

   

　　shell根據這個弱點進行了算法改進，融入了一種叫作「縮小增量排序法」的思想，其實也蠻簡單的，不過有點注意的就是：

增量不是亂取，而是有規律可循的。

 

希爾排序時效分析很難，關鍵碼的比較次數與記錄移動次數依賴於增量因子序列d的選取，特定狀況下能夠準確估算出關鍵碼的比較次數和記錄的移動次數。目前尚未人給出選取最好的增量因子序列的方法。增量因子序列能夠有各類取法，有取奇數的，也有取質數的，但須要注意：增量因子中除1 外沒有公因子，且最後一個增量因子必須爲1。希爾排序方法是一個不穩定的排序方法。

 

首先要明確一下增量的取法(這裏圖片是copy別人博客的，增量是奇數，我下面的編程用的是偶數)：

      第一次增量的取法爲： d=count/2;

      第二次增量的取法爲:  d=(count/2)/2;

      最後一直到: d=1;

 

好，注意看圖了，第一趟的增量d1=5, 將10個待排記錄分爲5個子序列，分別進行直接插入排序，結果爲(13, 27, 49, 55, 04, 49, 38, 65, 97, 76)

第二趟的增量d2=3, 將10個待排記錄分爲3個子序列，分別進行直接插入排序，結果爲(13, 04, 49, 38, 27, 49, 55, 65, 97, 76)

第三趟的增量d3=1, 對整個序列進行直接插入排序，最後結果爲(04, 13, 27, 38, 49, 49, 55, 65, 76, 97)

 

重點來了。當增量減少到1時，此時序列已基本有序，希爾排序的最後一趟就是接近最好狀況的直接插入排序。可將前面各趟的"宏觀"調整當作是最後一趟的預處理，比只作一次直接插入排序效率更高。

 

本人是學python的，今天用python實現了希爾排序。

 1 def ShellInsetSort(array, len_array, dk):  # 直接插入排序
 2     for i in range(dk, len_array):  # 從下標爲dk的數進行插入排序
 3         position = i  4         current_val = array[position]  # 要插入的數
 5 
 6         index = i  7         j = int(index / dk)  # index與dk的商
 8         index = index - j * dk  9 
10         # while True: # 找到第一個的下標，在增量爲dk中，第一個的下標index必然 0<=index<dk
11         # index = index - dk
12         # if 0<=index and index <dk:
13         # break
14 
15 
16         # position>index,要插入的數的下標必須得大於第一個下標
17         while position > index and current_val < array[position-dk]: 18             array[position] = array[position-dk]  # 日後移動
19             position = position-dk 20         else: 21             array[position] = current_val 22 
23 
24 
25 def ShellSort(array, len_array):  # 希爾排序
26     dk = int(len_array/2)  # 增量
27     while(dk >= 1): 28  ShellInsetSort(array, len_array, dk) 29         print(">>:",array) 30         dk = int(dk/2) 31 
32 if __name__ == "__main__": 33     array = [49, 38, 65, 97, 76, 13, 27, 49, 55, 4] 34     print(">:", array) 35     ShellSort(array, len(array))

輸出:

>: [49, 38, 65, 97, 76, 13, 27, 49, 55, 4]
>>: [13, 27, 49, 55, 4, 49, 38, 65, 97, 76]
>>: [4, 27, 13, 49, 38, 55, 49, 65, 97, 76]
>>: [4, 13, 27, 38, 49, 49, 55, 65, 76, 97]

首先你得先會插入排序，不會你必然看不懂。

 

插入排序，便是對上圖三個黃色框中的數進行插入排序。舉個例子：13，55，38，76

直接看55，55<13, 不用移動。接着看38，38<55，那麼55後移，數據變爲[13，55，55，76]，接着比較13<38, 那麼38替換55，變成[13，38，55，76]。其它同理，略。

這裏有個問題，好比第二個黃色框[27，4，65]，4<27, 那27日後移，接着4就替換第一個，數據變成[4，27，65]，可是計算機怎麼知道4就是在第一個啊??

個人作法是，先找出[27，4，65]第一個數的下標，在這個例子中27的下標爲1。當要插入的數的下標大於第一個下標1時，才能夠日後移，前一個數不能夠日後移有兩種狀況，一種是前面有數據，且小於要插入的數，那你只能插在它後面。另外一種，很重要，當要插入數比前面全部數都小時，那插入數確定是放在第一個，此時要插入數的下標＝第一個數的下標。(這段話，感受初學者應該不大懂……)

 

爲了找到第一個數的下標，最開始想的是用循環，一直到最前面:

        while True:  # 找到第一個的下標，在增量爲dk中，第一個的下標index必然 0<=index<dk
            index = index - dk
            if 0<=index and index <dk:
                break

在Debug時，發現用循環太浪費時間了，特別是當增量d=1時，直接插入排序爲了插入列表最後一個數，得循環減1，直到第一個數的下標，後來我學聰明瞭，用下面的方法:

        j = int(index / dk)  # index與dk的商
        index = index - j * dk

時間複雜度:

希爾排序的時間複雜度是所取增量序列的函數，尚難準確分析。有文獻指出，當增量序列爲d[k]=2^(t-k+1)時，希爾排序的時間複雜度爲O(n^1.5), 其中t爲排序趟數。

穩定性: 不穩定

 

希爾排序效果:

 

 

參考資料: 編程是我本身實現的。建議Debug看看運行過程
http://blog.csdn.net/hguisu/article/details/7776068#t2

http://www.blogjava.net/todayx-org/archive/2012/01/08/368091.html

http://www.cnblogs.com/huangxincheng/archive/2011/11/20/2255695.html