演算法的時間空間複雜度和空間複雜度總結

時間頻度

一個演算法中的語句執行次數稱為語句頻度或時間頻度。記為T(n)。

如何獲得T(n)：

    public static int factorial(int n){
        int result = 1;     //①
        if(n == 0 || n == 1){   //②
            return result;  //③
        }else{
            for(int i = 2;i<=n;i++){    //④
                result *= i;    //⑤
            }
            return result;  //6
        }
    }
 

上面的這個方法中，①語句執行一次；②雖然是if語句，但判斷也需要執行一次；我們通常在計算演算法效率時，做最壞打算，因此我們認為if不成立，執行else中的語句，④語句中包含三條語句，各執行了n-1次；⑤語句處於for迴圈中，執行了n-1次；⑥語句執行一次。因此，T(n)=1+1+4(n-1)+1=n-1

時間複雜度

一般情況下，演算法中基本操作重複執行的次數是問題規模n的某個函式，用T(n)表示，若有某個輔助函式f(n),使得當n趨近於無窮大時，T(n)/f(n)的極限值為不等於零的常數，則稱f(n)是T(n)的同數量級函式。記作T(n)=Ｏ(f(n)),稱Ｏ(f(n)) 為演算法的漸進時間複雜度，簡稱時間複雜度。

在上面已經提到了求T(n)的方法，現在我們只需要知道怎樣通過T(n)求出f(n)，就得出時間複雜度O(f(n))

若把T(n)比作一棵樹，那f(n)就是將樹的枝葉修剪完的主幹，修剪的規則如下：

• 常數省略，若T(n)本身就為常數，則f(n)=1
• 低次階省略，例如T(n)=n^3+n^2+3，則f(n)=n^3
• 係數忽略，例如T(n)=3n^3+n^2+3，則f(n)=n^3

為什麼會出現這樣的規則，這時是因為在演算法中，我們認為n趨於無窮大，因此常數、低次階、係數對於T(n)的影響很小，所以省略。

平均時間複雜度：平均時間複雜度是指所有可能的輸入例項均以等概率出現情況下該演算法的執行時間

最壞時間複雜度：最壞情況下的時間複雜度稱為最壞時間複雜度。一般討論的時間複雜度均是最壞時間複雜度。這樣做的原因是：最壞情況下的時間複雜度是演算法在任何輸入例項上執行時間的界限，這就保證了演算法的執行時間不會比最壞情況更長

常見的時間複雜度

常見的時間複雜度有：常數階O(1)、對數階O(log2n)、線性階O(n)、平方階O(n^2)、立方階O(n^3)、k次方階O(n^k)、線性對數階O(nlog2n)、指數階O(2^n)、階乘階O(n!)

時間複雜度由小到大依次為：O(1)<O(log2n)<O(n)<O(n^2)<O(n^3)<O(n^k)<O(nlog2n)<O(2^n)<O(n!)

用圖片表示部分時間複雜度隨n的增長T(n)增長的曲線：

1.O(1)

    a = 1;
    b = a;

T(n)為一個常數，因此f(n)=1，故O(f(n))=O(1)

2.O(log2n)

    i = 1;
    while(i<n){
        i *= 2;
    }

設while迴圈執行次數為x，則2^x=n，x=log2n，因此T(n)=2log2n+1，f(n)=log2n，故O(f(n))=O(log2n)

3.O(n)

    int a = 1;
    for(int i = 0;i < n;i++){
        a++;
    }

for迴圈執行次數為n次，因此T(n)=4n+1，f(n)=n，故O(f(n))=O(n)。一個n次迴圈的for迴圈就是線性階，兩個n次迴圈的for迴圈就是平方階，O(n^k)就是k個n次迴圈的for迴圈巢狀

4.O(nlog2n)

    int i = 1;
    int a = 1;
    while(i<n){
        for(int i = 0;i < n;i++){
            a++;
        }
        i *= 2;
    }

T(n)=2+2log2n+4nlog2n，f(n)=nlog2n，故O(f(n))=O(nlog2n)

呼叫方法時的時間複雜度的計算

呼叫方法時不參與迴圈，則可以將被呼叫方法的f(n)當做其T(n)加入到當前方法的T(n)中，已知factorial方法的時間複雜度為O(n)

    public static void print(int n){
        int a = 0;
        for (int i = 0;i<n;i++){
           a = i;
        }
        System.out.println(factorial(i));
    }
    public static int factorial(int n){
        int result = 1;
        if(n == 0 || n == 1){
            return result;
        }else{
            for(int i = 2;i<=n;i++){
                result *= i;    //①
            }
        }
        return result;
    }

T(n)=1+4n+n，print的時間複雜度為O(n)

呼叫方法時參與迴圈，這種情況下就要考慮迴圈條件，修改上面的部分程式碼：

    public static void print(int n){
        for (int i = 0;i<n;i++){
           System.out.println(factorial(i)); 
        }
    }

設print方法的時間頻度為T(n)，①被呼叫的次數為0+0+1+2+...+n=(n^2+n)/2，故T(n)=3n+(n^2+n)/2，f(n)=n^2，所以O(n^2)。

空間複雜度

一個演算法的空間複雜度S(n)定義為該演算法所耗費的儲存空間，它也是問題規模n的函式。漸近空間複雜度也常常簡稱為空間複雜度。

一個演算法在計算機儲存器上所佔用的儲存空間，包括①儲存演算法本身所佔用的儲存空間，②演算法的輸入輸出資料所佔用的儲存空間，③演算法在執行過程中臨時佔用的儲存空間。

• 儲存演算法本身所佔用的儲存空間由演算法程式碼的書寫長短有關，優化程式碼量可節約空間
• 演算法的輸入輸出資料所佔用空間，通常解決一個問題的不同演算法的輸入輸出資料基本相同，因此不用考慮優化
• 演算法在執行過程中臨時佔用的儲存空間，例如有些演算法通過陣列解決，有些通過連結串列解決等，不用的算法佔用的臨時儲存空間不同，需要關注優化。

演算法的空間複雜度也用O表示，指的是該演算法所佔用的空間隨問題規模n的增長所變化的情況，O(1)表示演算法所佔用空間不隨n的增長而增長；O(n)表示演算法所佔用空間隨n的增長線性增長

在衡量一個演算法的效率時，主要考慮時間複雜度，因為時間複雜度直接與使用者體驗相關，用空間換取時間也是可行的。

常用演算法的時間和空間複雜度

相關推薦