Python——排序實現

冒泡排序

1. 時間複雜度：

   最優時間複雜度：O(n)(表示遍歷一次沒有發現任何可以交換的元素，排序結束)
   最壞時間複雜度：O(n**2)

2. 穩定性：穩定

def bubble_sort(alist):
    n = len(alist)
    for j in range(n-1):
        # print('')
        count = 0
        for i in range(n-1-j):
            if alist[i] > alist[i+1]:
                alist[i],alist[i+1] = alist[i+1],alist[i]
                count += 1
        if count == 0:
            break

對一萬個數據進行排序時間：



排序三次，平均時間爲11.82

選擇排序

1. 時間複雜度

   最優時間複雜度：O(n2)
   最壞時間複雜度：O(n2)

2. 穩定性：

   不穩定（考慮升序每次選擇最大的情況）

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

對一萬個數據進行排序時間：



排序三次，平均時間爲5.2

冒泡排序和選擇排序相比，冒泡排序是相鄰兩個元素比較，符合要求交換一次；選擇排序是一個元素與後邊元素比較，符合要求交換一次。所以對於同一組數據來說，選擇排序交換次數要少於冒泡排序的，所以效率高

插入排序

1. 時間複雜度

   最優時間複雜度：O(n)（升序排列，序列已經處於升序狀態）
   最壞時間複雜度：O(n**2)

2. 穩定性：穩定

def insert_sort(alist):
    n = len(alist)
    for i in range(n):
        for j in range(i):
            if alist[i] < alist[j]:
                alist[i], alist[j] = alist[j], alist[i]

對一萬個數據進行排序時間：



排序三次，平均時間爲5.1，比選擇排序稍微快一點點

有一位博主的寫法利用了Python列表的方法，更快：

def insert_sort(ilist):
    for i in range(len(ilist)):
        for j in range(i):
            if ilist[i] < ilist[j]:
                ilist.insert(j, ilist.pop(i))
                break

只用了1.7秒左右

這種方式不用交換，只需要遍歷列表找到指定的位置即可

希爾排序

1. 時間複雜度：

   最優時間複雜度：根據步長序列的不同而不同
   最壞時間複雜度：O(n**2)

2. 穩定性：不穩定

def shell_sort(alist):
    n = len(alist)
    gap = n // 2
    while gap > 0:
        for j in range(gap, n):
            i = j
            while i > 0:
                if alist[i] < alist[i-gap]:
                    alist[i], alist[i-gap] = alist[i-gap], alist[i]
                    i -= gap
                else:
                    break
        gap //= 2

對一萬個數據進行排序時間：

歸併排序

1. 時間複雜度：

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

2. 穩定性：穩定

def merge_sort(alist):
    n = len(alist)
    # print(alist)
    if n <= 1:
        return alist
    mid = n//2
    #left_li 採用歸併排序後形成的有序的新的列表
    left_li = merge_sort(alist[:mid])
    #right_li 採用歸併排序後形成的有序的新的列表
    right_li = merge_sort(alist[mid:])
    #將兩個有序的子序列合成一個新的整體
    left_pointer,right_pointer = 0,0
    print(left_li)
    print(right_li)
    result = []
    while left_pointer < len(left_li) and right_pointer < len(right_li):
        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 += left_li[left_pointer:]
    result += right_li[right_pointer:]
    return result

對一萬個數據進行排序時間：

快速排序

1. 時間複雜度：

   最優時間複雜度:O(nlogn)
   最壞時間複雜度：O(n**2)

2. 穩定性：不穩定

def quick_sort(alist, first, last):
    if first >= last:
        return
    mid_value = alist[first]
    low = first
    high = last

    while low < high:
        #high左移
        #當low和high的值等於，把相同的值放在分界線一邊
        while low < high and alist[high] >= mid_value:
            high -= 1
        alist[low]  = alist[high]

        #low右移
        while low < high and alist[low] < mid_value:
             low += 1
        alist[high] = alist[low]
    #從循環退出時，low==high
    alist[low] = mid_value
    # print(alist)

    #對low左邊的列表執行快速排序
    quick_sort(alist, first, low-1)
    #對low右邊的列表執行快速排序
    quick_sort(alist, low+1, last)

這種方法不好理解

百度百科的方法簡單易懂：

def quick_sort(data):
    """快速排序"""
    if len(data) >= 2:  # 遞歸入口及出口
        mid = data[len(data)//2]  # 選取基準值，也可以選取第一個或最後一個元素
        left, right = [], []  # 定義基準值左右兩側的列表
        data.remove(mid)  # 從原始數組中移除基準值
        for num in data:
            if num >= mid:
                right.append(num)
            else:
                left.append(num)
        return quick_sort(left) + [mid] + quick_sort(right)
    else:
        return data

對一萬個數據進行排序時間：

本文所用的數據是隨機生成的一萬個整數，幾種排序用的是一樣的數據。

幾種排序是從b站上學習的：https://www.bilibili.com/video/BV1p441167Wc/?spm_id_from=333.788.videocard.3

排序具體代碼實現有多種寫法，如果有錯誤請大家指出。