算法時間複雜度求解

深夜和網絡大神們聊起算法時間複雜度計算，T (n) = aT (n/b) + f(n)，乍一看還覺得是最小二乘的兄弟，梯度降低也不是，百度一看是遞歸。大神便扔來博客：www.cnblogs.com/fanchangfa/p/3868696.html，恍然大悟，大一就學過的方法，快還給書本了。

在進行算法分析時，語句總的執行次數T(n)是關於問題規模n的函數，進而分析T(n)隨n的變化狀況並肯定T(n)的數量級。算法的時間複雜度，也就是算法的時間量度，基座T（n）=O(f(n))。它表示隨問題規模n的增大，算法執行時間的增加率和f(n)的增加率相同，稱做算法的漸進算法時間複雜度，簡稱爲時間複雜度。其中f(n)是問題規模n的某個函數。

通常用大寫O()來表示算法的時間複雜度寫法，一般叫作大O記法。

通常狀況下，隨着n的增大，T(n)增加最慢的算法爲最優算法。

O(1)：常數階

O(n)：線性階

O(n²)：平方階

 

大O推導法：

1. 用常數1取代運行時間中的全部加法常數
2. 在修改後的運行函數中，只保留最高階項
3. 若是最高階項存在且不是1，則去除與這個項相乘的常數

 

常數階：

int sum = 0 ; n = 100;        /*執行一次*/
sum = (1+n)*n/2;             /*執行一次*/
printf("%d",sum);            /*執行一次*/

這個算法的運行次數f(n) = 3,根據推導大O階的方法，第一步是將3改成1，在保留最高階項是，它沒有最高階項，所以這個算法的時間複雜度爲O(1);

另外，

int sum = 0 ; n = 100; /*執行一次*/
sum = (1+n)*n/2; /*執行第1次*/
sum = (1+n)*n/2; /*執行第2次*/
sum = (1+n)*n/2; /*執行第3次*/
sum = (1+n)*n/2; /*執行第4次*/
sum = (1+n)*n/2; /*執行第5次*/
sum = (1+n)*n/2; /*執行第6次*/
sum = (1+n)*n/2; /*執行第7次*/
sum = (1+n)*n/2; /*執行第8次*/
sum = (1+n)*n/2; /*執行第9次*/
sum = (1+n)*n/2; /*執行第10次*/
printf("%d",sum); /*執行一次*/

上面的兩段代碼中，其實不管n有多少個，本質是是3次和12次的執行差別。這種與問題的大小無關，執行時間恆定的算法，成爲具備O(1)的時間複雜度，又叫作常數階。

注意：無論這個常數是多少，3或12，都不能寫成O(3)、O(12)，而都要寫成O(1)

此外，對於分支結構而言，不管真假執行的次數都是恆定不變的，不會隨着n的變大而發生變化，因此單純的分支結構（不在循環結構中），其時間複雜度也是O(1)。

 

線性階：

線性階的循環結構會複雜一些，要肯定某個算法的階次，須要肯定特定語句或某個語句集運行的次數。所以要分析算法的複雜度，關鍵是要分析循環結構的運行狀況。

int i;
for(i = 0 ; i < n ; i++){
  /*時間複雜度爲O(1)的程序*/      
}

對數階：

int count = 1;
while(count < n){
  count = count * 2;
  /*時間複雜度爲O(1)的程序*/    
}

由於每次count*2後，距離結束循環更近了。也就是說有多少個2 相乘後大於n，退出循環。

數學公式：2^x = n    -->     x = log₂ⁿ

所以這個循環的時間複雜度爲O(logn)

 

平方階：

int i;
for(i = 0 ; i < n ; i++){
   for(j = 0 ; j < n ; j++){
    /*時間複雜度爲O(1)的程序*/  
    }    
}

上面的程序中，對於對於內層循環，它的時間複雜度爲O(n)，可是它是包含在外層循環中，再循環n次，所以這段代碼的時間複雜度爲O(n²)。

int i;
for(i = 0 ; i < n ; i++){
   for(j = 0 ; j < m ; j++){
    /*時間複雜度爲O(1)的程序*/  
    }    
}

可是，若是內層循環改爲了m次，時間複雜度就爲O(n*m)

 

再來看一段程序：

int i;
for(i = 0 ; i < n ; i++){
   for(j = i ; j < n ; j++){
    /*時間複雜度爲O(1)的程序*/  
    }    
}

注意：上面的內層循環j = i ;而不是0

由於i = 0時，內層循環執行了n次，當i=1時，執行了n-1次……當i=n-1時，執行了1次，因此總的執行次數爲：

n+(n-1)+(n-1)+...+1 = ⁿ⁽ⁿ⁺¹⁾/₂  =  n²/₂ + _ⁿ/₂

根據大O推導方法，保留最高階項，n²/₂ ，而後去掉這個項相乘的常數，1/2

所以，這段代碼的時間複雜度爲O(n²)

 

下面，分析調用函數時的時間複雜度計算方法：

首先，看一段代碼：

int i,j;

