1.快速排序

排序思想：

1.從數列中挑出一個元素，稱為"基準"（pivot）
2.重新排序數列，所有比基準值小的元素放在基準前面，比基準大的元素放在基準後面。在這個分割槽結束之後，該基準就處於數列的中間位置，這就是分割槽操作。
3.遞迴地把小於基準的子數列和大於基準的子數列排序。

最優時間複雜度：O(nlogn)
最壞時間複雜度：O(n2)
穩定性：不穩定

def quick_sort(alist, start, end):
    """快速排序"""
    
    # 遞迴出口
    if start >= end:
        return
 

    # 設起始元素為基準元素
    mid = alist[start]
    # low為序列左邊的由左向右移動的遊標
    low = start
    # high為序列右邊的由右向左移動的遊標
    high = end

    while low < high:
        # 如果low與high未重合，high指向的元素比基準元素大，則high向左移動
        while low < high and alist[high] >= mid:
            high -=1
        # 將high指向的元素放到low的位置上
 

        alist[low] = alist[high]
        # 如果low與high未重合，low指向的元素比基準元素小，則low向右移動
        while low < high and alist[low] < mid:
            low += 1
        # 將low指向的元素放到high的位置上
        alist[high] = alist[low]
        
    # 將基準元素放到該位置
    alist[low] = mid
    # 對基準元素左邊的子序列進行快速排序
    quick_sort(
 
alist,start,low-1)
    # 對基準元素右邊的子序列進行快速排序
    quick_sort(alist,low+1,end)

alist = [4,2,3,7,9,1,8,5,6]
quick_sort(alist,0,len(alist)-1)
print(alist)

氣泡排序

排序思想：

1.比較相鄰的元素。如果第一個比第二個大（升序），就交換他們的位置
2.對每一個相鄰於是做同樣的步驟，從開始第一對到結尾的最後一對，最後的元素會是最大的數
3.針對所有的元素重複以上的步驟
4.每次對元素重複上述步驟，直到沒有任何一對數字需要比較

最優時間複雜度：O(n) （指遍歷一次發現沒有任何可以交換的元素）
最壞時間複雜度：O(n2)
穩定性：穩定

def buble_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]

alist = [4,2,3,7,9,1,8,5,6]
buble_sort(alist)
print(alist)

選擇排序

排序思想：

1.首先，在未排序系列中找到最小（大）元素，存放到排序序列的起始位置；
2.然後，再從剩餘未排序元素中繼續尋找最小（大）元素，然後放到已排序序列的末尾；
3.以此類推，直到所有元素均排序完畢

最優時間複雜度：O(n2)
最壞時間複雜度：O(n2)
穩定性：不穩定

def selection_sort(alist):
    """選擇排序"""
    
    n = len(alist)
    # 需要進行n-1次選擇
    for i in range(n-1):
        # 記錄最小位置
        min_index = i
        # 從i+1位置到末尾選擇出最小資料
        for j in range(i+1,n):
            if alist[j] < alist[min_index]:
                min_index = j
        # 迴圈結束表示找到了最小值，將最小值交換到靠前的位置
        if min_index != i:
            alist[i],alist[min_index] = alist[min_index],alist[i]

alist = [4,2,3,7,9,1,8,5,6]
selection_sort(alist)
print(alist)

插入排序

排序思想：

構建有序序列，對於未排序資料，在已排序序列中從後向前掃描，找到相應位置插入。插入排序在實現上，在從後向前掃描過程中，需要反覆把已排序元素逐步向後移位，給最新元素提供插入空間。

最優時間複雜度：O(n) （序列已經處於升序狀態）
最壞時間複雜度：O(n2)
穩定性：穩定

def insert_sort(alist):
    """插入排序"""
    
    # 從第二個位置，即下標為1的元素開始向前插入
    for i in range(1,len(alist)):
        # 從第i 個元素開始向前比較，如果小於前一個元素，交換位置
        for j in range(i,0,-1):
            if alist[j] < alist[j-1]:
                alist[j],alist[j-1] = alist[j-1],alist[j]

alist = [4,2,3,7,9,1,8,5,6]
insert_sort(alist)
print(alist)

希爾排序

排序思想：

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

