【數據結構與算法】時間複雜度的計算

時間 2019-11-12

標籤數據結構與算法時間複雜度計算简体版

原文原文鏈接

算法時間複雜度的計算 [整理]

博客分類：

算法學習

基本的計算步驟

時間複雜度的定義
    通常狀況下，算法中基本操做重複執行的次數是問題規模n的某個函數，用T(n)表示，如有某個輔助函數f(n)，使得當n趨近於無窮大時，T(n)/f(n)的極限值爲不等於零的常數，則稱f(n)是T(n)的同數量級函數。記做T(n)=O(f(n))，稱O(f(n))爲算法的漸進時間複雜度(O是數量級的符號 )，簡稱時間複雜度。

根據定義，能夠概括出基本的計算步驟
1. 計算出基本操做的執行次數T(n)
    基本操做即算法中的每條語句（以;號做爲分割），語句的執行次數也叫作語句的頻度。在作算法分析時，通常默認爲考慮最壞的狀況。

2. 計算出T(n)的數量級
    求T(n)的數量級，只要將T(n)進行以下一些操做：
    忽略常量、低次冪和最高次冪的係數

    令f(n)=T(n)的數量級。

3. 用大O來表示時間複雜度
    當n趨近於無窮大時，若是lim(T(n)/f(n))的值爲不等於0的常數，則稱f(n)是T(n)的同數量級函數。記做T(n)=O(f(n))。算法

一個示例：
(1) int num1, num2;
(2) for(int i=0; i<n; i++){
(3)     num1 += 1;
(4)     for(int j=1; j<=n; j*=2){
(5)         num2 += num1;
(6)     }
(7) }

分析：
1.
語句int num1, num2;的頻度爲1；
語句i=0;的頻度爲1；
語句i<n; i++; num1+=1; j=1; 的頻度爲n；4條
語句j<=n; j*=2; num2+=num1;的頻度爲n*log₂n；3條
T(n) = 2 + 4n + 3n*log₂n

2.
忽略掉T(n)中的常量、低次冪和最高次冪的係數
f(n) = n*log₂n

3.
lim(T(n)/f(n)) = (2+4n+3n*log₂n) / (n*log₂n)
                     = 2*(1/n)*(1/log₂n) + 4*(1/log₂n) + 3

當n趨向於無窮大，1/n趨向於0，1/log₂n趨向於0
因此極限等於3。

T(n) = O(n*log₂n)

簡化的計算步驟

再來分析一下，能夠看出，決定算法複雜度的是執行次數最多的語句，這裏是num2 += num1，通常也是最內循環的語句。

而且，一般將求解極限是否爲常量也省略掉？

因而，以上步驟能夠簡化爲：
1. 找到執行次數最多的語句
2. 計算語句執行次數的數量級
3. 用大O來表示結果

繼續以上述算法爲例，進行分析：
1.
執行次數最多的語句爲num2 += num1

2.
T(n) = n*log₂n
f(n) = n*log₂n

3.
// lim(T(n)/f(n)) = 1
T(n) = O(n*log₂n)函數

--------------------------------------------------------------------------------
一些補充說明
最壞時間複雜度
算法的時間複雜度不只與語句頻度有關，還與問題規模及輸入實例中各元素的取值有關。通常不特別說明，討論的時間複雜度均是最壞狀況下的時間複雜度。這就保證了算法的運行時間不會比任何更長。

求數量級
即求對數值(log)，默認底數爲10，簡單來講就是「一個數用標準科學計數法表示後，10的指數」。例如，5000=5x10 3 (log5000=3) ，數量級爲3。另外，一個未知數的數量級爲其最接近的數量級，即最大可能的數量級。

求極限的技巧
要利用好1/n。當n趨於無窮大時，1/n趨向於0

--------------------------------------------------------------------------------
一些規則(引自：時間複雜度計算 )
1) 加法規則
T(n,m) = T1(n) + T2(n) = O (max ( f(n), g(m) )

2) 乘法規則
T(n,m) = T1(n) * T2(m) = O (f(n) * g(m))

3) 一個特例（問題規模爲常量的時間複雜度）
在大O表示法裏面有一個特例，若是T1(n) ＝ O(c)， c是一個與n無關的任意常數，T2(n) = O ( f(n) ) 則有
T(n) = T1(n) * T2(n) = O ( c*f(n) ) = O( f(n) )

也就是說，在大O表示法中，任何非0正常數都屬於同一數量級，記爲O(1)。

4) 一個經驗規則
複雜度與時間效率的關係：
c < log₂n < n < n*log₂n < n² < n³ < 2ⁿ < 3ⁿ < n! （c是一個常量）
|--------------------------|--------------------------|-------------|
較好通常較差
其中c是一個常量，若是一個算法的複雜度爲c 、 log₂n 、n 、 n*log₂n,那麼這個算法時間效率比較高，若是是 2ⁿ , 3ⁿ ,n!,那麼稍微大一些的n就會令這個算法不能動了，居於中間的幾個則差強人意。性能