void function(int count){
print(count);
}

for(i = 0 ; i < n ; i++){
function (i)
}

函數的時間複雜度是O(1)，所以總體的時間複雜度爲O(n)。

假如function是這樣的：

void function(int count){
  int j;
  for(j = count ; j < n ;j++){
        /*時間複雜度爲O(1)的程序*/
 }
}

和第一個的不一樣之處在於把嵌套內循環放到了函數中，所以最終的時間複雜度爲O(n²)

 

再來看一個比價複雜的語句:

n++; /*執行次數爲1*/
function(n); /*執行次數爲n*/
int i,j;
for(i = 0 ; i < n ; i++){ /*執行次數爲nXn*/
function(i);
}
for(i = 0 ; i < n ; i++){ /*執行次數爲n(n+1)/2*/
for(j = i ; j < n ; j++){
/*時間複雜度爲O(1)的程序*/
}
}

它的執行次數f(n) = 1 + n + n² + ⁿ⁽ⁿ⁺¹⁾/₂ + ³/₂n²+³/₂ n+1,

根據推導大O階的方法，最終它的時間複雜度爲：O(n²)

 

常見的時間複雜度：

 

時間複雜度所耗費的時間是：

O(1) < O(logn) < O(n) < O(nlogn) < O(n²) < O(n³) <O(2ⁿ) < O(n!) <O(nⁿ)

 

-----------------------------------------------------------------------------------------------------------------------------------------------------------

 

但是當出現 T(n)=T(n-1)+T(n-2)+T(n-3)，這種公式算法的時間複雜度怎麼計算呢？

你可能想說眼觀就知道是 O(n)，但是你有想過它逆序的可能嗎？（有沒有聯想到斐波那契數列？）

 

因此祖宗出來了，Master定理：T (n) = aT (n/b) + f(n)

                            通常，a>=一、b>1,且都爲常數，f(n)爲正

一共有3種狀況：

1. If f(n) = O(n logb a− ) for some constant  > 0, then T (n) = Θ(n logb a ).

2. If f(n) = Θ(n logb a logk n) with1 k ≥ 0, then T (n) = Θ(n logb a logk+1 n).

3. If f(n) = Ω(n logb a+ ) with  > 0, and f(n) satisfies the regularity condition, then T (n) = Θ(f(n)). Regularity condition: af(n/b) ≤ cf(n) for some constant c < 1 and all sufficiently large n.

eg:

1. T (n) = 3T (n/2) + n 2 =⇒ T (n) = Θ(n 2 ) (Case 3)

2. T (n) = 4T (n/2) + n 2 =⇒ T (n) = Θ(n 2 log n) (Case 2)

3. T (n) = T (n/2) + 2n =⇒ Θ(2n ) (Case 3)

4. T (n) = 2nT (n/2) + n n =⇒ Does not apply (a is not constant)

5. T (n) = 16T (n/4) + n =⇒ T (n) = Θ(n 2 ) (Case 1)

6. T (n) = 2T (n/2) + n log n =⇒ T (n) = n log2 n (Case 2)

7. T (n) = 2T (n/2) + n/ log n =⇒ Does not apply (non-polynomial difference between f(n) and n logb a )

8. T (n) = 2T (n/4) + n 0.51 =⇒ T (n) = Θ(n 0.51) (Case 3)

9. T (n) = 0.5T (n/2) + 1/n =⇒ Does not apply (a < 1)

10. T (n) = 16T (n/4) + n! =⇒ T (n) = Θ(n!) (Case 3)

11. T (n) = √ 2T (n/2) + log n =⇒ T (n) = Θ(√ n) (Case 1)

12. T (n) = 3T (n/2) + n =⇒ T (n) = Θ(n lg 3 ) (Case 1)

13. T (n) = 3T (n/3) + √ n =⇒ T (n) = Θ(n) (Case 1)

14. T (n) = 4T (n/2) + cn =⇒ T (n) = Θ(n 2 ) (Case 1)

15. T (n) = 3T (n/4) + n log n =⇒ T (n) = Θ(n log n) (Case 3)

16. T (n) = 3T (n/3) + n/2 =⇒ T (n) = Θ(n log n) (Case 2)

17. T (n) = 6T (n/3) + n 2 log n =⇒ T (n) = Θ(n 2 log n) (Case 3)

18. T (n) = 4T (n/2) + n/ log n =⇒ T (n) = Θ(n 2 ) (Case 1)

19. T (n) = 64T (n/8) − n 2 log n =⇒ Does not apply (f(n) is not positive)

20. T (n) = 7T (n/3) + n 2 =⇒ T (n) = Θ(n 2 ) (Case 3)

21. T (n) = 4T (n/2) + log n =⇒ T (n) = Θ(n 2 ) (Case 1)

22. T (n) = T (n/2) + n(2 − cos n) =⇒ Does not apply. We are in Case 3, but the regularity condition is violated. (Consider n = 2πk, where k is odd and arbitrarily large. For any such choice of n, you can show that c ≥ 3/2, thereby violating the regularity condition.)