最優時間複雜度：根據步長序列的不同而不同
最壞時間複雜度：O(n2)
穩定性：不穩定

def shell_sort(alist):
    n = len(alist) # 列表長度
    # 初始步長
    gap = n // 2
    while gap > 0:
        # 按步長進行插入排序
        for i in range(gap, n):
            j = i
            # 插入排序
            while j >= gap and alist[j - gap] > alist[j]:
                alist[j - gap], alist[j] = alist[j], alist[j - gap]
                j -= gap
        # 得到新的步長
        gap = gap // 2


alist = [4,2,3,7,9,1,8,5,6]
shell_sort(alist)
print(alist)

歸併排序

排序思想：就是先遞迴分解陣列，再合併陣列。

將陣列分解最小之後，然後合併兩個有序陣列，基本思路：比較兩個陣列的最前面的數，誰小就先取誰，相應的指標就往後移一位。然後再比較，直至一個數組為空，最後把另一個數組的剩餘部分切過來即可。

最優時間複雜度：O(nlogn)
最壞時間複雜度：O(nlogn)
穩定性：穩定

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):
    '''合併操作，將兩個有序陣列left[]和right[]合併成一個大的有序陣列'''
    # left與right的下標指標
    l,r = 0,0
    result = []
    while l<len(left) and r < len(right):
        if left[l] <= right[r]:
            result.append(left[l])
            l += 1
        else:
            result.append(right[r])
            r += 1
    result += left[l:]
    result += right[r:]
    return result

alist = [4,2,3,7,9,1,8,5,6]
sorted_alist = merge_sort(alist)
print(sorted_alist)

基數排序

排序思想

基數排序又稱為“桶子法”。以十進位制為例，基數指的是數的位，如個位，十位百位等。
將根據整數的最右邊數字將其扔進相應的0~9號的籃子裡，
對於相同的數字要保持其原來的相對順序（確保排序演算法的穩定性），
然後將籃子裡的數如圖radix_sort.jpg所示的串起來，然後再進行第二趟的收集（按照第二位的數字進行收集），
就這樣不斷的反覆，當沒有更多的位時，串起來的數字就是排好序的數字。

最優時間複雜度：O(d(n+rd))
最壞時間複雜度：O(d(r+n))
穩定性：穩定

def radix_sort(alist):
    bucket, digit = [[]], 0
    while len(bucket[0]) != len(alist):
        bucket = [[], [], [], [], [], [], [], [], [], []]  # 桶
        for i in range(len(alist)):   # 這裡的len為9
            num = (alist[i] // 10 ** digit) % 10
            bucket[num].append(alist[i])  # 在對應的桶中存放對應的數
        alist.clear()
        for i in range(len(bucket)):
            alist += bucket[i]
        digit += 1

alist = [4,2,3,7,9,1,8,5,6]
radix_sort(alist)
print(alist)

堆排序

排序思想

它是選擇排序的一種。可以利用陣列的特點快速定位指定索引的元素。
堆分為大根堆和小根堆，是完全二叉樹。
大根堆的要求是每個節點的值都不大於其父節點的值，即A[PARENT[i]] >= A[i]。
在陣列的非降序排序中，需要使用的就是大根堆，因為根據大根堆的要求可知，最大的值一定在堆頂。

最優時間複雜度：O(nlogn)
最壞時間複雜度：O(nlogn)
穩定性：不穩定

import copy
def heap_sort(alist):
    def heap_adjust(parent):
        child = 2 * parent + 1 
        while child < len(heap):
            if child + 1 < len(heap):
                if heap[child + 1] > heap[child]:
                    child += 1 
            if heap[parent] >= heap[child]:
                break
            heap[parent], heap[child] = heap[child], heap[parent]
            parent, child = child, 2 * child + 1

    heap, alist = copy.copy(alist), []
    for i in range(len(heap) // 2, -1, -1):
        heap_adjust(i)
    while len(heap) != 0:
        heap[0], heap[-1] = heap[-1], heap[0]
        alist.insert(0, heap.pop())
        heap_adjust(0)
    return alist

alist = heap_sort([4,2,3,7,9,1,8,5,6])
print(alist)

以上排序演算法使用python編寫，僅供學習參考。