基礎排序算法（冒泡排序、選擇排序、插入排序、希爾排序 ）python實現

基礎排序筆記：
|-爲什麼要學習O(n^2)的排序算法
    基礎
    編碼簡單易於實現
    在一些特殊的情況下 簡單的排序算法更有效
    簡單的排序思想衍生出複雜的排序算法
    作爲子過程 改進更復雜的排序算法
|-選擇排序
    兩層循環必須完全執行完成o(n^2)
|-插入排序
    在近乎有序的數據中 排序速度很快 甚至快於O(n*logn)排序算法
    當完全有序時 複雜度爲O(n)
|-冒泡排序
|-希爾排序
    插入排序的升級
    逐步減小增量
    複雜度O(n^1.5)

    由於是一種跳躍式的排序 希爾排序不穩定

源代碼:
https://github.com/lzneu/Algrithm_python

import datetime
import random
import time


# 生成一個近乎有序的數組
def genNearlyOrderArray(n, swapTimes):
    arr = list(range(n))
    for i in range(swapTimes):
        x = random.randint(0, n)
        y = random.randint(0, n)
        swap(arr, x, y)
    return arr


def genRandomArray(n, start=0, end=10000):
    return random.sample(range(start, end), n)


def testSort(sortName, arr, n):
    t_start = datetime.datetime.now()
    sortName(arr, n)
    t_end = datetime.datetime.now()  # 記錄函數結束時間)
    long = (t_end - t_start).total_seconds()
    if isSorted(arr, n):
        print("sortName: %s, time: %f s" % (sortName.__name__, long))
    else:
        print('Sort ERROR!')


def swap(arr, i, j):
    temp = arr[i]
    arr[i] = arr[j]
    arr[j] = temp


def isSorted(arr, n):
    for i in range(n-1):
        if(arr[i] > arr[i+1]):
            return False
    return True


def selectonSort(arr, n):
    for i in range(n):
        # 尋找[i, n)區間裏面的最小值
        minIndex = i
        for j in range(i+1, n):
            if (arr[j] < arr[minIndex]):
                swap(arr, minIndex, j)


def insertionSort(arr, n):
    for i in range(1, n):
        # 尋找arr[i]合適的插入位置
        j = i
        while j > 0 and arr[j] < arr[j-1]:
            swap(arr, j, j-1)
            j-=1


def insertionSort2(arr, n):
    for i in range(1, n):
        # 尋找arr[i]合適的插入位置
        j = i
        temp = arr[i]
        while j > 0 and arr[j-1] > temp:
            # 副本存儲代替每次交換
            arr[j] = arr[j-1]
            j-=1
        arr[j] = temp


def bubbleSort(arr, n):
    # 設一個標誌位 如果沒有數據交換 說明排序完成
    flag = True
    for i in range(n):
        if flag == False:
            break
        flag = False
        ite = list(range(i, n))
        ite.reverse()
        for j in ite:
            if (arr[j] < arr[j-1]):
                swap(arr, j, j-1)
                flag = True


def shellSort(arr, n):

    increment = n
    while (increment > 1):
        increment = increment // 3 + 1
        for i in range(increment, n):
            if (arr[i] < arr[i-increment]):
                # 將 arr[i]插入有序增量子表
                temp = arr[i]
                j = i - increment
                while (j>=0 and arr[j] > temp):
                    arr[j+increment] = arr[j]
                    j -= increment
                arr[j+increment] = temp
    return arr


if __name__ == '__main__':
    n = 10000
    start = 0
    end = 10000
    # arr = genNearlyOrderArray(n, swapTimes=100)
    arr = genRandomArray(n, start, end)
    arr2 = arr.copy()
    arr3 = arr.copy()
    testSort(shellSort, arr, n)
    testSort(insertionSort, arr2, n)
    testSort(insertionSort2, arr3, n)