用python完成排序算法

排序算法總結

冒泡排序

相鄰兩個元素，兩兩循環比較，每趟篩選出一個最大或者最小的元素（有序區在後面）

def bubble_sort(data):
    # 第一層循環：循環一次，表明一趟，並篩選出一個最大或最小元素
    for i in range(len(data)-1):
        temp = True
        # 第二層循環：循環一次，表示相鄰兩個元素進行了一次比較
        for j in range(len(data)-1-i):
            if data[j] > data[j+1]:
                # 相鄰兩個元素進行替換
                data[j], data[j+1] = data[j+1], data[j]
                temp = False
        if temp:
            return

選擇排序

將一個元素設爲初始值（通常都是第一個值），循環後面每一個元素與第一個元素比較，最終篩選出一個最小或最大值（有序區在前面）

def select_sort(data):
    # 第一層循環：取出數組中的每一個元素
    for i in range(len(data)):
        temp = i   # 拿取一個元素用來比較
        # 第二層循環：從第i後面的一個值開始循環，與data[i]進行比較
        for j in range(i+1,len(data)):
            if data[j] < data[temp]:
                data[temp], data[j] = data[j], data[temp]

插入排序

將第一個元素做爲有序區的元素，從無序區取出一個元素與有序區元素進行逐個比較，並加入到有序區，依次循環

def insert_sort(data):
    # 第一層循環： 從第二個元素開始循環取出元素，與有序區元素進行比較
    for i in range(1,len(data)):
        temp = data[i]
        j = i-1
        while j>=0 and temp < data[j]:   
            data[j+1] = data[j]    # i = j+1
            j = j-1    # 在與前面一個元素進行比較，因此j須要減1
        # 當j = -1 就跳出循環，將temp值賦給第一個值，即data[0]
        data[j+1] = temp

快速排序

取第一個元素p，使元素p歸位（須要創建歸位函數）；

列表（數組）被P分紅兩部分，左邊都比P小，右邊都比P大；

遞歸完成排序。

總結就分紅兩部分：整理 + 遞歸

# 歸位函數，定位中間值P
def partition(data,left,right):
    temp = data[left]
    while left < right:
        # 若是最右邊的值大於中間值，則最右邊值日後退一個位置，反之，就將值賦值給最左邊位置
        while left < right and data[right] >= temp:
            right = right - 1
        data[left] = data[right]
         # 若是最左邊的值小於中間值，則最左邊值往前進一個位置，反之，就將值賦值給最右邊位置
        while left < right and data[left] <= temp:
            left = left + 1
        data[right] = data[left]
    # 循環結束，便可定位到中間位置，將初始值，賦值到這個位置
    data[left] = temp
    return left
            
def quick_sort(data,left,right):
    if left< right:
        mid = partition(data,left,right)
        quick_sort(data,left,mid)
        quick_sort(data,mid+1,right)

冒泡、選擇、插入的時間複雜度爲O(n^2)；

快速排序的時間複雜度爲O(nlogn)

希爾排序

希爾排序是一種分組插入排序算法

首先，取一個d1 = n // 2的整數，將元素分爲d1個組，每組相鄰元素之間的距離爲d1，在各組內進行直接插入排序；

而後，取第二個整數d2 = d1 // 2，重複上述分組排序過程，直到d1 = 1，再將全部元素在同一組內直接插入排序。

希爾排序每趟並不使某些元素有序，而是使總體數據愈來愈接近有序；最後一趟排序使得全部數據有序。

def shell_sort(data):
    gap = len(data) // 2
    while gap > 0:
        for i in range(gap,len(data)):
            temp = data[i]
            j = i - gap
            while j >= 0 and temp < data[j]:
                data[j+gap] = data[j]
                j = j-gap
            data[j+gap] = temp
        gap /= 2

希爾排序的時間複雜度爲：O((1+T)n) 約等於 O(1.3n)

計數排序

新增一個值所有爲0的列表(數組),再利用enumerate獲得該列表的索引和值來排序;

def count_sort(data):
    count = [0 for _ in range(len(data)+1)]
    for i in data:
        count[i] += 1
    data.clear()
    for index, nums in enumerate(count):
        for j in range(nums):
            data.append(index)