--------------------------------------------------------------------------------------------------
複雜狀況的分析

以上都是對於單個嵌套循環的狀況進行分析，但實際上還可能有其餘的狀況，下面將例舉說明。

1.並列循環的複雜度分析
將各個嵌套循環的時間複雜度相加。

例如：

　　for (i=1; i<=n; i++)
　　    x++;

　　for (i=1; i<=n; i++)
　　    for (j=1; j<=n; j++)
　　        x++;

解：
第一個for循環
T(n) = n
f(n) = n
時間複雜度爲Ο(n)

第二個for循環
T(n) = n²
f(n) = n²
時間複雜度爲Ο(n²)

整個算法的時間複雜度爲Ο(n+n²) = Ο(n²)。

2.函數調用的複雜度分析
例如：
public void printsum(int count){
    int sum = 1;
    for(int i= 0; i<n; i++){
       sum += i;
    }
    System.out.print(sum);
}

分析：
記住，只有可運行的語句纔會增長時間複雜度，所以，上面方法裏的內容除了循環以外，其他的可運行語句的複雜度都是O(1)。
因此printsum的時間複雜度 = for的O(n)+O(1) = 忽略常量 = O(n)

*這裏其實能夠運用公式 num = n*(n+1)/2，對算法進行優化，改成：
public void printsum(int count){
    int sum = 1;
    sum = count * (count+1)/2;
    System.out.print(sum);
}
這樣算法的時間複雜度將由原來的O(n)降爲O(1)，大大地提升了算法的性能。

3.混合狀況（多個方法調用與循環）的複雜度分析
例如：
public void suixiangMethod(int n){
    printsum(n);//1.1
    for(int i= 0; i<n; i++){
       printsum(n); //1.2
    }
    for(int i= 0; i<n; i++){
       for(int k=0; k<n; k++){
        System.out.print(i,k); //1.3
      }
}
suixiangMethod 方法的時間複雜度須要計算方法體的各個成員的複雜度。
也就是1.1+1.2+1.3 = O(1)+O(n)+O(n²) ----> 忽略常數和非主要項 == O(n²)

--------------------------------------------------------------------------------------------------
更多的例子

O(1)
交換i和j的內容
temp=i;
i=j;
j=temp;

以上三條單個語句的頻度爲1，該程序段的執行時間是一個與問題規模n無關的常數。算法的時間複雜度爲常數階，記做T(n)=O(1)。若是算法的執行時間不隨着問題規模n的增長而增加，即便算法中有上千條語句，其執行時間也不過是一個較大的常數。此類算法的時間複雜度是O(1)。

O(n²)
    sum=0；                /* 執行次數1 */
    for(i=1;i<=n;i++)
       for(j=1;j<=n;j++)
         sum++；       /* 執行次數n² */
解：T(n) = 1 + n² = O(n²)

   for (i=1;i<n;i++)
   {
       y=y+1;        ①
       for (j=0;j<=(2*n);j++)
          x++;        ②
   }
解：語句1的頻度是n-1
         語句2的頻度是(n-1)*(2n+1) = 2n²-n-1
         T(n) = 2n²-n-1+(n-1) = 2n²-2
         f(n) = n²
         lim(T(n)/f(n)) = 2 + 2*(1/n²) = 2
         T(n) = O(n²).

O(n)
   a=0;
   b=1;                     ①
   for (i=1;i<=n;i++) ②
   {
      s=a+b;　　　　③
      b=a;　　　　　④
      a=s;　　　　　⑤
   }
解：語句1的頻度：2,
         語句2的頻度：n,
         語句3的頻度：n,
         語句4的頻度：n,
         語句5的頻度：n,
         T(n) = 2+4n
         f(n) = n
         lim(T(n)/f(n)) = 2*(1/n) + 4 = 4
         T(n) = O(n).

O(log₂n)
   i=1;       ①
   while (i<=n)
      i=i*2; ②
解：語句1的頻度是1,
       設語句2的頻度是t, 則：2^t<=n; t<=log₂n
       考慮最壞狀況，取最大值t=log₂n,
        T(n) = 1 + log₂n
        f(n) = log₂n
        lim(T(n)/f(n)) = 1/log₂n + 1 = 1
        T(n) = O(log₂n)

O(n³)
   for(i=0;i<n;i++)
   {
      for(j=0;j<i;j++)
      {
         for(k=0;k<j;k++)
            x=x+2;
      }
   }
解：當i=m, j=k的時候,內層循環的次數爲k當i=m時, j 能夠取 0,1,...,m-1 , 因此這裏最內循環共進行了0+1+...+m-1=(m-1)m/2次因此,i從0取到n, 則循環共進行了: 0+(1-1)*1/2+...+(n-1)n/2=n(n+1)(n-1)/2次
T(n) = n(n+1)(n-1)/2 = (n³-n)/2? <--4
f(n) = n³
因此時間複雜度爲O(n³)。學習