演算法復雜度計算

1. 演算法的時間復雜度

空間復雜度是指演算法在計算機內執行時所需存儲空間的度量。
我們一般所討論的是除正常佔用內存開銷外的輔助存儲單元規模.

本人: 空間復雜度跟指令條數沒有必然聯系,同一種演算法你可以寫得很長 也可以寫得很短 但是他們的復雜度是一樣的

2. 演算法的時間復雜度是對演算法什麼的度量

這演算法的運行標准，是通過測量的方式以及計算的模擬實驗。

3. 如何計算一個演算法的時間復雜度

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

1、找出演算法中的基本語句：

演算法中執行次數最多的那條語句就是基本語句，通常是最內層循環的循環體。

2、計算基本語句的執行次數的數量級：

（1）只需計算基本語句執行次數的數量級，這就意味著只要保證基本語句執行次數的函數中的最高次冪正確即可，可以忽略所有低次冪和最高次冪的系數。

（2）這樣能夠簡化演算法分析，並且使注意力集中在最重要的一點上：增長率。

3、用大Ο記號表示演算法的時間性能：

（1）將基本語句執行次數的數量級放入大Ο記號中。

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

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

（3）第一個for循環的時間復雜度為Ο(n)，第二個for循環的時間復雜度為Ο(n2)，則整個演算法的時間復雜度為Ο(n+n2)=Ο(n2)。

4. C語言演算法的時間復雜度如何計算啊

看看這個
每個循環都和上一層循環的參數有關。
所以要用地推公式：
設i(n)表示第一層循環的i為n時的循環次數，注意到他的下一層循環次數剛好就是n，分別是0,1,2...n-1
所以，把每一層循環設一個函數分別為：j(n),k(n),t(n)
則有
i(n)=j(0)+...+j(n-1)
j(n)=k(0)+...+k(n-1)
k(n)=t(0)+...+t(n-1)
i(0)=j(0)=k(0)=0
t(n)=1
而總循環數是i(0)+i(1)...+i(n-1)
可以根據遞推條件得出准確值
所以演算法復雜度是O(i(0)+i(1)...+i(n-1))
記得採納啊

5. 如何計算一個演算法的時間復雜度

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

1、找出演算法中的基本語句：

演算法中執行次數最多的那條語句就是基本語句，通常是最內層循環的循環體。

2、計算基本語句的執行次數的數量級：

（1）只需計算基本語句執行次數的數量級，這就意味著只要保證基本語句執行次數的函數中的最高次冪正確即可，可以忽略所有低次冪和最高次冪的系數。

（2）這樣能夠簡化演算法分析，並且使注意力集中在最重要的一點上：增長率。

3、用大Ο記號表示演算法的時間性能：

（1）將基本語句執行次數的數量級放入大Ο記號中。

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

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

（3）第一個for循環的時間復雜度為Ο(n)，第二個for循環的時間復雜度為Ο(n2)，則整個演算法的時間復雜度為Ο(n+n2)=Ο(n2)。

6. 演算法空間復雜度怎麼算

演算法空間復雜度計算方法：

一個演算法的空間復雜度只考慮在運行過程中為局部變數分配的存儲空間的大小，它包括為參數表中形參變數分配的存儲空間和為在函數體中定義的局部變數分配的存儲空間兩個部分。

若一個演算法為遞歸演算法，其空間復雜度為遞歸所使用的堆棧空間的大小，它等於一次調用所分配的臨時存儲空間的大小乘以被調用的次數(即為遞歸調用的次數加1，這個1表示開始進行的一次非遞歸調用)。

演算法的空間復雜度一般也以數量級的形式給出。如當一個演算法的空間復雜度為一個常量，即不隨被處理數據量n的大小而改變時，可表示為O(1)；當一個演算法的空間復雜度與以2為底的n的對數成正比時，可表示為O(log2n)；當一個演算法的空間復雜度與n成線性比例關系時，可表示為O(n)。若形參為數組，則只需要為它分配一個存儲由實參傳送來的一個地址指針的空間，即一個機器字長空間；若形參為引用方式，則也只需要為其分配存儲一個地址的空間，用它來存儲對應實參變數的地址，以便由系統自動引用實參變數。

(6)演算法復雜度計算擴展閱讀：

空間復雜度(Space Complexity)是對一個演算法在運行過程中臨時佔用存儲空間大小的量度，記做S(n)=O(f(n))。比如直接插入排序的時間復雜度是O(n^2),空間復雜度是O(1) 。而一般的遞歸演算法就要有O(n)的空間復雜度了，因為每次遞歸都要存儲返回信息。一個演算法的優劣主要從演算法的執行時間和所需要佔用的存儲空間兩個方面衡量。

