一.插入排序——簡單插入排序

基本思想：每步將一個待排序的紀錄，按其關鍵碼值的大小插入前面已經排序的文件中適當位置上，直到全部插入完為止。

def insertSort(arr):
    if len(arr) <= 1:
        return arr
    for i in range(1, len(arr)):
        tmp = arr[i]
        j = i
        while j > 0 and tmp < arr[j-1]:
            arr[j] = arr[j-1]
            j -= 1
        a[j] = tmp

二.插入排序——希爾排序

基本思想：先將要排序的一組記錄按某個增量d（n/2,n為要排序數的個數）分成若干組子序列，每組中記錄的下標相差d.對每組中全部元素進行直接插入排序，然后再用一個較小的增量（d/2）對它進行分組，在每組中再進行直接插入排序。繼續不斷縮小增量直至為1，最后使用直接插入排序完成排序。

def shellSort(arr):
    if len(arr) <= 1:
        return arr
    Increment = len(arr) / 2
    while Increment > 0:
        for i in range(Increment, len(arr)):
            tmp = arr[i]
            j = i
            while j > 0 and tmp < arr[j-Increment]:
                arr[j] = arr[j-Increment]
                j -= Increment
            arr[j] = tmp
        Increment /= 2

三. 選擇排序——簡單選擇排序

基本思想：每一次從待排序的數據元素中選出最小（或最大）的一個元素，存放在序列的起始位置，直到全部待排序的數據元素排完。

過程：
第一趟，從n 個記錄中找出關鍵碼最小的記錄與第一個記錄交換；
第二趟，從第二個記錄開始的n-1 個記錄中再選出關鍵碼最小的記錄與第二個記錄交換；
以此類推…..
第i 趟，則從第i 個記錄開始的n-i+1 個記錄中選出關鍵碼最小的記錄與第i 個記錄交換，
直到整個序列按關鍵碼有序。

def selectSort(arr):
    if len(arr) <= 1:
        return arr
    for i in range(len(arr)-1):
        min = i
        for j in range(i+1, len(arr)):
            if arr[j] < arr[min]:
                min = j
        arr[i], arr[min] = arr[min], arr[i]

四.選擇排序——堆排序

基本思想：堆排序需要兩個過程，一是建立堆，二是堆頂與堆的最后一個元素交換位置.
堆排序會將所有的數據建成一個堆，最大的數據在堆頂，然后將堆頂數據和序列的最后一個數據交換。接下來不動最后一個數據再次重建堆，交換數據，依次下去，就可以排序所有的數據。

def heapSort(arr):
    def precDown(a, i, N):
        child = 2 * i + 1
        tmp = a[i]
        while child < N:
            if child < N-1 and a[child] < a[child+1]:
                child += 1
            if tmp < a[child]:
                a[i] = a[child]
                i = child
            else:
                break
            child = child * 2 + 1
        a[i] = tmp

    if len(arr) <= 1:
        return arr
    N = len(arr)
    for i in range((N-2)//2, -1, -1):
        precDown(arr,i,N)
    for i in range(N-1, 0, -1):
        arr[0], arr[i] = arr[i], arr[0]
        precDown(arr,0,i)

五.交換排序——冒泡排序

基本思想：

1. 比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。
2. 對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最后一對。在這一點，最后的元素應該會是最大的數。
3. 針對所有的元素重復以上的步驟，除了最后一個。
4. 持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。

def bubbleSort(arr):
    length = len(arr)
    if length <= 1:
        return arr
    while length > 1:
        for i in range(length-1):
            if arr[i] > arr[i+1]:
                arr[i], arr[i+1] = arr[i+1], arr[i]
        length -= 1

六.交換排序——快速排序

基本思想：使用一個樞紐元，通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比樞紐元小，另外一部分的所有數據都比樞紐元大，然后再按此方法對這兩部分數據分別進行快速排序。

def quickSort(arr):
    def Qsort(a, left, right):
        i = left
        j = right
        if i >= j:
            return
        key = Median(a, left, right)
        while i < j:
            while i < j and a[j] >= key:
                j -= 1
            a[i] = a[j]
            while i < j and a[i] <= key:
                i += 1
            a[j] = a[i]
        a[i] = key
        Qsort(a, left, i-1)
        Qsort(a, i+1, right)

    def Median(a, left, right):
        center = (left + right) / 2
        if a[left] > a[center]:
            a[left], a[center] = a[center], a[left]
        if a[center] > a[right]:
            a[center], a[right] = a[right], a[center]
        if a[left] > a[right]:
            a[left], a[right] = a[right], a[left]
        a[center], a[left] = a[left], a[center]
        return a[left]

    if len(arr) <= 1:
        return arr
    Qsort(arr, 0, len(arr)-1)

七.歸並排序

基本思想：將兩個（或兩個以上）有序表合並成一個新的有序表，即把待排序序列分為若干個子序列，每個子序列是有序的。然后再把有序子序列合並為整體有序序列。

def mergeSort(arr):
    def Merge(left, right):
        i, j = 0, 0
        result = []
        while i < len(left) and j < len(right):
            if left[i] < right[j]:
                result.append(left[i])
                i += 1
            else:
                result.append(right[j])
                j += 1
        result += left[i:]
        result += right[j:]
        return result

    if len(arr) <= 1:
        return arr
    center = len(arr) / 2
    left = mergeSort(arr[:center])
    right = mergeSort(arr[center:])
    return Merge(left, right)

八.基數排序

基本思想：將所有待比較數值（正整數）統一為同樣的數位長度，數位較短的數前面補零。然后，從最低位開始，依次進行一次排序。這樣從最低位排序一直到最高位排序完成以后, 數列就變成一個有序序列。

def bucketSort(arr, radix=10):
    if len(arr) <= 1:
        return arr
    K = int(math.ceil(math.log(max(arr), radix)))
    bucket = [[] for i in range(radix)]
    for i in range(1, K+1):
        for element in arr:
            bucket[element%(radix**i)/(radix**(i-1))].append(element)
        del(arr[:])
        for each in bucket:
            arr.extend(each)
        bucket = [[] for i in range(radix)]