02 算法之排序

一.冒泡排序

代碼示例：

#將亂序列表中最大元素排列到列表末尾位置
def m_sort(alist):
    for j in range(0,len(alist)-1):
        if alist[j] > alist[j+1]:
            temp = alist[j]
            alist[j] = alist[j+1]
            alist[j+1] = temp
    return alist

def m_sort_final(alist):
    for i in range(0,len(alist)-1):
        for j in range(0,len(alist)-i-1):
            if alist[j] > alist[j+1]:
                temp = alist[j]
                alist[j] = alist[j+1]
                alist[j+1] = temp
    return alist

二.選擇排序

 - 選擇排序改進了冒泡排序，每次遍歷列表只作一次交換。爲了作到這一點，一個選擇排序在他遍歷時尋找最大的值，並在完成遍歷後，將其放置在正確的位置。

def selectionSort(alist):
   for i in range(len(alist)-1,0,-1):
       positionOfMax=0
       for location in range(1,i+1):
           if alist[location]>alist[positionOfMax]:
               positionOfMax = location

       temp = alist[i]
       alist[i] = alist[positionOfMax]
       alist[positionOfMax] = temp

alist = [54,26,93,17,77,31,44,55,20]
selectionSort(alist)
print(alist)

　　- 對於冒泡排序來說選擇排序因爲交換數量的減小，選擇排序一般在基準研究中執行得更快。

三.插入排序

　　- 插入排序的主要思想是每次取一個列表元素與列表中已經排序好的列表段進行比較，而後插入從而獲得新的排序好的列表段，最終得到排序好的列表。好比，待排序列表爲[49,38,65,97,76,13,27,49]，則比較的步驟和獲得的新列表以下：(帶有背景顏色的列表段是已經排序好的，紅色背景標記的是執行插入而且進行過交換的元素）

def insert_sort(alist):

    for j in range(1, len(alist)):
        i = j
        while i > 0:
            if alist[i] < alist[i - 1]:
                alist[i], alist[i - 1] = alist[i - 1], alist[i]
                i -= 1
            else:
                break
    return alist

alist = [3,8,5,7,6]
print(insert_sort(alist))

 

 四.希爾排序

　　- 希爾排序(Shell Sort)是插入排序的一種。也稱縮小增量排序，是直接插入排序算法的一種更高效的改進版本,該方法的基本思想是：先將整個待排元素序列分割成若干個子序列（由相隔某個「增量（gap）」的元素組成的）分別進行直接插入排序，而後依次縮減增量再進行排序，待整個序列中的元素基本有序（增量足夠小）時，再對全體元素進行一次直接插入排序。由於直接插入排序在元素基本有序的狀況下（接近最好狀況），效率是很高的，所以希爾排序在時間效率比直接插入排序有較大提升。

def shell_sort(alist):
    n = len(alist)
    gap = n//2
    while gap >= 1:
        #插入排序
        for j in range(gap,n):
            i = j
            while i > 0:  # i > gap
                if alist[i] < alist[i-gap]:
                    alist[i],alist[i-gap] = alist[i-gap],alist[i]
                    i -= gap
                else:
                    break
        #縮短gap的步長
        gap //= 2

alist = [3,8,5,7,6]
shell_sort(alist)
print(alist)

五.歸併排序

　　- 歸併排序採用分而治之的原理：

　　　　- 將一個序列從中間位置分紅兩個序列；

　　　　- 在將這兩個子序列按照第一步繼續二分下去；

　　　　- 直到全部子序列的長度都爲1，也就是不能夠再二分截止。這時候再兩兩合併成一個有序序列便可。

　　　　　　- 如何合併？

　　　　　　　　下圖中的倒數第三行表示爲第一次合併後的數據。其中一組數據爲 4 8  ，  5 7。該兩組數據合併方式爲：每一小組數據中指定一個指針，指針指向每小組數據的第一個元素，經過指針的偏移指定數據進行有序排列。排列狀況以下：

　　　　　　1. p1指向4，p2指向5，p1和p2指向的元素4和5進行比較，較小的數據歸併到一個新的列表中。通過比較p1指向的4會被添加到新的列表中，則p1向後偏移一位，指向了8，p2不變。

　　　　　　2.p1和p2指向的元素8，5繼續比較，則p2指向的5較小，添加到新列表中，p2向後偏移一位，指向了7。

　　　　　　3.p1和p2指向的元素8，7繼續比較，7添加到新列表中，p2偏移指向NULL，比較結束。

　　　　　　4.最後剩下的指針指向的數據（包含該指針指向數據後面全部的數據）直接添加到新列表中便可。

 

def merge_sort(alist):
    n = len(alist)
    #結束遞歸的條件
    if n <= 1:
        return alist
    #中間索引
    mid = n//2

    left_li = merge_sort(alist[:mid])
    right_li = merge_sort(alist[mid:])

    #指向左右表中第一個元素的指針
    left_pointer,right_pointer = 0,0
    #合併數據對應的列表：該表中存儲的爲排序後的數據
    result = []
    while left_pointer < len(left_li) and right_pointer < len(right_li):
        #比較最小集合中的元素，將最小元素添加到result列表中
        if left_li[left_pointer] < right_li[right_pointer]:
            result.append(left_li[left_pointer])
            left_pointer += 1
        else:
            result.append(right_li[right_pointer])
            right_pointer += 1
    #當左右表的某一個表的指針偏移到末尾的時候，比較大小結束，將另外一張表中的數據（有序）添加到result中
    result += left_li[left_pointer:]
    result += right_li[right_pointer:]

    return result

alist = [3,8,5,7,6]
print(merge_sort(alist))

 六.快速排序

 

def quiteSort(alist,start,end):

    low = start
    height = end
    
    if low >= height:
        return
    mid = alist[low]
    while low < height:
        #從右往左進行判斷
        while low < height:
            if alist[height] >= mid:
                height -= 1
            else:
                alist[low] = alist[height]
                break
        while low < height:
            if alist[low] < mid:
                low += 1
            else:
                alist[height] = alist[low]
                break
    alist[low] = mid
    quiteSort(alist,start,low-1)
    quiteSort(alist,low+1,end)
    
l = [3,8,5,7,6]
quiteSort(l,0,len(l)-1)
print(l)