《大话数据结构》--学习笔记3(算法的时间复杂度)

2013年12月23日 12:36
转载(0) / 评论(0) / 浏览(661)

2.9  算法的时间复杂度

2.9.1 算法时间复杂度定义

             在进行算法分析时,语句总的执行次数T(n)是关键问题规模n的函数,进而分析T(n)随n的变化情况并确定T(n)的数量级。算法的时间复杂度,记作:T(n)=O(f(n)).它表示随问题规模n的增大,算法执行时间的增长率和f(n)的增长率相同,称作算法渐进时间复杂度,简称为时间复杂度。其中f(n)是时间规模n的某个函数。

          一般情况下,随着n的增大,T(n)增长最慢的算法为最优算法。

显然,由此算法时间复杂度的定义可知,我们三个求和算法的时间复杂的分别为O(n)、O(1)、O(n^2).我们分别取名为:

O(1):常数阶       O(n):线性阶         O(n^2):平方阶

2.9.2 推导大O阶方法

推导大O阶:

1.用常数1取代运行时间中的所有加法常数;

2.在修改后的运行次数函数中,只保留最高阶项;

3.如果最高阶项存在且不是1,则去除与这个项相乘的常数;

得到的结果就是大O阶。

 

常数阶:

首先顺序结构的时间复杂度。下面这个算法,为什么时间复杂度不是O(3),而是O(1)。

[plain] view plaincopy
  1. int  i, sum=0,n=100;    /*执行一次*/  
  2. sum = (1+n)*n/2;       /*执行一次*/  
  3. printf("%d",sum);     /*执行一次*/  

这个算法的运行次数函数是f(n)=3. 根据我们推到大O阶的方法,第一步就是把常数项3改为1。在保留最高阶项时发现,它根本没有最高阶项,所以这个算法的时间复杂度是O(1).

另外,我们试想一下,如果这个算法当中的语句sum=(1+n)*n/2有7句,即: 

