時間複雜度 空間複雜度

①時間複雜度

      通常狀況下，算法的基本操做重複執行的次數是模塊n的某一個函數f（n）。

      所以，算法的時間複雜度記作：T（n）=O（f（n））。

      當咱們評價一個算法的時間性能時，主要標準就是算法的漸近時間複雜度T（n），所以，在算法分析時，每每對二者不予區分，常常是將漸近時間複雜度T(n)=O(f(n))簡稱爲時間複雜度，其中的f(n)通常是算法中頻度最大的語句頻度。此外，算法中語句的頻度不只與問題規模有關，還與輸入實例中各元素的取值相關。可是咱們老是考慮在最壞的狀況下的時間複雜度。以保證算法的運行時間不會比它更長。

       在計算時間複雜度的時候，先找出算法的基本操做，而後根據相應的各語句肯定它的執行次數，再找出T（n）的同數量級（它的同數量級有如下：1，Log2n ，n ，nLog2n ，n的平方，n的三次方，2的n次方，n！），找出後，f（n）=該數量級，若T(n)/f(n)求極限可獲得一常數c，則時間複雜度 T（n）=O（f（n））。常見的時間複雜度，按數量級遞增排列依次爲：常數階O(1){Hash表的查找}、對數階O(log2n){二分查找}、線性階O(n)、線性對數階 O(nlog2n){快速排序的平均複雜度}、平方階O(n^2){冒泡排序}、立方階O(n^3){求最短路徑的Floyd算法}、k次方階 O(n^k)、指數階O(2^n){漢諾塔}。

       規則：有以下複雜度關係：c < log2N < n < n * Log2N < n^2 < n^3 < 2^n < 3^n < n!

       其中c是一個常量，若是一個算法的複雜度爲c 、 log2N 、n 、 n*log2N ,那麼這個算法時間效率比較高 ，若是是 2^n , 3^n ,n!，那麼稍微大一些的n就會令這個算法不能動了。

       咱們常須要描述特定算法相對於 n(輸入元素的個數 )須要作的工做量。在一組未排序的數據中檢索，所需的時間與 n成正比；若是是對排序數據用二分檢索，花費的時間正比於logn。排序時間可能正比於n^2或者nlogn。

       咱們但願可以比較算法的運行時間和空間要求，並使這種比較能與程序設計語言、編譯系統、機器結構、處理器的速度及系統的負載等複雜因素無關。

        爲了這個目的，人們提出了一種標準的記法，稱爲「大O記法」.在這種描述中使用的基本參數是 n，即問題實例的規模，把複雜性或運行時間表達爲n的函數 。這裏的「O」表示量級 (order)，好比說「二分檢索是 O(logn)的」,也就是說它須要「經過logn量級的步驟去檢索一個規模爲n的數組」記法O ( f(n) )表示當n增大時，運行時間至多將以正比於f(n)的速度增加。這種漸進估計對算法的理論分析和大體比較是很是有價值的，但在實踐中細節也可能形成差別。 例如，一個低附加代價的O(n2)算法在n較小的狀況下可能比一個高附加代價的O(nlogn)算法運行得更快。固然，隨着n足夠大之後，具備較慢上升函 數的算法必然工做得更快。

       Temp=i;i=j;j=temp;

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

②實例

一、設三個函數f,g,h分別爲 f(n)=100n^3+n^2+1000 , g(n)=25n^3+5000n^2 , h(n)=n^1.5+5000nlgn
請判斷下列關係是否成立：
（1） f(n)=O(g(n))
（2） g(n)=O(f(n))
（3） h(n)=O(n^1.5)
（4） h(n)=O(nlgn)
這 裏咱們複習一下漸近時間複雜度的表示法T(n)=O(f(n))，這裏的"O"是數學符號，它的嚴格定義是"若T(n)和f(n)是定義在正整數集合上的 兩個函數，則T(n)=O(f(n))表示存在正的常數C和n0 ,使得當n≥n0時都知足0≤T(n)≤C?f(n)。"用容易理解的話說就是這兩個函數當整型自變量n趨向於無窮大時，二者的比值是一個不等於0的常 數。這麼一來，就好計算了吧。

