複雜度分析：如何分析、統計算法的執行效率和資源消耗？

時間 2019-12-13

標籤複雜度分析如何統計算法執行效率資源消耗简体版

原文原文鏈接

咱們都知道，數據結構和算法自己解決的是「快」和「省」的問題，即如何讓代碼運行得更快，如何讓代碼更省存儲空間。因此，執行效率是算法一個很是重要的考量指標。那如何來衡量你編寫的算法代碼的執行效率呢？這裏就要用到咱們今天要講的內容：時間、空間複雜度分析。算法

其實，只要講到數據結構與算法，就必定離不開時間、空間複雜度分析。複雜度分析是整個算法學習的精髓，只要掌握了它，數據結構和算法的內容基本上就掌握了一半。數組

大 O 複雜度表示法

int cal(int n) {
   int sum = 0;
   int i = 1;
   int j = 1;
   for (; i <= n; ++i) {
     j = 1;
     for (; j <= n; ++j) {
       sum = sum +  i * j;
     }
   }
 }

我來具體解釋一下這個公式。其中，數據結構

T(n)表示代碼執行的時間；
n 表示數據規模的大小；
f(n) 表示每行代碼執行的次數總和。由於這是一個公式，因此用 f(n) 來表示。
O 表示代碼的執行時間 T(n) 與 f(n) 表達式成正比。

這就是大 O 時間複雜度表示法。大 O 時間複雜度實際上並不具體表示代碼真正的執行時間，而是表示代碼執行時間隨數據規模增加的變化趨勢，因此，也叫做漸進時間複雜度（asymptotic time complexity），簡稱時間複雜度。數據結構和算法

時間複雜度分析

只關注循環次數最多的一段代碼

大 O 這種複雜度表示方法只是表示一種變化趨勢。咱們一般會忽略掉公式中的常量、低階、係數，只須要記錄一個最大階的量級就能夠了。因此，咱們在分析一個算法、一段代碼的時間複雜度的時候，也只關注循環執行次數最多的那一段代碼就能夠了。這段核心代碼執行次數的 n 的量級，就是整段要分析代碼的時間複雜度。函數

int cal(int n) {
   int sum = 0;
   int i = 1;
   int j = 1;
   for (; i <= n; ++i) {
     j = 1;
     for (; j <= n; ++j) {
       sum = sum +  i * j;
     }
   }
 }

其中第二、3 行代碼都是常量級的執行時間，與 n 的大小無關，因此對於複雜度並無影響。循環執行次數最多的是第四、5 行代碼，因此這塊代碼要重點分析。前面咱們也講過，這兩行代碼被執行了 n 次，因此總的時間複雜度就是 O(n)。學習

加法法則：總複雜度等於量級最大的那段代碼的複雜度

int cal(int n) {
   int sum_1 = 0;
   int p = 1;
   for (; p < 100; ++p) {
     sum_1 = sum_1 + p;
   }

   int sum_2 = 0;
   int q = 1;
   for (; q < n; ++q) {
     sum_2 = sum_2 + q;
   }
 
   int sum_3 = 0;
   int i = 1;
   int j = 1;
   for (; i <= n; ++i) {
     j = 1; 
     for (; j <= n; ++j) {
       sum_3 = sum_3 +  i * j;
     }
   }
 
   return sum_1 + sum_2 + sum_3;
 }

綜合這三段代碼的時間複雜度，咱們取其中最大的量級。因此，整段代碼的時間複雜度就爲 O(n^2)。也就是說：等於量級最大的那段代碼的時間複雜度。spa

乘法法則：嵌套代碼的複雜度等於嵌套內外代碼複雜度的乘積

也就是說，假設 T1(n) = O(n)，T2(n) = O(n^2)，則 T1(n) * T2(n) = O(n^2)。落實到具體的代碼上，咱們能夠把乘法法則當作是嵌套循環，我舉個例子給你解釋一下。code

int cal(int n) {
   int ret = 0; 
   int i = 1;
   for (; i < n; ++i) {
     ret = ret + f(i);
   } 
 } 
 
 int f(int n) {
  int sum = 0;
  int i = 1;
  for (; i < n; ++i) {
    sum = sum + i;
  } 
  return sum;
 }

咱們單獨看 cal() 函數。假設 f() 只是一個普通的操做，那第 4～6 行的時間複雜度就是，T1(n) = O(n)。但 f() 函數自己不是一個簡單的操做，它的時間複雜度是 T2(n) = O(n)，因此，整個 cal() 函數的時間複雜度就是，T(n) = T1(n) T2(n) = O(nn) = O(n^2)。排序

幾種常見的時間複雜度實例分析

O(1)