[plain] view plaincopy
  1. int  i, sum=0,n=100;    /*执行一次*/  
  2. sum = (1+n)*n/2;       /*执行第1次*/  
  3. <pre class="plain" name="code">sum = (1+n)*n/2; /*执行第2次*/</pre><pre class="plain" name="code">sum = (1+n)*n/2; /*执行第3次*/</pre><pre class="plain" name="code">sum = (1+n)*n/2; /*执行第4次*/</pre><pre class="plain" name="code">sum = (1+n)*n/2; /*执行第5次*/</pre><pre class="plain" name="code">sum = (1+n)*n/2; /*执行第6次*/</pre><pre class="plain" name="code">sum = (1+n)*n/2; /*执行第7次*/</pre><pre class="plain" name="code">sum = (1+n)*n/2; /*执行一次*/printf("%d",sum); /*执行一次*/</pre><pre class="plain" name="code"><span style="font-size:16px;color:#ff0000;"><strong><span style="color:#000000;">事实上无论n为多少,上面的两段代码就是3次和9次执行的差异,</span>这样与n多少无关的,执行时间恒定的算法,我们称之为具有O(1)的时间复杂度,又称为常数阶。</strong></span></pre>  
  4. <pre></pre>  
  5. <p>【注意:不管这个常数是多少,我们都记做O(1),而不是O(3)、O(9)等其他任何数字。】<span style="font-size:16px; color:#ff0000"><strong></strong></span></p>  
  6. <h5><a name="t4"></a><span style="color:#000000">线性阶</span></h5>  
  7. <p><span style="font-size:16px; color:#ff0000">我们要分析算法的复杂度,关键就是要分析循环结构的运行情况。</span></p>  
  8. <p>下面我们来看这段代码,它的循环的时间复杂度为O(n),因为循环体中代码须要执行n次。</p>  
  9. <pre class="plain" name="code">int  i;  
  10. for (i=0;i<n;i++)  
  11. {  
  12.    ....  
  13. }</pre>  
  14. <h5><a name="t5"></a><br>  
  15. 对数阶</h5>  
  16. <p>看下面代码的时间复杂度又是多少?</p>  
  17. <pre class="plain" name="code">int count=1;  
  18. while(count<0)  
  19. {  
  20.     count =count*2;  
  21. }</pre>  
  22. <p><br>  
  23. 由于每次count乘以2之后,就距离n更近一分。也就是说,有多少个2相乘后大于n,则会退出循环。由2^x=n  得到<span style="font-size:18px">x=log<span style="font-size:10px">2</span>n</span><span style="font-size:12px">.所以这个循环的时间复杂度为O(logn)。</span></p>  
  24. <h5><a name="t6"></a>平方阶</h5>  
  25. <p>下面例子是一个循环嵌套,它的内循环刚才我们已经分析过,时间复杂度为O(n)</p>  
  26. <pre class="plain" name="code">int i ,j;  
  27. for(i=0; i<n; i++)  
  28. {  
  29.     <span style="color:#ff0000;"> </span><span style="color:#000000;">for(j=0;j<n;j++)  
  30.      {  
  31.      }  
  32. </span>}</pre>  
  33. <p><br>  
  34. 而对于外层的循环,不过是内部这个时间复杂度为O(n)的语句,再循环n次。所以这段代码的时间复杂度为O(n^2)</p>  
  35. <p>如果外循环的循环次数改为m,时间复杂度就变为O(m*n),所以我们总结得出,循环的时间复杂度等于循环体的复杂度乘以该循环运行的次数。</p>  
  36. <p>那么下面的循环嵌套,它的时间复杂度是多少?</p>  
  37. <pre class="plain" name="code">int  i,j;  
  38. for(i=0;i<n ;i++)  
  39. {  
  40.     for(j=i;j<n;j++)  //<span style="color:#000000;">注意:j=i 而不是0  
  41. </span>    {  
  42.     }  
  43. }</pre>  
  44. <p><br>  
  45. 由于当i=0时,内循环执行了n次,当i=1时,执行了n-1次,......当i=n-1时,执行了1次。所以总的执行次数为:</p>  
  46. <p>n+(n-1)+(n-2)+......+1=n(n+1)/2=(n^2)/2+n/2</p>  
  47. <p>用我们推导大O阶的方法,第一条,没有加法常数不予考虑;</p>  
  48. <p>第二条,只保留最高阶项,因此保留(n^2)/2;</p>  
  49. <p>第三条,去除这个项的相乘常数,即/2,最终这段代码的时间复杂度为O(n^2)</p>  
  50. <p> </p>  
  51. <p>我们继续看例子,对于方法调用的时间复杂度又如何分析:</p>  
  52. <pre class="plain" name="code">int  i ,j;  
  53. for (i=0; i<n;i++)  
  54. {  
  55.     function(i);  
  56. }  
  57. void  function(int  count)  
  58. {  
  59.     printf("count");  
  60. }</pre>  
  61. <p><br>  
  62. 函数体是打印这个参数。其实function函数的时间复杂度是O(1),所以整体的时间复杂度为O(n).</p>  
  63. <p>假如function是下面这样的:</p>  
  64. <pre class="plain" name="code">void function (int  count)  
  65. {  
  66.   
  67.     int  j ;  
  68.   
  69.     for(j=count;  j<n;  j++)  
  70.   
  71.    {  
  72.   
  73.    }  
  74.   
  75. }  
  76.   
  77. </pre>  
  78. <p><br>  
  79. 事实上,这和刚才举例子的是一样的,只不过把嵌套内循环放到了函数中。最终的时间复杂度是O(n^2)</p>  
  80. <p>下面这段相对复杂的语句:</p>  
  81. <pre class="plain" name="code">n++;  
  82.   
  83. function(n);  
  84.   
  85. int  i,j;  
  86.   
  87. for(i=0; i<n; i++)  
  88.   
  89. {  
  90.   
  91.    function(i);  
  92.   
  93. }  
  94.   
  95. for(i=0; i<n; i++)  
  96.   
  97. {  
  98.   
  99.    for(j=i; i<n; j++)  
  100.   
  101.    {  
  102.   
  103.         
  104.   
  105.    }  
  106.   
  107. }  
  108.   
  109. </pre>  
  110. <p><br>  
  111. 它的执行次数 f(n)=1+n+n^2+n(n+1)/2=3/2(n^2)+3/2(n)+1 根据推导O阶的方法,最终这段代码的时间复杂度也是O(n^2)</p>  
  112. <h2><a name="t7"></a>2.10 常见的时间复杂度</h2>  
  113. <p>  
  114. </p><table border="1" cellspacing="1" cellpadding="1" width="419" style="width:419px; height:191px">  
  115. <tbody>  
  116. <tr>  
  117. <td>执行次数函数</td>  
  118. <td>阶</td>  
  119. <td>非正常术语</td>  
  120. </tr>  
  121. <tr>  
  122. <td>12</td>  
  123. <td>O(1)</td>  
  124. <td>常数阶</td>  
  125. </tr>  
  126. <tr>  
  127. <td>2n+3</td>  
  128. <td>O(n)</td>  
  129. <td>线性阶</td>  
  130. </tr>  
  131. <tr>  
  132. <td>3n^2+2n+1</td>  
  133. <td>O(n^2)</td>  
  134. <td>平方阶</td>  
  135. </tr>  
  136. <tr>  
  137. <td>5log2n+20</td>  
  138. <td>O(logn)</td>  
  139. <td>对数阶</td>  
  140. </tr>  
  141. <tr>  
  142. <td>2n+3nlog2n+19</td>  
  143. <td>O(nlogn)</td>  
  144. <td>nlogn阶</td>  
  145. </tr>  
  146. <tr>  
  147. <td>6n^3+2n^2+3n</td>  
  148. <td>O(n^3)</td>  
  149. <td>立方阶</td>  
  150. </tr>  
  151. <tr>  
  152. <td>2^n</td>  
  153. <td>O(2^n)</td>  
  154. <td>指数阶</td>  
  155. </tr>  
  156. </tbody>  
  157. </table>  
  158. <p></p>  
  159. <p> </p>  
  160. <p>常用的时间复杂度所耗的时间从小到大依次是:</p>  
  161. <p>O(1)<O(logn)<O(n)<O(nlogn)<O(n^2)<O(n^3)<O(2^n)<O(n!)<O(n^n)</p>  
  162. <p> </p>  
  163. <p> </p>  
  164. <p> </p>  
  165. <p> </p>  
  166. <p> </p>  
  167. <p> </p>  
  168. <p> </p>  
  169. <p> </p>  
  170. <p> </p>  
  171. <p> </p>  
  172. <p> </p>  
  173. <p> </p>  
  174. <p> </p>  
  175. <p> </p>  
  176. <p> </p>  
  177. <p> </p>  
  178. <p> </p>  
  179. <p> </p>  
  180. <p> </p>  
  181. <p> </p>  
  182. <p> </p>  
  183. <p> </p>  
  184. <p> </p>  
  185. <p> </p>  
  186. <p> </p>  
  187. <p> </p>  
  188. <p> </p>  
  189. <p> </p>  
  190. <p> </p>  
  191. <p><span style="font-size:16px; color:#33ccff; background-color:#000000"></span> </p>  
  192. <p> </p>  
  193. <pre></pre>  
  194. <pre></pre>  

评论(0)

发表评论
登录
xy

我可以
  • 评论
关联标签
C语言 × 121
算法 × 7
关联热门电子辑
类似的技文

浏览(590) / 评论(0) / 2013年12月23日 12:31

浏览(392) / 评论(0) / 2013年12月25日 12:19

浏览(725) / 评论(0) / 2013年12月23日 12:29

浏览(550) / 评论(0) / 2013年12月23日 12:38

浏览(522) / 评论(0) / 2013年12月23日 12:40

浏览(517) / 评论(0) / 2013年12月23日 12:42

浏览(542) / 评论(0) / 2013年12月23日 12:46

浏览(395) / 评论(0) / 2013年12月23日 12:51

浏览(511) / 评论(0) / 2013年12月23日 12:53