~~~~總結基礎知識~~~

1.生成隨機陣列

       方案一： import random  === random.shuffle

       方案二：隨機輸出一個數，然後和前面的一個數進行交換

2.快速排序

      基本思想：

         1）找一個基準點，（一般直接中間的點），然後設定兩個變數

        2）

#-*-coding=utf-8-*-
def quickSorted(arr,start,end):
    if start < end:
        i,j = start,end
        pivotKey = arr[i]
        while i < j:
            #如果後面的數比基準數要大，則前移一位，直到有比基準數小的數
            while i < j and arr[j] >= pivotKey:
                j -= 1
            arr[i] = arr[j]
            #同樣前面的數比基準數小則後移一位，直到有比基準數大的數
            while i < j and arr[i] <= pivotKey:
                i += 1
            arr[j] = arr[i]
        #完成一輪比較後，序列被分成兩部分，並且i = j，需要將這個數設定為pivotKey
        arr[i] = pivotKey
        #遞迴排序前後兩部分
        quickSorted(arr,start,i-1)
        quickSorted(arr,j+1,end)
    return arr

if __name__ == '__main__':
    rawArr = [8,4,5,7,1,3,6,2]
    print ( quickSorted(rawArr,0,len(rawArr)-1))
    #print (arr)
 

3.歸併排序

       歸併排序是分治法的一個典型應用，歸併排序是將兩個已排序的表合成一個表。

      基本思想： 把待排序序列看成是N 個長度為 1 的有序序列，將相鄰的有序表成對歸併，得到n/2 個長度為 2 的有序表；將這些有序序列再次歸併，得到N/4 個長度為 4 的有序表，反覆迴圈此操作，最後得到一個長度為N的有序表。

     歸併主要在做兩件事：

     1）“分解”-----將序列每次這般劃分

     2）“合併” ----將劃分後的有序列兩兩合併後排序

分而治之：（example：[8,4,5,7,1,3,6,2]）

治階段：把兩個基本有序性的子序列進行合併

python程式碼實現：(遞迴的歸併排序)

#-*-coding=utf-8-*-
#合併有序集
def mergeList(arrA,arrB):
    mergeArr =[]
    indexA = 0
    indexB = 0
    while indexA < len(arrA) and indexB < len(arrB):
        if arrA[indexA] < arrB[indexB]:
            mergeArr.append(arrA[indexA])
            indexA += 1
        else:
            mergeArr.append(arrB[indexB])
            indexB += 1
    mergeArr += arrA[indexA:]
    mergeArr += arrB[indexB:]
    return mergeArr

def mergeSorted(allArr):
    if len(allArr) <= 1:
        return allArr
    num = int(len(allArr) / 2)                #二分分解
    aheadArr = mergeSorted(allArr[:num])      #遞迴呼叫歸併
    behindArr = mergeSorted(allArr[num:])
    return mergeList(aheadArr,behindArr)      #合併

if __name__ == '__main__':
    rawArr = [8,4,5,7,1,3,6,2]
    newArr = mergeSorted(rawArr)
    print (newArr)
 

歸併排序的時間複雜度：O(n*log2n)

空間複雜度：O(n+log2n)    // 歸併排序在歸併過程中需要與原始記錄序列同樣數量的儲存空間存放歸併結果，以及遞迴時深度為log2n的棧空間，因此空間複雜度為：n + log2n

總的來說，歸併排序是一種比較佔用記憶體，但效率高且穩定的演算法。

明天繼續更~~~

加油呀~~~~^_^~~~~