個演算法的空間復雜度S(n)定義為該演算法所耗費的存儲空間，它也是問題規模n的函數。漸近空間復雜度也常常簡稱為空間復雜度。空間復雜度(SpaceComplexity)是對一個演算法在運行過程中臨時佔用存儲空間大小的量度。一個演算法在計算機存儲器上所佔用的存儲空間，包括存儲演算法本身所佔用的存儲空間，演算法的輸入輸出數據所佔用的存儲空間和演算法在運行過程中臨時佔用的存儲空間這三個方面。

7. 如何分析演算法的復雜度

演算法的復雜性
演算法的復雜性是演算法效率度量，是評價演算法優劣的重要依據。一個演算法的復雜性的高低體現在運行該演算法所需要的計算機資源的多少上面，所需的資源越多，我們就說該演算法的復雜性越高；反之，所需的資源越低，則該演算法的復雜性越低。
計算機的資源，最重要的是時間和空間（即存儲器）資源。因而，演算法的復雜性有時間復雜性和空間復雜性之分。
不言而喻，對於任意給定的問題，設計出復雜性盡可能低的演算法是我們在設計演算法時追求的一個重要目標；另一方面，當給定的問題已有多種演算法時，選擇其中復雜性最低者，是我們在選用演算法適應遵循的一個重要准則。因此，演算法的復雜性分析對演算法的設計或選用有著重要的指導意義和實用價值。
簡言之，在演算法學習過程中，我們必須首先學會對演算法的分析，以確定或判斷演算法的優劣。
1.時間復雜性：
例1：設一程序段如下（為討論方便，每行前加一行號）
(1) for i:=1 to n do
(2) for j:=1 to n do
(3) x:=x+1
......
試問在程序運行中各步執行的次數各為多少？
解答：
行號 次數(頻度)
(1) n+1
(2) n*(n+1)
(3) n*n
可見，這段程序總的執行次數是：f(n)=2n2+2n+1。在這里，n可以表示問題的規模，當n趨向無窮大時，如果 f(n)的值很小，則演算法優。作為初學者，我們可以用f(n)的數量級O來粗略地判斷演算法的時間復雜性，如上例中的時間復雜性可粗略地表示為T(n)=O(n2)。

8. 某演算法的時間復雜度為O(n),表明該演算法的：

C、執行時間與n成正比。

A選項，演算法的時間復雜度與問題規模沒有任何關系。故A選項錯誤。

B選項，任何演算法的執行時間都幾乎不可能完全等於。故B選項錯誤。

C選項，如果一個演算法的時間復雜度為，的值增加，的值也會隨之增加，那麼執行時間肯定就是與成正比的。故C選項正確。

D選項，一個演算法的時間復雜度與這個問題的數據規模沒有關系，故D選項也錯誤。

(8)演算法復雜度計算擴展閱讀：

演算法的時間復雜度通常用大O符號表述，定義為T[n] = O(f(n))。稱函數T(n)以f(n)為界或者稱T(n)受限於f(n)。

如果一個問題的規模是n，解這一問題的某一演算法所需要的時間為T(n)。T(n)稱為這一演算法的「時間復雜度」。當輸入量n逐漸加大時，時間復雜度的極限情形稱為演算法的「漸近時間復雜度」。

9. 演算法的時間復雜度

時間復雜度的表示: O(執行次數)

一個有序的元素列表查找某個元素可以用二分查找，每次取中間元素進行比較大小，直到相等。因為每次不符合時總會排除一半的元素 ，所以查找的次數為log2n，那麼時間復雜度為O(log2n)。如果是一個無序的元素列表，查找從位置0開始，那麼簡單查找的次數為n，那麼時間復雜度為O(n)。

除此之外快速排序為O(n*log2n)，選擇排序為O(n*n)。

旅行演算法就是n個旅行地點，你可從某個地方出發到餘下某下一個地點，走完所有地點。從最開始時走有n個地點可以選擇，接下來再走就有n-1個地點可以選擇，這樣直到只有一個地點可以選擇。那麼所有你可走的路徑就是一個階乘，選擇復雜度為O( n!)。

關於數組和鏈表的操作。先說數組，因為你有了元素的索引，可以隨機訪問，你就能快速找到這個元素，而且所有元素的讀取都是一樣的步驟，所以讀取時間復雜度為O(1)，數組的插入和刪除的時間復雜度為O(n)，因為要移動元素。鏈表的特性是每個都存儲了下一個元素的地址，只能順序訪問。那麼讀取插入刪除的時間復雜度分別是O(n)、O(1)、O(1)。

10. 演算法時間復雜度怎麼算