首先你必須明確一個概念，O(1) 只是常量級時間複雜度的一種表示方法，並非指只執行了一行代碼。好比這段代碼，即使有 3 行，它的時間複雜度也是 O(1），而不是 O(3)。遞歸

int i = 8;
 int j = 6;
 int sum = i + j;

我稍微總結一下，只要代碼的執行時間不隨 n 的增大而增加，這樣代碼的時間複雜度咱們都記做 O(1)。或者說，通常狀況下，只要算法中不存在循環語句、遞歸語句，即便有成千上萬行的代碼，其時間複雜度也是Ο(1)。

O(logn)、O(nlogn)

對數階時間複雜度很是常見，同時也是最難分析的一種時間複雜度。我經過一個例子來講明一下。

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

根據咱們前面講的複雜度分析方法，第三行代碼是循環執行次數最多的。因此，咱們只要能計算出這行代碼被執行了多少次，就能知道整段代碼的時間複雜度。

從代碼中能夠看出，變量 i 的值從 1 開始取，每循環一次就乘以 2。當大於 n 時，循環結束。還記得咱們高中學過的等比數列嗎？實際上，變量 i 的取值就是一個等比數列。若是我把它一個一個列出來，就應該是這個樣子的：

因此，咱們只要知道 x 值是多少，就知道這行代碼執行的次數了。經過 2^x=n 求解 x 這個問題咱們想高中應該就學過了，我就很少說了。x=log2n，因此，這段代碼的時間複雜度就是 O(log2n)。

如今，我把代碼稍微改下，你再看看，這段代碼的時間複雜度是多少？

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

根據我剛剛講的思路，很簡單就能看出來，這段代碼的時間複雜度爲 O(log3n)。

實際上，不論是以 2 爲底、以 3 爲底，仍是以 10 爲底，咱們能夠把全部對數階的時間複雜度都記爲 O(logn)。爲何呢？

咱們知道，對數之間是能夠互相轉換的，log(3)(n) 就等於 log(3)(2) log(2)(n)，因此 O(log(3)(n)) = = O(C log(2)(n))，其中 C=log(3)(2) 是一個常量。基於咱們前面的一個理論：在採用大 O 標記複雜度的時候，能夠忽略係數，即 O(Cf(n)) = O(f(n))。因此，O(log2n) 就等於 O(log3n)。所以，在對數階時間複雜度的表示方法裏，咱們忽略對數的「底」，統一表示爲 O(logn)。

若是你理解了我前面講的 O(logn)，那 O(nlogn) 就很容易理解了。還記得咱們剛講的乘法法則嗎？若是一段代碼的時間複雜度是 O(logn)，咱們循環執行 n 遍，時間複雜度就是 O(nlogn) 了。並且，O(nlogn) 也是一種很是常見的算法時間複雜度。好比，歸併排序、快速排序的時間複雜度都是 O(nlogn)。

O(m+n)、O(m*n)

int cal(int m, int n) {
  int sum_1 = 0;
  int i = 1;
  for (; i < m; ++i) {
    sum_1 = sum_1 + i;
  }

  int sum_2 = 0;
  int j = 1;
  for (; j < n; ++j) {
    sum_2 = sum_2 + j;
  }

  return sum_1 + sum_2;
}

從代碼中能夠看出，m 和 n 是表示兩個數據規模。咱們沒法事先評估 m 和 n 誰的量級大，因此咱們在表示複雜度的時候，就不能簡單地利用加法法則，省略掉其中一個。因此，上面代碼的時間複雜度就是 O(m+n)。

針對這種狀況，原來的加法法則就不正確了，咱們須要將加法規則改成：T1(m) + T2(n) = O(f(m) + g(n))。可是乘法法則繼續有效：T1(m)T2(n) = O(f(m) f(n))。

空間複雜度分析

void print(int n) {
  int i = 0;
  int[] a = new int[n];
  for (i; i <n; ++i) {
    a[i] = i * i;
  }

  for (i = n-1; i >= 0; --i) {
    print out a[i]
  }
}

跟時間複雜度分析同樣，咱們能夠看到，第 2 行代碼中，咱們申請了一個空間存儲變量 i，可是它是常量階的，跟數據規模 n 沒有關係，因此咱們能夠忽略。第 3 行申請了一個大小爲 n 的 int 類型數組，除此以外，剩下的代碼都沒有佔用更多的空間，因此整段代碼的空間複雜度就是 O(n)。

咱們常見的空間複雜度就是 O(1)、O(n)、O(n^2 )，像 O(logn)、O(nlogn) 這樣的對數階複雜度平時都用不到。並且，空間複雜度分析比時間複雜度分析要簡單不少。因此，對於空間複雜度，掌握剛我說的這些內容已經足夠了。