轉載：記錄python幾個演算法：

轉載自：http://blog.csdn.net/laodengbaiwe0838/article/details/52373891
（一）插入排序

插入排序原址排序輸入的數，演算法在陣列A中重排這些數，

在任何時候，最多隻有常數個數字儲存在陣列外部。

插入排序是原地排序，基本無需外部空間。

從第二個元素開始，依次遍歷全部陣列。

其中，前半截為已排好的有序陣列而後半截為待排序的無序陣列。

每個元素從後向前依次對比，直到找到自己的位置。

插入排序是穩定排序。

def insert_sort(list1):
    for j in range(1,len(list1)): # 從第二個元素開始遍歷，依次將元素放在指定位置
        key = list1[j] #記錄當前值
        i = j -1 #將當前值從當前位置之前逆序依次比較
        while i>=0 and list1[i] >key:#如果當前值小於之前值，則說明當前值位於之前值的前面
            list1[i+1] = list1[i] #將大於當前值的元素依次後移一位，給當前值留位置
            i -=1
        list1[i+1] = key # 將當前值插入第一個小於它的值的後面
    return list1

if __name__ == "__main__":
    list1 = [380,22,64,75,327,98]
    list2 = ["wang","zhe","tian","jin","da","xue"]
    ordered_list1 = insert_sort(list1)
    ordered_list2 = insert_sort(list2)
    print(ordered_list1) #[2,3,4,5,6,7]
    print(ordered_list2) #['da']

（2）氣泡排序

氣泡排序原址排序輸入的數，演算法在陣列A中重排這些數，

在任何時候，最多隻有常數個數字儲存在陣列外部。

氣泡排序是原地排序，基本無需外部空間。

氣泡排序依次迴圈陣列，每輪迴圈從前向後依次比較兩個元素，排列使得後一個元素總是大於前一個元素。

因此，每輪迴圈可以保證當前未排序的列表中最大的元素放置在列表末尾。

即每輪迴圈後，可以使得未排序的列表長度減1。

重複直到列表僅剩唯一一個元素。

氣泡排序是穩定排序。

Python實現程式碼如下：

1. # -*- coding: utf-8 -*-  
   def bubbleSort(bubbleList):  
       listLength = len(bubbleList)   #計算排序列表的長度  
       while listLength > 0:  
           for i in range(listLength - 1):  
               if bubbleList[i] > bubbleList[i+1]:  
                  temp = bubbleList[i+1]  
                  bubbleList[i+1] = bubbleList[i]  
                  bubbleList[i] = temp   #交換bubbleList[i]與bubbleList[i+1]的值  
           listLength -= 1   #每輪排序結束後，最後一個元素已經是最大的。因此只需要排前N-1個元素即可。  
       return bubbleList  
         
   if __name__ == '__main__':  
       list1 = [3,2,4,6,7,5]  
       list2 = ["wang", "zhe", "tian", "jin", "da", "xue"]  
       ordered_list1 = bubbleSort(list1)  
       ordered_list2 = bubbleSort(list2)  
       print(ordered_list1) #[2, 3, 4, 5, 6, 7]  
       print(ordered_list2) #['da', 'jin', 'tian', 'wang', 'xue', 'zhe'] 
   

（3）

歸併排序（MERGE-SORT）是建立在歸併操作上的一種有效的排序演算法,該演算法是採用分治法（Divide and Conquer）的一個非常典型的應用。

將已有序的子序列合併，得到完全有序的序列；即先使每個子序列有序，再使子序列段間有序。

歸併排序是透過遞迴和合並來實現的。

即首先將一個列表分為兩個字列表，字列表長度為1。然後在依次合併，使得合成的列表有序。

歸併排序的時間複雜度是nlogn。空間複雜度是n。

歸併排序是穩定排序。

Python的實現程式碼如下：

# -*- coding: utf-8 -*-  
def mergeSort(lists):  
    if len(lists) <= 1:  #當陣列長度為1時，則無需排序。  
        return lists  
    num = int(len(lists) / 2)  #將一個陣列分為兩個部分  
    left = mergeSort(lists[:num])  #分別對左右兩個部分進行排序  
    right = mergeSort(lists[num:])  
    return merge(left, right)   #將左右兩個有序陣列合併為一個有序陣列  
      