一、概念
時間復雜度是總運算次數表達式中受n的變化影響最大的那一項(不含系數)
比如：一般總運算次數表達式類似於這樣：
a*2^n+b*n^3+c*n^2+d*n*lg(n)+e*n+f
a ！ =0時，時間復雜度就是O(2^n);
a=0,b<>0 =>O(n^3);
a,b=0,c<>0 =>O(n^2)依此類推
eg:
(1) for(i=1;i<=n;i++) //循環了n*n次，當然是O(n^2)
for(j=1;j<=n;j++)
s++;
(2) for(i=1;i<=n;i++)//循環了(n+n-1+n-2+...+1)≈(n^2)/2，因為時間復雜度是不考慮系數的，所以也是O(n^2)
for(j=i;j<=n;j++)
s++;
(3) for(i=1;i<=n;i++)//循環了(1+2+3+...+n)≈(n^2)/2,當然也是O(n^2)
for(j=1;j<=i;j++)
s++;
(4) i=1;k=0;
while(i<=n-1){
k+=10*i; i++; }//循環了n-1≈n次，所以是O(n)(5) for(i=1;i<=n;i++)
for(j=1;j<=i;j++)
for(k=1;k<=j;k++)
x=x+1;
//循環了(1^2+2^2+3^2+...+n^2)=n(n+1)(2n+1)/6(這個公式要記住哦)≈(n^3)/3，不考慮系數，自然是O(n^3)
另外，在時間復雜度中，log(2,n)(以2為底)與lg(n)(以10為底)是等價的，因為對數換底公式：
log(a,b)=log(c,b)/log(c,a)
所以，log(2,n)=log(2,10)*lg(n),忽略掉系數，二者當然是等價的
二、計算方法1.一個演算法執行所耗費的時間，從理論上是不能算出來的，必須上機運行測試才能知道。但我們不可能也沒有必要對每個演算法都上機測試，只需知道哪個演算法花費的時間多，哪個演算法花費的時間少就可以了。並且一個演算法花費的時間與演算法中語句的執行次數成正比例，哪個演算法中語句執行次數多，它花費時間就多。
一個演算法中的語句執行次數稱為語句頻度或時間頻度。記為T(n)。
2.一般情況下，演算法的基本操作重復執行的次數是模塊n的某一個函數f（n），因此，演算法的時間復雜度記做：T（n）=O（f（n））。隨著模塊n的增大，演算法執行的時間的增長率和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））。
3.常見的時間復雜度
按數量級遞增排列，常見的時間復雜度有：
常數階O(1), 對數階O(log2n), 線性階O(n), 線性對數階O(nlog2n), 平方階O(n^2)， 立方階O(n^3),...， k次方階O(n^k), 指數階O(2^n) 。
其中，1.O(n)，O(n^2)， 立方階O(n^3),...， k次方階O(n^k) 為多項式階時間復雜度，分別稱為一階時間復雜度，二階時間復雜度。。。。2.O(2^n)，指數階時間復雜度，該種不實用3.對數階O(log2n), 線性對數階O(nlog2n)，除了常數階以外，該種效率最高
例：演算法：
for（i=1;i<=n;++i）
{
for(j=1;j<=n;++j)
{
c[ i ][ j ]=0; //該步驟屬於基本操作 執行次數：n^2
for(k=1;k<=n;++k)
c[ i ][ j ]+=a[ i ][ k ]*b[ k ][ j ]; //該步驟屬於基本操作 執行次數：n^3
}
}
則有 T（n）= n^2+n^3，根據上面括弧里的同數量級，我們可以確定 n^3為T（n）的同數量級
則有f（n）= n^3，然後根據T（n）/f（n）求極限可得到常數c
則該演算法的 時間復雜度：T（n）=O（n^3)
四、

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

當輸入量n逐漸加大時，時間復雜性的極限情形稱為演算法的「漸近時間復雜性」。

我們常用大O表示法表示時間復雜性，注意它是某一個演算法的時間復雜性。大O表示只是說有上界，由定義如果f(n)=O(n)，那顯然成立f(n)=O(n^2)，它給你一個上界，但並不是上確界，但人們在表示的時候一般都習慣表示前者。

此外，一個問題本身也有它的復雜性，如果某個演算法的復雜性到達了這個問題復雜性的下界，那就稱這樣的演算法是最佳演算法。

「大O記法」：在這種描述中使用的基本參數是
n，即問題實例的規模，把復雜性或運行時間表達為n的函數。這里的「O」表示量級 (order)，比如說「二分檢索是 O(logn)的」,也就是說它需要「通過logn量級的步驟去檢索一個規模為n的數組」記法 O ( f(n) )表示當 n增大時，運行時間至多將以正比於 f(n)的速度增長。

這種漸進估計對演算法的理論分析和大致比較是非常有價值的，但在實踐中細節也可能造成差異。例如，一個低附加代價的O(n2)演算法在n較小的情況下可能比一個高附加代價的 O(nlogn)演算法運行得更快。當然，隨著n足夠大以後，具有較慢上升函數的演算法必然工作得更快。

O(1)

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

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

O(n^2)

2.1.
交換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)

2.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)

2.3.
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
)

2.4.
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)

2.5.
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的值非常小，因為，在 這個問題中增加一個元素就導致運行時間加倍。不幸的是，確實有許多問題 (如著名的「巡迴售貨員問題」 )，到目前為止找到的演算法都是指數的。如果我們真的遇到這種情況，通常應該用尋找近似最佳結果的演算法替代之。