演算法時間複雜度的計算

函數代碼之時代複雜度計算：http://hi.baidu.com/dbfr2011818/item/f99fe7df0d65471bd68ed0ee

定義：如果一個問題的規模是n，解這一問題的某一演算法所需要的時間為T(n)，它是n的某一函數 T(n)稱為這一演算法的“時間複雜性”。

     求解演算法的時間複雜度的具體步驟是：

[1] 找出演算法中的基本語句:演算法中執行次數最多的那條語句就是基本語句，通常是最內層迴圈的迴圈體。

[2] 計算基本語句的執行次數的數量級:這就意味著只要保證基本語句執行次數的函數中的最高次冪正確即可，可以忽略所有低次冪和最高次冪的係數。這樣能夠簡化演算法分析，並且使注意力集中在最重要的一點上：增長率。

[3] 用大Ο記號表示演算法的時間效能。

     如果演算法中包含嵌套的迴圈，則基本語句通常是最內層的迴圈體，如果演算法中包含並列的迴圈，則將並列迴圈的時間複雜度相加。例如：

　　for (i=1; i<=n; i++)
　　     x++;

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

　　第一個for迴圈的時間複雜度為Ο(n)，第二個for迴圈的時間複雜度為Ο(n^2)，則整個演算法的時間複雜度為Ο(n+n^2)=Ο(n^2)。

      二分檢索是 O(logn),也就是說它需要“通過logn量級的步驟去檢索一個規模為n的數組”記法 O ( f(n) )表示當 n增大時，已耗用時間至多將以正比於 f(n)的速度增長。

　　常見的演算法時間複雜度由小到大依次為：

　　Ο(1)＜Ο(log2n)＜Ο(n)＜Ο(nlog2n)＜Ο(n2)＜Ο(n3)＜…＜Ο(2n)＜Ο(n!)

Ο(1)表示基本語句的執行次數是一個常數，一般來說，只要演算法中不存在迴圈語句，其時間複雜度就是Ο(1)。Ο(log2n)、Ο(n)、Ο(nlog2n)、Ο(n2)和Ο(n3)稱為多項式時間，而Ο(2n)和Ο(n!)稱為指數時間。電腦科學家普遍認為前者是有效演算法，把這類問題稱為P類問題，而把後者稱為NP問題。

O(1): Temp=i;i=j;j=temp;                    

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

O(n^2)

    交換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;        ①   

       for (j=0;j<=(2*n);j++)    

          x++;        ②      

   }         

解：  語句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).         

O(n)                                        

   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的頻度：n-1,                                  

         T(n)=2+n+3(n-1)=4n-1=O(n).

                                                                                                 

O(log2n )

   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 )

 

 O(n^3)

   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(n^2)，但期望時間是 O(nlogn)。通過每次都仔細地選擇基準值，我們有可能把平方情況 (即O(n^2)情況)的機率減小到幾乎等於 0。在實際中，精心實現的快速排序一般都能以 (O(nlogn)時間運行。

下面是一些常用的記法：

訪問數組中的元素是常數時間操作，或說O(1)操作。一個演算法如果能在每個步驟去掉一半資料元素，如二分檢索，通常它就取 O(logn)時間。用strcmp比較兩個具有n個字元的串需要O(n)時間。常規的矩陣乘演算法是O(n^3)，因為算出每個元素都需要將n對元素相乘並加到一起，所有元素的個數是n^2。

指數時間演算法通常來源於需要求出所有可能結果。例如，n個元素的集合共有2n個子集,所以要求出所有子集的演算法將是O(2n)的.指數演算法一般說來是太複雜了，除非n的值非常小，因為，在這個問題中增加一個元素就導致已耗用時間加倍。不幸的是，確實有許多問題 (如著名 的“巡迴售貨員問題” )，到目前為止找到的演算法都是指數的。如果我們真的遇到這種情況， 通常應該用尋找近似最佳結果的演算法替代之。