1.冒泡排序

# [6,3,9,4,2]
def bubble_sort(li):
    n = len(li)
    # 確定冒泡排序的趟數 n - 1
    for j in range(n - 1): # 0 1 2 3

        count = 0
        # 冒泡排序一趟，把最大的一個數排到最右邊
        for i in range(n - 1 - j): # 0 3 每一趟冒泡 比較的次數越來越少
            if li[i] > li[i + 1]:
                # 交換
                li[i], li[i + 1] = li[i + 1], li[i]
                count 
 
+= 1
        # for循環結束時，如果沒有交換過，證明已經有序，直接返回
        if count == 0:
            break

if __name__ == ‘__main__‘:
    l = [1,1,2,4,5,6]
    # 3, 6, 4, 2, 9
    # i = 3
    # 3,6,4,2,9
    # 3,4,2,6,9
    bubble_sort(l)
    print(l)
    # 最壞時間復雜度：O(n^2)
    # 最優時間復雜度：O(n)
    # 穩定性：穩定

2.選擇排序

# [6,3,9,4,2]
 

def select_sort(li):
    n = len(li)
    # 總共選擇的次數，每次選擇的最小數 放的位置 0 ~ n-1
    for j in range(n - 1):

        # 選擇一次，找出最小的一個數，放到0位置
        temp = j  # 從這個位置開始比較，比較出最小的數放到這個位置
        for i in range(j + 1, n):
            if li[i] < li[temp]:
                temp = i
        # for循環結束時，temp指向最小的數
        #
 
 交換temp和0位置
        li[temp], li[j] = li[j], li[temp]

if __name__ == ‘__main__‘:

    l = [1,2,3,4,5]
    # 2,3,9,4,6
    select_sort(l)
    print(l)
    # 最壞時間復雜度：O(n^2)
    # 最優時間復雜度：O(n^2)
    # 穩定性：不穩定

3.插入排序

# [6,3,9,4,2]
def insert_sort(li):
    n = len(li)
    # 不停的指向插入排序，從1~n-1 位置的數據，依次跟前面有序的序列組成有序
    for j in range(1, n):

        # 把0位置的數認為有序，把下一個位置跟前面組成有序
        for i in range(j, 0, -1):
            if li[i] < li[i - 1]:
                li[i], li[i - 1] = li[i - 1], li[i]
            else:
                break

if __name__ == ‘__main__‘:
    l = [1,2,3,4,5]
    insert_sort(l)
    print(l)

    # 最壞時間復雜度：O(n^2)
    # 最壞時間復雜度：O(n)
    # 穩定性：穩定

4.希爾排序

# [6,1,4,2,5,3]
def shell_sort(li):
    n = len(li)
    # 設置步長，根據步長進行排序
    gap = n//2

    # 不停的改變步長，最後一個步長必須是1
    while gap >= 1:

        for i in range(gap, n):
            while (i - gap) >= 0:
                if li[i] < li[i - gap]:
                    li[i], li[i - gap] = li[i - gap], li[i]
                i -= gap

        gap //= 2
if __name__ == ‘__main__‘:

    l = [6,1,4,2,5,3]
    shell_sort(l)
    # 最壞時間復雜度:O(n^2)
    # 最壞時間復雜度: 跟步長相關
    # 穩定性：不穩定

5.快排

# [6,9,4,8,5,7]

def quick_sort(li, start, end):
    if start>=end:
        return
    # 左邊角標
    left = start
    # 右邊角標
    right = end
    # 把0位置的數作為中間值
    mid = li[left]

    while left < right:

        # 右邊的角標往左移動，找的一個小於中間值的數，把數放到左邊角標位置
        while left < right and li[right] >= mid:
            right -= 1
        # 當white循環結束時，right指向的值小於mid
        li[left] = li[right]

        # 左邊的角標往右移動，找的一個大於中間值的數，把數放到右邊邊角標位置
        while left < right and li[left] <= mid:
            left += 1
        li[right] = li[left]
    # while結束，left=right，把中間值賦值到這個位置
    li[left] = mid

    # 排序左邊的數據
    quick_sort(li, start, left-1)
    # 排序右邊的數據
    quick_sort(li, left+1, end)

if __name__ == ‘__main__‘:
    l = [6,8,4,4]
    quick_sort(l,0,len(l)-1)
    print(l)
    # 最壞時間復雜度 ： O(n^2)
    # 最優時間復雜度 ： O(nlogn)
    # 穩定性：不穩定

6.歸並排序

# [7,6,8,  9,10,2,1]

def merge_sort(li):
    if len(li) == 1:
        # print(li)
        return li
        # 獲取中間位置
    mid = len(li) // 2

    # 拆分左右各一半
    left = li[:mid]
    right = li[mid:]

    # print(left)
    # print(right)

    # 遞歸拆分
    left_res = merge_sort(left)
    right_res = merge_sort(right)
    # result = left_res + right_res
    # print(result)
    # 合並排序
    result = merge(left_res,right_res)
    return result


def merge(left, right):
    # 把下層方法返回的數據進行排序
    # [6] [8]
    # [5,7,9] [6,8]
    # 5 6 7
    res = []
    left_index = 0
    right_index = 0

    while left_index < len(left) and right_index < len(right):

        if left[left_index] <= right[right_index]:
            res.append(left[left_index])
            left_index += 1
        else:
            res.append(right[right_index])
            right_index += 1
    # while結束後，把剩下的數據全部添加
    res += right[right_index:]
    res += left[left_index:]
    return res


if __name__ == ‘__main__‘:
    l = [7, 8, 6, 9, 10, 2, 1]
    print(merge_sort(l))

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

Python實現常見的排序算法