複雜度分析(上)

1什麼是複雜度分析?

分別用時間複雜度(執行的快慢)和空間複雜度(內存的消耗 )兩個概念來描述性能問題，兩者統稱爲複雜度.

複雜度就是用來分析算法執行效率與數據規模之間增加關係。

 

2.爲何要進行復雜度分析?

1.和性能測試相比，複雜度分析有不依賴執行環境、成本低、效率高、易操做、指導性強的特色。
2.掌握複雜度分析，將能編寫出性能更優的代碼，有利於下降系統開發和維護成本。　

 

3.如何進行數據結構和算法的複雜度分析?

1.大O表示法
1）來源
算法的執行時間與每行代碼的執行次數成正比，用T(n) = O(f(n))表示，其中T(n)表示算法執行總時間，f(n)表示每行代碼執行總次數，而n每每表示數據的規模。
2）特色
以時間複雜度爲例，因爲時間複雜度描述的是算法執行時間與數據規模的增加變化趨勢，因此常量階、低階以及係數實際上對這種增加趨勢不產決定性影響，因此在作時間複雜度分析時忽略這些項。
2.複雜度分析法則
1）單段代碼看高頻(只關注循環執行次數最多的一段代碼)：好比循環。

1　　int cal(int n) {
2　　int sum = 0;
3　　int i = 1;
4　　for (; i <= n; ++i) {
5　　sum = sum + i;
6　　}
7　　return sum;
8　　}

其中第 二、3 行代碼都是常量級的執行時間，與 n 的大小無關.四、5兩行爲循環執行次數最多的一段代碼,

這兩行代碼執行了n次．因此複雜程度是Ｏ（ｎ）．

2）加法法則：總複雜度等於量級最大的那段代碼的複雜度：好比一段代碼中有單循環和多重循環，那麼取多重循環的複雜度。

１　　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) {
10　　sum_2 = sum_2 + q;
11　　}
12
13　　int sum_3 = 0;
14　　int i = 1;
15　　int j = 1;
16　　for (; i <= n; ++i) {
17　　j = 1;
18　　for (; j <= n; ++j) {
19　　sum_3 = sum_3 + i * j;
20　　}
21　　}
22
23　　return sum_1 + sum_2 + sum_3;
24　　}

其中的四、５兩行執行了１００次，與ｎ無關．

段代碼循環 10000 次、100000 次，只要是一個已知的數(常量,與n無關),就能夠忽略.由於時間複雜度表示的是一個算法執行效率

與數據規模增加的變化趨勢.因此無論常量的執行時間對增加趨勢並無影響.

９、１０兩段代碼的時間複雜程度是O(n),１６、１７、１８、１９的時間複雜程度是O(n2)．因此這段代碼的時間複雜程度是O(n2)．

3）乘法法則：嵌套代碼的複雜度等於嵌套內外代碼複雜度的乘積：好比遞歸、多重循環等

１　　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;
１６　}

第 4～6 行的時間複雜度就是，T1(n) = O(n)．但第五行的 f(i)函數自己就是 O(n)，因此整個函數的複雜程度就是

T(n) = T1(n) * T2(n) = O(n*n) = O(n2)。

 

4、經常使用的複雜度級別
多項式階：隨着數據規模的增加，算法的執行時間和空間佔用，按照多項式的比例增加。包括，
O(1)（常數階）、O(logn)（對數階）、O(n)（線性階）、O(nlogn)（線性對數階）、O(n^2)（平方階）、O(n^3)（立方階）
非多項式階：隨着數據規模的增加，算法的執行時間和空間佔用暴增，這類算法性能極差。包括，
O(2^n)（指數階）、O(n!)（階乘階）

1. O(1)

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

O(1) 只是常量級時間複雜度的一種表示方法，並非指只執行了一行代碼。好比這段代碼，即使有 3 行，

它的時間複雜度也是O(1），而不是 O(3)。

 

2. O(logn)、O(nlogn)

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

這段代碼ｉ＜＝ｎ時結束，那麼就是２的ｉ次方＝Ｎ．求得時ｉ的值．則x=log2n．時間複雜度就是 O(log2n)。

可是對數是能夠相互轉換的．例如log3n 就等於 log32 * log2n．因此 O(log3n) = O(C * log2n)，其中C=log32 是一個常量．

在採用大 O 標記複雜度的時候，能夠忽略係數，即 O(Cf(n)) = O(f(n))。因此，O(log2n) 就等於 O(log3n)。

所以，在對數階時間複雜度的表示方法裏，咱們忽略對數的「底」，，統一表示爲 O(logn)。

那麼O(nlogn)就是循環執行一段時間複雜程度是O(logn)的代碼．

 

3. 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))。

 

空間複雜度分析

空間複雜度全稱就是漸進空間複雜度（asymptotic space complexity），表示算法的存儲空間與數據規模之間的增加關係。

１　　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]
９　　}
１０　}

第３行申請了一個大小爲ｎ的int類型數組．其餘的代碼沒有佔用更多的空間．因此整段代碼的複雜程度就是O(n)

 

 

上面說了這麼多,可是沒有真正的用到有時候就不會真正的理解.因此想要真正的想要理解複雜分析度仍是要多加練習.

 

本文是在學習王爭老師的數據結構與算法之美的筆記.有些是王爭老師或者評論的言語.在此附上原文連接

 https://time.geekbang.org/column/article/40036