幾種常見算法（基於Python）

1.冒泡排序

冒泡排序(dubble sort)：它重複地遍歷要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。遍歷數列的工作是重複地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個算法的名字由來是因爲越小的元素會經由交換慢慢“浮”到數列的頂端。
冒泡排序算法的運作如下：

1.比較相鄰的元素。如果第一個比第二個大（升序），就交換他們兩個。
2.對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。這步做完後，最後的元素會是最大的數。
3.針對所有的元素重複以上的步驟，除了最後一個。
4.持續每次對越來越少的元素重複上面的步驟，直到沒有任何一對數字需要比較。

實現：

def bubble_sort(alist):
    for j in range(len(alist)-1,0,-1):
        # j表示每次遍歷需要比較的次數，是逐漸減小的
        for i in range(j):
            if alist[i] > alist[i+1]:
                alist[i], alist[i+1] = alist[i+1], alist[i]

li = [54,26,93,17,77,31,44,55,20]
bubble_sort(li)

2.選擇排序

**選擇排序(Selection sort)**是一種簡單直觀的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然後，再從剩餘未排序元素中繼續尋找最小（大）元素，然後放到已排序序列的末尾。以此類推，直到所有元素均排序完畢。

選擇排序的主要優點與數據移動有關。如果某個元素位於正確的最終位置上，則它不會被移動。選擇排序每次交換一對元素，它們當中至少有一個將被移到其最終位置上，因此對n個元素的表進行排序總共進行至多n-1次交換。在所有的完全依靠交換去移動元素的排序方法中，選擇排序屬於非常好的一種。

def select_sort(aList):
    for i in range(len(aList)):
        max_index = i     # 當前值爲最大
        for j in range(i, len(aList)):
            if aList[j] > aList[max_index]:
                aList[j], aList[max_index] = aList[max_index], aList[j]
    return aList

插入排序

插入排序(Insertion Sort)：通過構建有序序列，對於未排序數據，在已排序序列中從後向前掃描，找到相應位置並插入。插入排序在實現上，在從後向前掃描過程中，需要反覆把已排序元素逐步向後挪位，爲最新元素提供插入空間。

def insert_sort(aList):
    for i in range(len(aList)):
        for j in range(i, len(aList)):
            if aList[i] > aList[j]:
                aList[i:j + 1] = [aList[j]] + aList[i:j]
    return aList

希爾排序

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

def shell_sort(aList):
    gap = len(aList) // 2
    while gap > 0:
        for i in range(gap, len(aList)):
            while i >= gap and aList[i-gap] > aList[i]:
                aList[i-gap], aList[i] = aList[i], aList[i-gap]
                i -= gap
        gap //= 2
    return aList

快速排序

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

步驟爲：

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

def quick_sort(aList, start, end):
    if start >= end:
        return
    i, j = start, end
    base = aList[i]    # 設置基準數字
    while i < j:
        while (i < j) and (aList[j] >= base):
            j -= 1
        aList[i] = aList[j]
        while (i < j) and (aList[i] <= base):
            i += 1
        aList[j] = aList[i]
    aList[i] = base
    quick_sort(aList, start, i - 1)
    quick_sort(aList, i + 1, end)
    return aList

歸併排序

歸併排序(merge sort):採用分治法的一個非常典型的應用。歸併排序的思想就是先遞歸分解數組，再合併數組。將數組分解最小之後，然後合併兩個有序數組，基本思路是比較兩個數組的最前面的數，誰小就先取誰，取了後相應的指針就往後移一位。然後再比較，直至一個數組爲空，最後把另一個數組的剩餘部分複製過來即可。

def merge_sort(aList):
    if len(aList) <= 1:
        return aList
    num = len(aList) // 2
    left = merge_sort(aList[:num])
    right = merge_sort(aList[num:])
    return merge(left, right)


def merge(left, right):
    res = []
    l, r = 0, 0
    while l < len(left) and r < len(right):
        if left[l] < right[r]:
            res.append(left[l])
            l += 1
        else:
            res.append(right[r])
            r += 1
    res += left[l:]
    res += right[r:]
    return res

算法比較