算法複雜度是在《數據結構》這門課程的第一章裏出現的，因爲它稍微涉及到一些數學問題，所以很多同學感覺很難，加上這個概念也不是那麼具體，更讓許多同學學起來無從下手，下面我們就這個問題給各位考生進行分析。
首先了解一下幾個概念。一個是時間複雜度，一個是漸近時間複雜度。前者是某個算法的時間耗費，它是該算法所求解問題規模n的函數，而後者是指當問題規模趨向無窮大時，該算法時間複雜度的數量級。
當我們評價一個算法的時間性能時，主要標準就是算法的漸近時間複雜度，因此，在算法分析時，往往對兩者不予區分，經常是將漸近時間複雜度T(n)=O(f(n))簡稱爲時間複雜度，其中的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){漢諾塔}。
下面我們通過例子加以說明，讓大家碰到問題時知道如何去解決。
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的比值不是常數，故不成立。
2、設n爲正整數，利用大"O"記號，將下列程序段的執行時間表示爲n的函數。
(1) i=1; k=0
while(i<n)
{ k=k+10*i;i++;
}
解答：T(n)=n-1， T(n)=O(n)， 這個函數是按線性階遞增的。
(2) x=n; // n>1
while (x>=(y+1)*(y+1))
y++;
解答：T(n)=n1/2 ，T(n)=O(n1/2)， 最壞的情況是y=0，那麼循環的次數是n1/2次，這是一個按平方根階遞增的函數。
(3) x=91; y=100;
while(y>0)
if(x>100)
{x=x-10;y--;}
else x++;
解答： T(n)=O(1)， 這個程序看起來有點嚇人，總共循環運行了1000次，但是我們看到n沒有? 沒。這段程序的運行是和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)。
例 2.1. 交換i和j的內容
1） sum=0； （一次）2） for(i=1;i<=n;i++) （n次 ）3） for(j=1;j<=n;j++) （n^2次 ）4） 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).
例 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).
例 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 )
例 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的值非常小，因爲，在這個問題中增加一個元素就導致運行時間加倍。不幸的是，確實有許多問題 (如著名 的“巡迴售貨員問題”)，到目前爲止找到的算法都是指數的。如果我們真的遇到這種情況， 通常應該用尋找近似最佳結果的算法替代之。
