算法導論：1算法分析--python實現

 

1 插入排序(Insert Sort)

1.1 插入排序原理

最壞時間：輸入逆序。

　　

比較次數：(n+2)(n-1)/2

移動次數：(n+4)(n-1)/2

 

平均時間：輸入規模爲n時，所有可能輸入的期望時間。換一種說法，每種輸入的運行時間，乘以那種輸入出現的概率，是一種加權平均。

如何知道某種輸入出現的概率？

通過一個有關輸入的統計分佈的假設。常見的假設就是，所有輸入都是以等可能的方式出現的，即均勻分佈。

　　

 

最少時間：輸入正序。

比較次數：n-1

移動次數：0

插入排序快不快？當n很小的時候，挺快，當n很大，就會很慢，通常n<=8。

 

1.2 python 實現

def insert_sort(A):
    n = len(A)
    for i in range(1, n):
        key = A[i]
        j = i - 1
        while j >= 0 and A[j] > key:
            A[j + 1] = A[j]
            j -= 1
        A[j + 1] = key
    return A


def insert_sort1(A):
    n = len(A)
    for i in range(1, n):
        for j in range(0, i):
            if A[i] < A[j]:
                tmp = A[j]
                A[j] = A[i]
                A[i] = tmp
    return A


if __name__ == '__main__':
    print(insert_sort([4, 3, 123, 12, 2, 5, 0, 88]))

2 歸併排序(Merge Sort)

分治法：將原問題分解爲幾個規模較小但類似於原問題的子問題，遞歸地求解這些子問題，然後在阿合併這些子問題的解來建立原問題的解。

2.1 算法原理

僞代碼如下：

2.2 算法分析

總時間：

1. 如果n=1, 排序完成
2. Merge_Sort:  遞歸排序，和
3. Merge: 合併連個已經排好序的列表

第一步所需時間, 

第二步所需時間

第三部所需時間

所以，歸併排序最壞情況下運行時間的遞歸式：

因 ,  遞歸式可重寫爲：

求解遞歸式：

遞歸樹具有層，每層的代價均爲cn , 所以總代價爲,  忽略低價項和常量c ,期望的結果爲 。
 

2.3 python 實現

def MergeSort(lists):
    if len(lists) <= 1:
        return lists
    middle = len(lists)//2
    left = MergeSort(lists[:middle])
    right = MergeSort(lists[middle:])
    return merge(left, right)


def merge(a, b):
    c = []
    h = j = 0
    while j < len(a) and h < len(b):
        if a[j] < b[h]:
            c.append(a[j])
            j += 1
        else:
            c.append(b[h])
            h += 1
    if j == len(a):
        for i in b[h:]:
            c.append(i)
    else:
        for i in a[j:]:
            c.append(i)

    return c


if __name__ == '__main__':
    a = [4, 7, 8, 3, 5, 9]
    print(MergeSort(a))

 

3 算法分析

運行時間依賴於輸入，比如輸入的個數，輸入的排序情況。

漸進分析的基本思路是，忽略依賴於機器的常量，不去檢查實際的運行時間，而是關注運行時間的增長。棄低階項和常數因子。