Python實現程序運行時間度量分析

• 推薦自己的專欄：分享一些Python案例，將所學用出來

---

一：算法時間複雜度分析函數的設計

• 程序的運行時間長度與算法的設計和所求解的問題的規模有關。
• 當輸入大小(即問題規模)增大時，程序的運行時間遞增比例，即是算法的時間複雜度。

設計思路如下:

1. 定義函數buildData(n)，構造並返回規模爲n的測試輸入數據。例如，排序隨機n個數的列表。

def buildData(n):
    """構造測試規模爲n的輸入數據,對於排序，隨機n個數的列表"""
    data = [random.randrange(n) for i in range(n)]
    return data

2. 定義函數timing(f, data)， 返回調用f(data)的運行時間。

def timing(f, data):
    """測量函數調用f(data)的運行時間分析"""
    start = time.time() #記錄開始時間
    f(data)  #運行f(data)
    end = time.time()  #記錄結束時間
    return end - start #返回執行時間

3. 定義函數timingAnalysis(f, m₁, m₂, runs, buildData)， 測量並輸出函數 f 在不同輸入規模: 10^m₁、10^m₁+1、 …、10^m₂ 情況下運行runs次的平均時間。
   函數調用buildData(n)規模爲n的數據data，然後調用timing(f, data) 測量函數的運行時間。

def timingAnalysis(f,m1, m2, runs, buildData) :
    """輸出函數f在不同輸入規模: 10**m1,.... ,10**m2運行runs次的時間"""
    for n in [10**i for i in range(m1, m2+1)]:  #10**m1,...，10**m2
          data = buildData (n)
          total = 0.0  #初始化總時間
          for i in range(runs) : #重複運行runs次
              total += timing(f, data) #運行f並累計運行時間
          strResult = '輸入規模{:10}時函數{:15}運行{}次的平均時間爲: {} 秒'
          print (strResult.format(n, f.__name__, runs, total/runs))

4. 在測試代碼中，導入各種排序算法（不在本篇文章中贅述，有興趣者可以下載完整代碼查看），然後調用分析各排序算法的時間複雜度。

二：算法時間複雜度分析函數的實現與應用

time_analysis.py

import time
import random

def timing(f, data):
    """測量函數調用f(data)的運行時間分析"""
    start = time.time() #記錄開始時間
    f(data)  #運行f(data)
    end = time.time()  #記錄結束時間
    return end - start #返回執行時間

def timingAnalysis(f,m1, m2, runs, buildData) :
    """輸出函數f在不同輸入規模: 10**m1,.... ,10**m2運行runs次的時間"""
    for n in [10**i for i in range(m1, m2+1)]:  #10**m1,...，10**m2
          data = buildData (n)
          total = 0.0  #初始化總時間
          for i in range(runs) : #重複運行runs次
              total += timing(f, data) #運行f並累計運行時間
          strResult = '輸入規模{:10}時函數{:15}運行{}次的平均時間爲: {} 秒'
          print (strResult.format(n, f.__name__, runs, total/runs))

def buildData(n):
    """構造測試規模爲n的輸入數據,對於排序，隨機n個數的列表"""
    data = [random.randrange(n) for i in range(n)]
    return data


#測試代碼

if __name__ ==  "__main__" :
    from bubbleSort import bubbleSort
    from selectionSort import selectionSort
    from insertSort import insertSort
    from mergeSort import mergeSort
    from quickSort import quickSort

    def quickSort1 (a) :
        quickSort(a, 0, len(a) - 1)

    #冒泡排序算法，時間複雜度分析
    timingAnalysis (bubbleSort, 2, 4, 1, buildData)
    print()

    #選擇排序算法，時間複雜度分析
    timingAnalysis (selectionSort, 2, 4, 1, buildData)
    print()

    #插入排序算法，時間複雜度分析
    timingAnalysis (insertSort, 2, 4, 1, buildData)
    print()

    #歸併排序算法，時間複雜度分析
    timingAnalysis (mergeSort, 1, 4, 1, buildData)
    print()

    #快速排序算法，時間複雜度分析
    timingAnalysis (quickSort1, 1, 4, 1, buildData)
    print()

    #內置排序算法sort，時間複雜度分析
    timingAnalysis(sorted, 1, 4, 1, buildData)

運行：

輸入規模       100時函數bubbleSort     運行1次的平均時間爲: 0.000997781753540039 秒
輸入規模      1000時函數bubbleSort     運行1次的平均時間爲: 0.10474658012390137 秒
輸入規模     10000時函數bubbleSort     運行1次的平均時間爲: 8.514265298843384 秒

輸入規模       100時函數selectionSort  運行1次的平均時間爲: 0.0 秒
輸入規模      1000時函數selectionSort  運行1次的平均時間爲: 0.044878244400024414 秒
輸入規模     10000時函數selectionSort  運行1次的平均時間爲: 4.592764377593994 秒

輸入規模       100時函數insertSort     運行1次的平均時間爲: 0.0009894371032714844 秒
輸入規模      1000時函數insertSort     運行1次的平均時間爲: 0.0917809009552002 秒
輸入規模     10000時函數insertSort     運行1次的平均時間爲: 7.810081720352173 秒

輸入規模        10時函數mergeSort      運行1次的平均時間爲: 0.0 秒
輸入規模       100時函數mergeSort      運行1次的平均時間爲: 0.000997304916381836 秒
輸入規模      1000時函數mergeSort      運行1次的平均時間爲: 0.0029914379119873047 秒
輸入規模     10000時函數mergeSort      運行1次的平均時間爲: 0.03091740608215332 秒

輸入規模        10時函數quickSort1     運行1次的平均時間爲: 0.0 秒
輸入規模       100時函數quickSort1     運行1次的平均時間爲: 0.0009975433349609375 秒
輸入規模      1000時函數quickSort1     運行1次的平均時間爲: 0.001994609832763672 秒
輸入規模     10000時函數quickSort1     運行1次的平均時間爲: 0.02396249771118164 秒

輸入規模        10時函數sorted         運行1次的平均時間爲: 0.0 秒
輸入規模       100時函數sorted         運行1次的平均時間爲: 0.0 秒
輸入規模      1000時函數sorted         運行1次的平均時間爲: 0.0 秒
輸入規模     10000時函數sorted         運行1次的平均時間爲: 0.0019676685333251953 秒