什么是算法的時間和空間復雜度

　　算法（Algorithm）是指用來操作數據、解決程序問題的一組方法。對於同一個問題，使用不同的算法，也許最終得到的結果是一樣的，但在過程中消耗的資源和時間卻會有很大的區別。

　　那么我們應該如何去衡量不同算法之間的優劣呢？

　　主要還是從算法所占用的「時間」和「空間」兩個維度去考量。

• 時間維度：是指執行當前算法所消耗的時間，我們通常用「時間復雜度」來描述。

• 空間維度：是指執行當前算法需要占用多少內存空間，我們通常用「空間復雜度」來描述。

　　因此，評價一個算法的效率主要是看它的時間復雜度和空間復雜度情況。然而，有的時候時間和空間卻又是「魚和熊掌」，不可兼得的，那么我們就需要從中去取一個平衡點。

　　下面我來分別介紹一下「時間復雜度」和「空間復雜度」的計算方式。

一、時間復雜度

　　我們想要知道一個算法的「時間復雜度」，很多人首先想到的的方法就是把這個算法程序運行一遍，那么它所消耗的時間就自然而然知道了。這種方式可以嗎？當然可以，不過它也有很多弊端。

　　這種方式非常容易受運行環境的影響，在性能高的機器上跑出來的結果與在性能低的機器上跑的結果相差會很大。而且對測試時使用的數據規模也有很大關系。再者，並我們在寫算法的時候，還沒有辦法完整的去運行呢。因此，另一種更為通用的方法就出來了：「 大O符號表示法 」，即 T(n) = O(f(n))

我們先來看個例子：

for(i=1; i<=n; ++i)
{
   j = i;
   j++;
}

　　通過「 大O符號表示法 」，這段代碼的時間復雜度為：O(n) ，為什么呢?

　　在 大O符號表示法中，時間復雜度的公式是： T(n) = O( f(n) )，其中f(n) 表示每行代碼執行次數之和，而 O 表示正比例關系，這個公式的全稱是：算法的漸進時間復雜度 。

　　我們繼續看上面的例子，假設每行代碼的執行時間都是一樣的，我們用 1顆粒時間 來表示，那么這個例子的第一行耗時是1個顆粒時間，第三行的執行時間是 n個顆粒時間，第四行的執行時間也是 n個顆粒時間（第二行和第五行是符號，暫時忽略），那么總時間就是 1顆粒時間 + n顆粒時間 + n顆粒時間 ，即 (1+2n)個顆粒時間，即： T(n) =  (1+2n)*顆粒時間，從這個結果可以看出，這個算法的耗時是隨着n的變化而變化，因此，我們可以簡化的將這個算法的時間復雜度表示為：T(n) =  O(n)。

　　為什么可以這么去簡化呢，因為大O符號表示法並不是用於來真實代表算法的執行時間的，它是用來表示代碼執行時間的增長變化趨勢的。

　　所以上面的例子中，如果n無限大的時候，T(n) =  time(1+2n)中的常量1就沒有意義了，倍數2也意義不大。因此直接簡化為T(n) =  O(n) 就可以了。

常見的時間復雜度量級有：

• 常數階O(1)

• 對數階O(logN)

• 線性階O(n)

• 線性對數階O(nlogN)

• 平方階O(n²)

• 立方階O(n³)

• K次方階O(n^k)

• 指數階(2^n)

上面從上至下依次的時間復雜度越來越大，執行的效率越來越低。

下面選取一些較為常用的來講解一下（沒有嚴格按照順序）：

1.常數階O(1)

無論代碼執行了多少行，只要是沒有循環等復雜結構，那這個代碼的時間復雜度就都是O(1)，如：

int i = 1;
int j = 2;
++i;
j++;
int m = i + j;

 

上述代碼在執行的時候，它消耗的時候並不隨着某個變量的增長而增長，那么無論這類代碼有多長，即使有幾萬幾十萬行，都可以用O(1)來表示它的時間復雜度。

2.線性階O(n)

這個在最開始的代碼示例中就講解過了，如：

for(i=1; i<=n; ++i)
{
   j = i;
   j++;
} 

這段代碼，for循環里面的代碼會執行n遍，因此它消耗的時間是隨着n的變化而變化的，因此這類代碼都可以用O(n)來表示它的時間復雜度。

3.對數階O(logN)

還是先來看代碼：

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

從上面代碼可以看到，在while循環里面，每次都將 i 乘以 2，乘完之后，i 距離 n 就越來越近了。我們試着求解一下，假設循環x次之后，i 就大於 2 了，此時這個循環就退出了，也就是說 2 的 x 次方等於 n，那么 x = log2^n
也就是說當循環 log2^n 次以后，這個代碼就結束了。因此這個代碼的時間復雜度為：O(logn)

4.線性對數階O(nlogN)

線性對數階O(nlogN) 其實非常容易理解，將時間復雜度為O(logn)的代碼循環N遍的話，那么它的時間復雜度就是 n * O(logN)，也就是了O(nlogN)。

就拿上面的代碼加一點修改來舉例：

for(m=1; m<n; m++)
{
    i = 1;
    while(i<n)
    {
        i = i * 

5.平方階O(n²) 

平方階O(n²) 就更容易理解了，如果把 O(n) 的代碼再嵌套循環一遍，它的時間復雜度就是 O(n²) 了。
舉例：

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

這段代碼其實就是嵌套了2層n循環，它的時間復雜度就是 O(n*n)，即  O(n²) 
如果將其中一層循環的n改成m，即：

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

那它的時間復雜度就變成了 O(m*n)

6.立方階O(n³)及K次方階O(n^k)

參考上面的O(n²) 去理解就好了，相當於三層n循環，其它的類似。

除此之外，其實還有 平均時間復雜度、均攤時間復雜度、最壞時間復雜度、最好時間復雜度 的分析方法，有點復雜，這里就不展開了。

二、空間復雜度

　　既然時間復雜度不是用來計算程序具體耗時的，那么我也應該明白，空間復雜度也不是用來計算程序實際占用的空間的。空間復雜度是對一個算法在運行過程中臨時占用存儲空間大小的一個量度，同樣反映的是一個趨勢，我們用 S(n) 來定義。

　　空間復雜度比較常用的有：O(1)、O(n)、O(n²)，我們下面來看看：

1.空間復雜度O(1)

如果算法執行所需要的臨時空間不隨着某個變量n的大小而變化，即此算法空間復雜度為一個常量，可表示為 O(1)
舉例：

int i = 1;
int j = 2;
++i;
j++;
int m = i + j; 

代碼中的 i、j、m 所分配的空間都不隨着處理數據量變化，因此它的空間復雜度 S(n) = O(1)

2.空間復雜度O(n)

我們先看一個代碼：

int[] m = new int[n]
for(i=1; i<=n; ++i)
{
   j = i;
   j++;
} 

這段代碼中，第一行new了一個數組出來，這個數據占用的大小為n，這段代碼的2-6行，雖然有循環，但沒有再分配新的空間，因此，這段代碼的空間復雜度主要看第一行即可，即 S(n) = O(n)

 

 

 

 

原文參考【Java知音網】