（1）成立。題中因爲兩個函數的最高次項都是n^3,所以當n→∞時，兩個函數的比值是一個常數，因此這個關係式是成立的。
（2）成立。與上同理。
（3）成立。與上同理。
（4）不成立。因爲當n→∞時n^1.5比nlgn遞增的快，因此h(n)與nlgn的比值不是常數，故不成立。

二、設n爲正整數，利用大"O"記號，將下列程序段的執行時間表示爲n的函數。

i=1; k=0 
while(i<n){ 
   k=k+10*i;
   i++;
}

解答：T(n)=n-1， T(n)=O(n)， 這個函數是按線性階遞增的。
三、將下列程序段的執行時間表示爲n的函數。

x=n; // n>1 
while (x>=(y+1)*(y+1)){
   y++;
}

解答：T(n)=n1/2 ，T(n)=O(n1/2)， 最壞的狀況是y=0，那麼循環的次數是n1/2次，這是一個按平方根階遞增的函數。

四、將下列程序段的執行時間表示爲n的函數。

x=91; y=100; 
while(y>0){
    if(x>100){
       x=x-10;
       y--;
    }else {
       x++;
    }
}

解答： T(n)=O(1)， 這個程序看起來有點嚇人，總共循環運行了1000次，可是咱們看到n沒有? 沒。這段程序的運行是和n無關的，就算它再循環一萬年，咱們也無論他，只是一個常數階的函數。

五、交換i和j的內容

sum=0；                      //  一次
for(i=1;i<=n;i++){           //  n次
    for(j=1;j<=n;j++){       //  n^2次
      sum++；                //  n^2次
    }  
}

       解：T(n)=2n^2+n+1 =O(n^2)

六、另外一種循環

for (i=1;i<n;i++){
     y=y+1;                      //語句1
     for (j=0;j<=(2*n);j++){ 
        x++;                     //語句2
     }
}

解：語句1的頻度是n-1, 語句2的頻度是(n-1)*(2n+1)=2n^2-n-1 。 f(n)=2n^2-n-1+(n-1)=2n^2-2,該程序的時間複雜度T(n)=O(n^2).

七、繼續循環

a=0;b=1;                        //語句一
for (i=1;i<=n;i++)　            //語句二
{
  s=a+b;　　　　                 //語句三
  b=a;　　　　　                 //語句四
  a=s;　　　　　                 //語句五
}

解：語句1的頻度：2,  語句2的頻度： n,  語句3的頻度： n-1,   語句4的頻度：n-1, 語句5的頻度：n1,                                   則：T（n)=2+n+3(n-1)=4n-1=O(n).

八、繼續循環

i=1;  
while (i<=n){
  i=i*2;                     //語句二
}

解：語句1的頻度是1,   設語句2的頻度是f(n),  則：2^f(n)<=n;f(n)<=log2n  ，取最大值f(n)= log2n,

     則該程序的時間複雜度T(n)=O(log2n )

九、繼續循環

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)/6。因此時間複雜度爲O(n^3).

      

③總結一下

      下面是一些經常使用的記法：

•        訪問數組中的元素是常數時間操做，或說O(1)操做。

•        一個算法若是能在每一個步驟去掉一半數據元素，如二分檢索，一般它就取O(logn)時間。

•        一層循環次數於n相關或者間接與n相關的話那麼爲O(n)，兩層就爲O(n^2),，兩層就爲O(n^3),例題中有不少

•         常規的矩陣乘算法是O(n^3)，由於算出每一個元素都須要將n對元素相乘並加到一塊兒，全部元素的個數是n^2。

•         咱們還應該區分算法的最壞狀況的行爲和期 望行爲。如快速排序的最壞狀況運行時間是O(n^2)，但指望時間是O(nlogn)。經過每次都仔細地選擇基準值，咱們有可能把平方狀況 (即O(n^2)狀況)的機率減少到幾乎等於0。在實際中，精心實現的快速排序通常都能以(O(nlogn)時間運行。

•          指數時間算法一般來源於須要求出全部可能結果。例如，n個元 素的集合共有2n個子集,因此要求出全部子集的算法將是O(2n)的。指數算法通常說來是太複雜了，除非n的值很是小，由於，在這個問題中增長一個元素就 致使運行時間加倍。不幸的是，確實有許多問題 (如著名 的「巡迴售貨員問題」)，到目前爲止找到的算法都是指數的。若是咱們真的遇到這種狀況， 一般應該用尋找近似最佳結果的算法替代之。