解惑3:時間頻度,演算法時間複雜度

山貓大戰響尾蛇發表於2020-06-27

一、概述

先放百科上的說法:

演算法的時間複雜度(Time complexity)是一個函式,它定性描述該演算法的執行時間。這是一個代表演算法輸入值的字串的長度的函式。

時間複雜度常用大O符號表述,不包括這個函式的低階項和首項係數。使用這種方式時,時間複雜度可被稱為是漸近的,亦即考察輸入值大小趨近無窮時的情況。

例如,如果一個演算法對於任何大小為 n (必須比 n0 大)的輸入,它至多需要 5n3 + 3n 的時間執行完畢,那麼它的漸近時間複雜度是 O(n3).

二、時間頻度

要理解時間複雜度,需要先理解時間頻度,而時間頻度簡單的說,就是演算法中語句的執行次數

舉個例子:

要計算1+2+...+100,現在有兩種演算法

public int fun1(int n){
    int total;
    for(int i = 0; i <= n; i++){
        total+=i;
    }
    return total;
}

public int fun2(int n){
    int total = (1 + n)*n/2;
    return total;
}

我們可以看見,對於fun1()這個方法,不管n多大,永遠需要執行n+1次,也就是說他的時間頻度是T(n)=n+1,

而對與fun2()來說,不管n多大都只需要執行1次,所以他的時間頻度T(n)=1。

當n趨向無窮大時,有三個忽略

1.忽略常數項

比如T(n)=2n+1,當n趨向無窮大時,可以忽略常數項1;

參見下圖:

  • 2n+20 和 2n 隨著n 變大,執行曲線無限接近, 20可以忽略
  • 3n+10 和 3n 隨著n 變大,執行曲線無限接近, 10可以忽略

2.忽略低次項

比如T(n)=2n+3n^8,當n趨向無窮大時,可以忽略低次項及其係數2n;

參見下圖:

  • 2n^2+3n+10 和 2n^2 隨著n 變大, 執行曲線無限接近, 可以忽略 3n+10
  • n^2+5n+20 和 n^2 隨著n 變大,執行曲線無限接近, 可以忽略 5n+20

3.忽略係數

比如T(n)=2n^8,當n趨向無窮大時,可以忽略係數2。

參見下圖:

  • 隨著n值變大,5n^2+7n 和 3n^2 + 2n ,執行曲線重合, 說明 這種情況下, 5和3可以忽略。
  • 而n^3+5n 和 6n^3+4n ,執行曲線分離,說明多少次方式關鍵

三、時間複雜度

我們現在理解了時間頻度的T(n)的含義,假設當有一個輔助函式f(n),使得當n趨近無窮大時,T(n)/f(n)的極限值為不等於0的常數,就叫f(n)為T(n)的同量級函式,記作T(n)=O(f(n)),

稱O(f(n))為演算法的時間漸進複雜度,也就是時間複雜度

又根據時間頻度T(n)的“三個忽略”原則,我們可以知道時間複雜度是這樣得到的:

  1. 忽略所有常數
  2. 只保留函式中的最高階項
  3. 去掉最高階項的係數

舉個例子:

某演算法T(n)=2n^3+4n-5,按步驟走:

  1. T(n)=2n^3+4n
  2. T(n)=2n^3
  3. T(n)=n^3

即可得該演算法時間複雜度為O(n^3)

四、常見時間複雜度

這裡按複雜度從低到高列舉常見的時間複雜度:

  1. 常數階O(1)

    // 無論程式碼執行了多少行,只要是沒有迴圈等複雜結構,那這個程式碼的時間複雜度就都是O(1) 。
    public void fun(int n){
        n+=1;
    }
    
  2. 對數階O(log2n)

    // 根據公式有 n = 2^x,也就是 x = log2n,x即為迴圈程式碼執行次數,所以時間複雜度為O(log2n)
    public void fun(int n){
        int i = 1;
        while(i < n){
            i = i *2
        }
    }
    
  3. 線性階O(n)

    // 一般來說,只要程式碼裡只有一個迴圈結構,即輸入規模和執行次數呈線性相關,那這個程式碼的時間複雜度就都是O(n) 。
    public void fun(int n){
        for(int i = 0; i < n; i++){
            n+=i;
        }
    }
    
  4. 線性對數階O(nlogn)

    // 可以簡單理解為對數階的程式被放入了迴圈結構中,也就是n*O(logn),下面的程式碼的複雜度就是O(nlog2n)
    public void fun(int n){
        int j = 1;
        for(int i = 0; i < n; i++){
            while(i < n){
                j = j *2
            }
        }
    }
    
  5. 平方階O(n²),立方階O(n3),K次方階O(nk)

    // 平方階可以簡單理解為線性階中巢狀一個線性階,也就是O(logn)*O(logn),下面的程式碼複雜度就是O(n^2)
    // 立方階同理,就是三個線性階的巢狀,K次方階同理
    public void fun(int n){
        for(int i = 0; i < n; i++){
            for(int j = 0; j < n; i++){
    			i=i+j;
            } 
        }
    }
    

五、複雜度的四個概念

  1. 最壞情況時間複雜度:程式碼在最理想情況下執行的時間複雜度。
  2. 最好情況時間複雜度:程式碼在最壞情況下執行的時間複雜度。
  3. 平均時間複雜度:用程式碼在所有情況下執行的次數的加權平均值表示
  4. 均攤時間複雜度:在程式碼執行的所有複雜度情況中絕大部分是低階別的複雜度,個別情況是高階別複雜度且發生具有時序關係時,可以將個別高階別複雜度均攤到低階別複雜度上。基本上均攤結果就等於低階別複雜度。

舉個例子:

長度為n的陣列查詢一個給定元素k

public void fun(int[] arr,int k){
    for(int i = 0; i < arr.length; i++){
        if(arr[i] == k){
            //找到了
        }
    }
}

上面這個方法,最好的情況下元素k就在陣列第一位,複雜度為O(1),但是最壞的情況下,元素k在陣列最後一位,複雜度為O(n)。

同一段程式碼在不同情況下時間複雜度會出現量級差異,為了更全面,更準確的描述程式碼的時間複雜度,我們引入這4個概念,當然,在大多數時候我們是不用特意區分這四種情況的。

六、總結

總結一下如何快速判斷程式的時間複雜度:

  • 只關注迴圈最多的那部分程式碼
  • 總複雜度等於量級最大的那段程式碼的複雜度
  • 巢狀程式碼的複雜度等於巢狀內外程式碼複雜度的乘積

相關文章