def merge(left, right):  
    r, l = 0, 0  #初始化左右索引為0  
    result = []   #初始化結果列表  
    while l < len(left) and r < len(right): #當左右索引都尚未達到列表長度時。  
        if left[l] < right[r]:               #如果左列表的值小於右列表的值  
            result.append(left[l])           #將左列表當前值存入結果列表中  
            l += 1                           #左列表索引加1  
        else:  
            result.append(right[r])          #否則將右列表當前值存入結果列表中  
            r += 1                          #右列表索引加1  
    result += right[r:]                     #將剩餘元素存入結果列表中  
    result += left[l:]  
    return result  
      
if __name__ == '__main__':  
    list1 = [3,2,4,6,7,5]  
    list2 = ["wang", "zhe", "tian", "jin", "da", "xue"]  
    ordered_list1 = mergeSort(list1)  
    ordered_list2 = mergeSort(list2)  
    print (ordered_list1) #[2, 3, 4, 5, 6, 7]  
    print (ordered_list2) #['da', 'jin', 'tian', 'wang', 'xue', 'zhe']

（4）

快速排序是指：

透過一趟排序將要排序的資料分割成獨立的兩部分，其中一部分的所有資料都比另外一部分的所有資料都要小，然後再按此方法對這兩部分資料分別進行快速排序，整個排序過程可以遞迴進行，以此達到整個資料變成有序序列。

快速排序在平均情況下時間複雜度為nlogn。

但是在最壞情況（本身為正序或者逆序時），時間複雜度為n*n。

快速排序是不穩定排序。即對於本身值相同的元素，在經過快速排序後，元素的先後位置可能會發生變化。

一趟快速排序的演算法是：

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的實現方式如下：

# -*- coding: utf-8 -*-  
def quickSortFunction(L, low, high):  
    i = low     #i表示被排序列表的起點  
    j = high    #j表示被排序列表的終點  
    if i >= j: #若當起點和終點重合或起點在終點後時，則無需進一步排序  
        return L  
    key = L[i]       #將起點元素選為被對比元素  
    while i < j:                            #當起點與終點尚未重合時  
        while i < j and L[j] >= key:       #找到第一個小於key的元素的位置  
            j -= 1  
        L[i] = L[j]              #將第一個小於key元素的值放入key元素的位置  
        while i < j and L[i] <= key:   #找到第一個大於key元素值，放入剛才小於key元素的位置  
            i += 1  
        L[j] = L[i]  
    L[i] = key    #當i和j重合時，將key元素放置在重合位置。表示該位置前的元素都小於該元素，而該位置後的元素都大於該元素。  
    quickSortFunction(L, low, i-1)   #利用歸併的方法繼續對low到i-1和j+1到high的部分進行排序  
    quickSortFunction(L, j+1, high)  
    return L  
      
def quickSort(list1):              #呼叫quickSortFunction進行快速排序  
    return quickSortFunction(list1, 0, len(list1)-1)  #low和high分別為0和len-1，表示對列表整體進行快速排序  
      
if __name__ == '__main__':  
    list1 = [3,2,4,6,7,5,1,8,10,9]  
    list2 = ["wang", "zhe", "tian", "jin", "da", "xue"]  
    ordered_list1 = quickSort(list1)  
    ordered_list2 = quickSort(list2)  
    print (ordered_list1)             #[2, 3, 4, 5, 6, 7]  
    print (ordered_list2)             #['da', 'jin', 'tian', 'wang', 'xue', 'zhe']  


（5）堆排序(Heapsort)是指利用堆積樹（堆）這種資料結構所設計的一種排序演算法，它是選擇排序的一種。

可以利用陣列的特點快速定位指定索引的元素。堆分為大根堆和小根堆，是完全二叉樹。大根堆的要求是每個節點的值都不大於其父節點的值，即A[PARENT[i]] >= A[i]。

在陣列的非降序排序中，需要使用的就是大根堆，因為根據大根堆的要求可知，最大的值一定在堆頂。

堆排序首先將待排序的陣列存入堆中，並將堆構造為最大/最小堆。再依次從堆中取出堆頂元素，從而得到有序陣列。

構造堆時，所用的方法為從最底層有子節點的節點開始依次向上處理。

取出頂元素恢復堆時則是先將末尾元素與頂元素交換位置，在對頂元素進行下沉處理即可。

堆排序是不穩定排序。即相同的元素再經過堆排序後，其先後位置可能發生變化。

堆排序的時間複雜度為N*logN。

Python的程式碼實現如下：