1.直接插入排序。

直接插入的基本思想是每一步將一個數插入到已排序的有序數列中。

python代碼實現：

def direct_insert_sort(l):
    for i in range(1,len(l)):
        key = l[i]
        j = i-1
        while j>=0:
            if key<l[j]:
                l[j+1] = l[j]
                l[j] = key
            j -= 1
    return l
a = [2,3,1,5,4,4]
 

2.Shell排序（希爾排序）。

希爾排序是直接插入排序的改進版本希爾排序是把記錄按下標的一定增量分組，對每組使用直接插入排序算法排序；隨著增量逐漸減少，每組包含的關鍵詞越來越多，當增量減至1時，整個文件恰被分成一組，算法便終止。

python代碼實現：

def shell_sort(l):
    c = len(l)
    step = len(l)//2
    while step>0:
        for i in range(step):
            j = i+step
            while j<c:
                key = l[j]
                p = j-step
                while p>=0:
                    if key<l[p]:
                        l[p+step] = l[p]
                        l[p] = key
                    p -= step
                j += step
        step = step//2
    return l
a = [2,3,1,5,4,4]
print(shell_sort(a))  
 

3.直接選擇排序。

直接選擇排序是每次找到未排序元素中最小的元素放到最前面具體實現是第一趟將第一個元素與後面所有元素比較，小的放前面，第二趟得到第二個元素，這樣直至排序完成。

python代碼實現：

def direct_choice_sort(l):
    for i in range(len(l)-1):
        for j in range(i+1,len(l)):
            if l[j]<l[i]:
                l[i],l[j] = l[j],l[i]
    return l
a = [3,1,4,5,2,2]
print(direct_choice_sort(a))  
 

4.堆排序。

堆排序是一種選擇排序，是用堆結構來完成排序的一種算法，升序用大頂堆，降序用小頂堆；構造大頂堆：一個結點i的左右葉子結點為2i+1,2i+2,最後一個非葉子結點為len(l)//2-1,從最後一個非葉子結點起，開始調整，將大的元素放到父結點上。

python代碼實現：

def heap_sort(l):
    for j in range(len(l),0,-1):
        #j為堆的長度，c為堆的最大非葉子結點索引
        c = (j//2)-1
        #從最大非葉子結點開始調整堆
        for i in range(c,-1,-1):
            if (2*i+1)<=(j-1) and l[2*i+1]>l[i]:
                l[i],l[2*i+1] = l[2*i+1],l[i]
            if (2*i+2)<=(j-1) and l[2*i+2]>l[i]:
                l[i],l[2*i+2] = l[2*i+2],l[i]
        #交換堆頂與最後一個結點
        l[0],l[j-1] = l[j-1],l[0]
    return l
a = [67,65,77,38,97,3,33,49,33]
#heap(a)
print(heap_sort(a))

5.冒泡排序。

冒泡排序是從後向前每次比較相鄰的2個元素大小，大的放後面，這樣一次遍歷第一個元素就是最小的，第二次遍歷第二個元素就是剩下中最小的，這樣直到排序完成。

python代碼實現：

def Bubble_sort(l):
    c = len(l)
    for i in range(1,c):
        for j in range(c-1,i-1,-1):
            if l[j] < l[j-1]:
                l[j],l[j-1] = l[j-1],l[j]
    return l
a = [3,1,4,5,2,2]
print(Bubble_sort(a))  

6.快速排序。

快速排序的思想是每次任意取一個元素，如第一個，將剩下比它小的元素的放到它的前面，大的放到它的後面，這樣這個元素就已經在最終排序完成的位置上了，然後對小的元素和大的元素繼續進行快速排序，這樣直至排序完成。

python代碼實現：

quick_sort = lambda l:l if len(l)<=1 else quick_sort([i for i in l[1:] if i<=l[0]])+[l[0]]+quick_sort([i for i in l[1:] if i>l[0]])        
a = [3,1,4,5,2,2]
print(quick_sort(a))

7.歸並排序。

歸並排序是一個典型的基於分治的遞歸算法。先將原數組分成n個小數組然後兩兩歸並。

歸並過程：先比較l1,l2的第一個元素大小，如果l1大則將l2的第一個元素添加到輸出數組o中，然後l2指向第二個元素繼續比較，這樣直至排序完成。

python代碼實現：

def merge(l1,l2):
    o = []
    a1 = 0;a2 = 0
    if l1==[]:
        return l2
    if l2==[]:
        return l1
    for i in range(len(l1)+len(l2)):
        if a1 == len(l1):
            for j in l2[a2:]:
                o.append(j)
        elif a2 == len(l2):
            for j in l1[a1:]:
                o.append(j)
        else:
            if l1[a1]>=l2[a2]:
                o.append(l2[a2])
                a2 += 1
            else:
                o.append(l1[a1])
                a1 += 1
    return o
def sort(l):
    if len(l)<=1:
        return l
    c = len(l)//2
    return merge(sort(l[:c]),sort(l[c:]))        
a = [67,65,77,38,97,3,33,33]
print(sort(a))  

基數排序寫不出來。。

今天來談談Python中的各種排序總結，含實現代碼