数模论坛

 找回密码
 注-册-帐-号
搜索
热搜: 活动 交友 discuz
楼主: b

算法的复杂性

[复制链接]
b
 楼主| 发表于 2004-5-29 03:17:59 | 显示全部楼层
<>其中S<SUB>k </SUB>(k=1,2,3,4)是单一的赋值语句。对于内循环体,显然只需<I>Ο</I>(l)时间。因而内循环只需</P><><img src="http://algorithm.myrice.com/algorithm/complexity/images/img6.gif"></P><>时间。累加起来便是外循环的时间复杂性:</P><P><img src="http://algorithm.myrice.com/algorithm/complexity/images/img8.gif"></P><P>应该指出,根据记号<I>Ο</I>的定义,用它评估算法的复杂性,得到的只是当规模充分大时的一个上界。这个上界的阶越低则评估就越精确,结果就越有价值。</P><P>关于记号<I>Ω</I>,文献里有两种不同的定义。本文只采用其中的一种,定义如下:如果存在正的常数<I>C</I>和自然数<I>N</I><SUB>0</SUB>,使得当<I>N</I>≥<I>N</I><SUB>0</SUB>时有<I>f</I>(<I>N</I>)≥<I>Cg</I>(<I>N</I>),则称函数<I>f</I>(<I>N</I>)当<I>N</I>充分大时<DFN>下有界</DFN>,且<I>g</I>(<I>N</I>)是它的一个<DFN>下界</DFN>,记为<I>f</I>(<I>N</I>)=<I>Ω</I>(<I>g</I>(<I>N</I>))。这时我们还说<I>f</I>(<I>N</I>)的阶不低于<I>g</I>(<I>N</I>)的阶。</P><P><I>Ω</I>的这个定义的优点是与<I>Ο</I>的定义对称,缺点是当<I>f</I>(<I>N</I>)对自然数的不同无穷子集有不同的表达式,且有不同的阶时,未能很好地刻画出<I>f</I>(<I>N</I>)的下界。比如当:</P><P><img src="http://algorithm.myrice.com/algorithm/complexity/images/img10.gif"></P><P>时,如果按上述定义,只能得到<I>f</I>(<I>N</I>)=<I>Ω</I>(1),这是一个平凡的下界,对算法分析没有什么价值。</P><P>然而,考虑到<I>Ω</I>的上述定义有与<I>Ο</I>的定义的对称性,又考虑到常用的算法都没出现上例中那种情况,所以本文还是选用它。</P><P>我们同样也可以列举<I>Ω</I>的一些运算规则。但这里从略,只提供一个应用的例子。还是考虑<a href="http://algorithm.myrice.com/algorithm/complexity/chapter1.htm#search" target="_blank" >算法Search</A>在最坏情况下的时间复杂性函数<I>T</I><SUB>max</SUB>(<I>m</I>)。由它的<a href="http://algorithm.myrice.com/algorithm/complexity/chapter2.htm#equ2_7" target="_blank" >表达式(2.7)</A>及已知<I>a</I>,<I>s</I>,<I>t</I>均为大于0的常数,可推得,当<I>m</I>≥1时有:</P><P><I>T</I><SUB>max</SUB>(<I>m</I>)≥(<I>m</I>+1)<I>a</I>+(2<I>m</I>+1)<I>t</I>&gt;<I>ma</I>+2<I>mt</I>=(<I>a</I>+2<I>t</I>)<I>m</I> ,</P><P>于是<I> T</I><SUB>max</SUB>(<I>m</I>)=<I>Ω</I>(<I>m</I>)。</P><P>我们同样要指出,用<I>Ω</I>评估算法的复杂性,得到的只是该复杂性的一个下界。这个下界的阶越高,则评估就越精确,结果就越有价值。再则,这里的<I>Ω</I>只对问题的一个算法而言。如果它是对一个问题的所有算法或某类算法而言,即对于一个问题和任意给定的充分大的规模<I>N</I>,下界在该问题的所有算法或某类算法的复杂性中取,那么它将更有意义。这时得到的相应下界,我们称之为问题的下界或某类算法的下界。它常常与<I>Ο</I>配合以证明某问题的一个特定算法是该问题的最优算法或该问题在某算法类中的最优算法。</P><P>明白了记号<I>Ο</I>和<I>Ω</I>之后,记号<I>θ</I>将随之清楚,因为我们定义<I>f</I>(<I>N</I>)=<I>θ</I>(<I>g</I>(<I>N</I>))则<I>f</I>(<I>N</I>)=<I>Ο</I>(<I>g</I>(<I>N</I>)) 且<I>f</I>(<I>N</I>)=<I>Ω</I>(<I>g</I>(<I>N</I>))。这时,我们说<I>f</I>(<I>N</I>)与<I>g</I>(<I>N</I>)<DFN>同阶</DFN>。比如,对于算法Search在最坏情况下的时间复杂性<I>T</I><SUB>max</SUB>(<I>m</I>)。已有<I>T</I><SUB>max</SUB>(<I>m</I>)=<I>Ο</I>(<I>m</I>)和<I>T</I><SUB>max</SUB>(<I>m</I>)=<I>Ω</I>(<I>m</I>),所以有<I>T<SUB>max</SUB></I>(<I>m</I>)<I>=θ</I>(<I>m</I>),这是对<I>T</I><SUB>max</SUB>(<I>m</I>)的阶的精确估计。</P><P>最后,如果对于任意给定的<I>ε</I>≥0,都存在非负整数<I>N</I><SUB>0</SUB>,使得当<I>N</I>≥<I>N</I><SUB>0</SUB>时有<I>f</I>(<I>N</I>)≤<I>εg</I>(<I>N</I>),则称函数<I>f</I>(<I>N</I>)当<I>N</I>充分大时比<I>g</I>(<I>N</I>)<DFN>低阶</DFN>,记为<I>f</I>(<I>N</I>)= <I>o</I>(<I>g</I>(<I>N</I>)),例如:</P><P>4<I>N</I>log<I>N</I> +7=<I>o</I>(3<I>N</I><SUP> 2</SUP>+4<I>N</I>log<I>N</I>+7);而<I>f</I>(<I>N</I>)=<I>ω</I>(<I>g</I>(<I>N</I>))定义为<I>g</I>(<I>N</I>)=<I>o</I>(<I>f</I>(<I>N</I>))。</P><P>即当<I>N</I>充分大时<I>f</I>(<I>N</I>)的阶比<I>g</I>(<I>N</I>)高。我们看到<I>o</I>对于<I>Ο</I>有如<I>ω</I>对于<I>Ω</I>。</P>
b
 楼主| 发表于 2004-5-29 03:18:45 | 显示全部楼层
<H2>复杂性渐近阶的重要性</H2><>计算机的设计和制造技术在突飞猛进,一代又一代的计算机的计算速度和存储容量在直线增长。有的人因此认为不必要再去苦苦地追求高效率的算法,从而不必要再去无谓地进行复杂性的分析。他们以为低效的算法可以由高速的计算机来弥补,以为在可接受的一定时间内用低效的算法完不成的任务,只要移植到高速的计算机上就能完成。这是一种错觉。造成这种错觉的原因是他们没看到:随着经济的发展、社会的进步、科学研究的深入,要求计算机解决的问题越来越复杂、规模越来越大,也呈线性增长之势;而问题复杂程度和规模的线性增长导致的时耗的增长和空间需求的增长,对低效算法来说,都是超线性的,决非计算机速度和容量的线性增长带来的时耗减少和存储空间的扩大所能抵销。事实上,我们只要对效率上有代表性的几个档次的算法作些简单的分析对比就能明白这一点。</P><>我们还是以时间效率为例。设A<SUB>1</SUB>,A<SUB>2</SUB>,…和A<SUB>6</SUB>。是求解同一间题的6个不同的算法,它们的渐近时间复杂性分别为<I>N</I>,<I>N</I>log<I>N</I>,<I>N</I><SUP> 2</SUP>,<I>N </I><SUP>3</SUP>,2<I><SUP>N</SUP></I>,<I>N!</I>。让这六种算法各在<I>C</I><SUB>1</SUB>和<I>C</I><SUB>2</SUB>两台计算机上运行,并设计算机<I>C</I><SUB>2</SUB>的计算速度是计算机<I>C</I><SUB>1</SUB>的10倍。在可接受的一段时间内,设在<I>C</I><SUB>1</SUB>上算法A<SUB>i</SUB>可能求解的问题的规模为<I>N</I><SUB>1i</SUB>,而在<I>C</I><SUB>2</SUB>上可能求解的问题的规模为<I>N</I><SUB>2i</SUB>,那么,我们就应该有<I>T</I><SUB>i</SUB>(<I>N</I><SUB>2i</SUB>)=10<I>T</I><SUB>i</SUB>(<I>N</I><SUB>1i</SUB>),其中<I>T</I><SUB>i</SUB>(<I>N</I>)是算法<I>A</I><SUB>i</SUB>渐近的时间复杂性,i=1,2,…,6。分别解出<I>N</I><SUB>2i</SUB>和<I>N</I><SUB>1i</SUB>的关系,可列成下表:</P>
b
 楼主| 发表于 2004-5-29 03:18:54 | 显示全部楼层
< align=center><B>表4-1算法与渐近时间复杂性的关系</B></P><TABLE cellSpacing=0 width="95%" align=center border=1><TR><TH align=middle width="6%">算法</TH><TH align=middle width="23%">渐进时间复杂性<I>T</I>(<I>N</I>)</TH><TH align=middle width="24%">在<I>C</I><SUB>1</SUB>上可解的规模<I>N</I><SUB>1</SUB></TH><TH align=middle width="23%">在<I>C</I><SUB>2</SUB>上可解的规模<I>N</I><SUB>2</SUB></TH><TH align=middle width="24%"><I>N</I><SUB>1</SUB>和<I>N</I><SUB>2</SUB>的关系</TH></TR><TR><TD align=middle width="6%">A<SUB>1</SUB></TD><TD align=middle width="23%">N</TD><TD align=middle width="24%"><I>N</I><SUB>11</SUB></TD><TD align=middle width="23%"><I>N</I><SUB>21</SUB></TD><TD align=middle width="24%"><I>N</I><SUB>21</SUB>=10<I>N</I><SUB>11</SUB></TD></TR><TR><TD align=middle width="6%">A<SUB>2</SUB></TD><TD align=middle width="23%"><I>N</I>log<I>N</I></TD><TD align=middle width="24%"><I>N</I><SUB>12</SUB></TD><TD align=middle width="23%"><I>N</I><SUB>22</SUB></TD><TD align=middle width="24%"><I>N</I><SUB>22</SUB>≈10<I>N</I><SUB>12</SUB></TD></TR><TR><TD align=middle width="6%">A<SUB>3</SUB></TD><TD align=middle width="23%"><I>N</I><SUP>2</SUP></TD><TD align=middle width="24%"><I>N</I><SUB>13</SUB></TD><TD align=middle width="23%"><I>N</I><SUB>23</SUB></TD><TD align=middle width="24%"><img src="http://algorithm.myrice.com/algorithm/complexity/images/img96.gif"></TD></TR><TR><TD align=middle width="6%">A<SUB>4</SUB></TD><TD align=middle width="23%"><I>N</I><SUP>3</SUP></TD><TD align=middle width="24%"><I>N</I><SUB>14</SUB></TD><TD align=middle width="23%"><I>N</I><SUB>24</SUB></TD><TD align=middle width="24%"><img src="http://algorithm.myrice.com/algorithm/complexity/images/img98.gif"></TD></TR><TR><TD align=middle width="6%">A<SUB>5</SUB></TD><TD align=middle width="23%">2<I><SUP>N</SUP></I></TD><TD align=middle width="24%"><I>N</I><SUB>15</SUB></TD><TD align=middle width="23%"><I>N</I><SUB>25</SUB></TD><TD align=middle width="24%"><I>N</I><SUB>25</SUB> =<I>N</I><SUB>15</SUB>+log10</TD></TR><TR><TD align=middle width="6%">A<SUB>6</SUB></TD><TD align=middle width="23%">N!</TD><TD align=middle width="24%"><I>N</I><SUB>16</SUB></TD><TD align=middle width="23%"><I>N</I><SUB>26</SUB></TD><TD align=middle width="24%"><I>N</I><SUB>26</SUB> =<I>N</I><SUB>16</SUB>+小的常数</TD></TR></TABLE>
b
 楼主| 发表于 2004-5-29 03:19:07 | 显示全部楼层
<>从表4-1的最后一列可以清楚地看到,对于高效的算法A<SUB>1</SUB>,计算机的计算速度增长10倍,可求解的规模同步增长10倍;对于A<SUB>2</SUB>,可求解的问题的规模的增长与计算机的计算速度的增长接近同步;但对于低效的算法A<SUB>3</SUB>,情况就大不相同,计算机的计算速度增长10倍只换取可求解的问题的规模增加log10。当问题的规模充分大时,这个增加的数字是微不足道的。换句话说,对于低效的算法,计算机的计算速度成倍乃至数10倍地增长基本上不带来求解规模的增益。因此,对于低效算法要扩大解题规模,不能寄希望于移植算法到高速的计算机上,而应该把着眼点放在算法的改进上。</P><>从表4-l的最后一列我们还看到,限制求解问题规模的关键因素是算法渐近复杂性的阶,对于表中的前四种算法,其渐近的时间复杂性与规模N的一个确定的幂同阶,相应地,计算机的计算速度的乘法增长带来的是求解问题的规模的乘法增长,只是随着幂次的提高,规模增长的倍数在降低。我们把渐近复杂性与规模N的幂同阶的这类算法称为多项式算法。对于表中的后两种算法,其渐近的时间复杂性与规模<I>N</I>的一个指数函数同阶,相应地计算机的计算速度的乘法增长只带来求解问题规模的加法增长。我们把渐近复杂性与规模<I>N</I>的指数同阶的这类算法称为指数型算法。多项式算法和指数型算法是在效率上有质的区别的两类算法。这两类算法的区别的内在原因是算法渐近复杂性的阶的区别。可见,算法的渐近复杂性的阶对于算法的效率有着决定性的意义。所以在讨论算法的复杂性时基本上都只关心它的渐近阶。</P><>多项式算法是有效的算法。绝大多数的问题都有多项式算法。但也有一些问题还未找到多项式算法,只找到指数型算法。</P><P>我们在讨论算法复杂性的渐近阶的重要性的同时,有两条要记住:</P><OL><LI>“复杂性的渐近阶比较低的算法比复杂性的渐近阶比较高的算法有效”这个结论,只是在问题的求解规模充分大时才成立。比如算法A<SUB>4</SUB>比A<SUB>5</SUB>有效只是在<I>N</I><SUP> 3</SUP>&lt;2<I><SUP>N</SUP></I>,即<I>N</I>≥<I>c </I>时才成立。其中<I>c</I>是方程<I>N</I><SUP> 3</SUP>=2<I><SUP>N</SUP></I>的解。当<I>N </I>&lt;<I>c</I>时,A<SUB>5</SUB>反而比A<SUB>4</SUB>有效。所以对于规模小的问题,不要盲目地选用复杂性阶比较低的算法。其原因一方面是如上所说,复杂性阶比较低的算法在规模小时不一定比复杂性阶比较高的算法更有效;另方面,在规模小时,决定工作效率的可能不是算法的效率而是算法的简单性,哪一种算法简单,实现起来快,就选用那一种算法。 <LI>当要比较的两个算法的渐近复杂性的阶相同时,必须进一步考察渐近复杂性表达式中常数因子才能判别它们谁好谁差。显然常数因子小的优于常数因子大的算法。比如渐近复杂性为<I>N</I>1og<I>N</I>/l00的算法显然比渐近复杂性为l00<I>N</I>log<I>N</I>的算法来得有效。 </LI></OL>
b
 楼主| 发表于 2004-5-29 03:19:29 | 显示全部楼层
<H2>算法复杂性渐近阶的分析</H2><>前两段讲的是算法复杂性渐近阶的概念和对它进行分析的重要性。本段要讲如何具体地分析一个算法的复杂性的渐近阶,给出一套可操作的规则。算法最终要落实到用某种程序设计语言(如Pascal)编写成的程序。因此算法复杂性渐近阶的分析可代之以对表达该算法的程序的复杂性渐近阶的分析。</P><>如前所提出,对于算法的复杂性,我们只考虑最坏、最好和平均三种情况,而通常又着重于最坏情况。为了明确起见,本段限于针对最坏情况。</P><>仍然以时间复杂性为例。这里给出分析时间复杂性渐近阶的八条规则。这八条规则已覆盖了用Pascal语言程序所能表达的各种算法在最坏情况下的时间复杂性渐近阶的分析。</P><P>在逐条地列出并解释这入条规则之前,应该指出,当我们分析程序的某一局部(如一个语句,一个分程序,一个程序段,一个过程或函数)时,可以用具体程序的输入的规模N作为复杂性函数的自变量,也可以用局部的规模参数作为自变量。但是,作为最终结果的整体程序的复杂性函数只能以整体程序的输入规模为自变量。</P><P>对于串行的算法,相应的Pascal程序是一个串行的Pascal语句序列,因此,很明显,该算法的时间复杂性(即所需要的时间)等于相应的Pascal程序的每一个语句的时间复杂性(即所需要的时间)之和。所以,如果执行Pascal语句中的每一种语句所需要的时间都有计量的规则,那么,执行一个程序,即执行一个算法所需要的时间的计量便只是一个代数问题。接着,应用本节第三段所提供的Ο、Ω和θ等运算规则就可以分析出算法时间复杂性的渐近阶。</P><P>因此,我们的时间计量规则只需要针对Pascal有限的几种基本运算和几种基本语句。下面是这些规则的罗列和必要的说明。</P><DL><DT><B>规则(1)</B> </DT></DL><P>赋值、比较、算术运算、逻辑运算、读写单个常量或单个变量等,只需要1个单位时间。</P><DL><DT><B>规则(2)</B> </DT></DL><P>条件语句"if C then S<SUB>1</SUB> else S<SUB>2</SUB>"只需要T<SUB>c</SUB>+max(T<SUB>s1</SUB>,T<SUB>s2</SUB>)的时间,其中T<SUB>c</SUB>是计算条件表达式C需要的时间,而T<SUB>s1</SUB>和T<SUB>s2</SUB>分别是执行语句S<SUB>1</SUB>和S<SUB>2</SUB>需要的时间。</P><DL><DT><B>规则(3)</B> </DT></DL><P>选择语句"Case  A  of  a1:S1; a2:S2; … ;am:Sm;  end",需要max(Ts1, Ts2,…,Tsm)的时间,其中Tsii是执行语句Si所需要的时间,i=l,2,…,m。</P><DL><DT><B>规则(4)</B> </DT></DL><P>访问一个数组的单个分量或一个记录的单个域,只需要1个单位时间。</P><DL><DT><B>规则(5)</B> </DT></DL><P>执行一个for循环语句需要的时间等于执行该循环体所需要的时间乘上循环的次数。</P><DL><DT><B>规则(6)</B> </DT></DL><P>执行一个while循环语句"while C do S"或一个repeat循环语句" repeat S until C",需要的时间等于计算条件表达式C需要的时间与执行循环S体需要的时间之和乘以循环的次数。与规则5不同,这里的循环次数是隐含的。</P><P>例如,b_search函数中的while循环语句。按规则(1)-(4),计算条件表达式" (not found)and(U≥=L)"与执行循环体</P>
b
 楼主| 发表于 2004-5-29 03:19:47 | 显示全部楼层
I:=(U+L)div 2;
if c=A[I] then found:=true
          else  if  c&gt;A[I] then L:=I+1
                           else U:=I-1;
b
 楼主| 发表于 2004-5-29 03:20:00 | 显示全部楼层
<>只需要<I>θ</I>(1)时间,而循环次数为log<I>m</I>,所以,执行此while语句只需要<I>θ</I>(log<I>m</I>)时间。</P><>在许多情况下,运用规则(5)和(6)常常须要借助具体算法的内涵来确定循环的次数,才不致使时间的估计过于保守。这里举一个例子。</P><>考察程序段:</P>
b
 楼主| 发表于 2004-5-29 03:20:25 | 显示全部楼层
Size:=m;
1
i:=1;
1
while i&lt;n do
   
    begin
   
      i:=i+1;
   
      S1;
θ(n)
      if  Size&gt;0  then
1
         begin
   
         在1到Size的范围内任选一个数赋值给t;
θ(1)
             Size:=Size-t;
2
             for j:=l  to  t  do
   
                 S2
θ(n)
         end;
   
    end;

b
 楼主| 发表于 2004-5-29 03:21:11 | 显示全部楼层
<>程序在各行右端顶格处标注着执行相应各行所需要的时间。如果不对算法的内涵作较深入的考察,只看到1≤<I>t</I>≤Size≤<I>m</I>,就草率地估计while的内循环for的循环次数为<I>Ο</I>(<I>m</I>),那么,程序在最坏情况下的时间复杂性将被估计为<I>Ο</I>(<I>n</I><SUP> 2</SUP>+<I>m</I>·<I>n</I><SUP> 2</SUP>)。反之,如果对算法的内涵认真地分析,结果将两样。事实上,在while的循环体内<I>t</I>是动态的,size也是动态的,它们都取决while的循环参数i,即<I>t</I>=<I>t</I>(i)记为<I>t</I><SUB>i</SUB>;size=size(i)记为size<SUB>i </SUB>,i=l,2,…,<I>n</I>-1。对于各个i,1≤i≤<I>n</I>-1,<I>t</I><SUB>i</SUB>与<I>m</I>的关系是隐含的,这给准确地计算for循环的循环体S<SUB>2</SUB>被执行的次数带来困难。上面的估计比较保守的原因在于我们把S<SUB>2</SUB>的执行次数的统计过于局部化。如果不局限于for循环,而是在整个程序段上统计S<SUB>2</SUB>被执行的总次数,那么,这个总次数等于<SUB><img src="http://algorithm.myrice.com/algorithm/complexity/images/img13.gif"></SUB>,又根据算法中t<SUB>i</SUB>的取法及size<SUB>i+1</SUB>=size<SUB>i</SUB>-t<SUB>i</SUB>,i=1,2,…,n-1 有size<SUB>n</SUB>=size<SUB>1</SUB>-<SUB><img src="http://algorithm.myrice.com/algorithm/complexity/images/img4.gif"></SUB>。最后利用size<SUB>1</SUB>=m和size<SUB>n</SUB>=0得到<SUB><img src="http://algorithm.myrice.com/algorithm/complexity/images/img14.gif"></SUB>=m 。于是在整个程序段上,S<SUB>2</SUB>被执行的总次数为m,所需要的时间为<I>θ</I>(<I>mn</I>)。执行其他语句所需要的时间直接运用规则(l)-(6)容易计算。累加起来,整个程序段在最坏情况下时间复杂性渐近阶为<I>θ</I>(<I>n</I><SUP> 2</SUP>+<I>mn</I>)。这个结果显然比前面粗糙的估计准确。</P><DL><DT><B>规则(7)</B> </DT></DL><>对于goto语句。在Pascal中为了便于表达从循环体的中途跳转到循环体的结束或跳转到循环语句的后面语句,引入goto语句。如果我们的程序按照这一初衷使用goto语句,那么,在时间复杂性分析时可以假设它不需要任何额外的时间。因为这样做既不会低估也不会高估程序在最坏情况下的运行时间的阶。如果有的程序滥用了goto语句,即控制转移到前面的语句,那么情况将变得复杂起来。当这种转移造成某种循环时,只要与别的循环不交叉,保持循环的内外嵌套,则可以比照规则(1)-(6)进行分析。当由于使用goto语句而使程序结构混乱时,建议改写程序然后再做分析。</P><DL><DT><B>规则(8)</B> </DT></DL><>对于过程调用和函数调用语句,它们需要的时间包括两部分,一部分用于实现控制转移,另一部分用于执行过程(或函数)本身,这时可以根据过程(或函数)调用的层次,由里向外运用规则(l)-(7)进行分析,一层一层地剥,直到计算出最外层的运行时间便是所求。如果过程(或函数)出现直接或间接的递归调用,则上述由里向外逐层剥的分析行不通。这时我们可以对其中的各个递归过程(或函数),所需要的时间假设为一个相应规模的待定函数。然后一一根据过程(或函数)的内涵建立起这些待定函数之间的递归关系得到递归方程。最后用求递归方程解的渐进阶的方法确定最坏情况下的复杂性的渐进阶。</P><P>递归方程的种类很多,求它们的解的渐近阶的方法也很多,我们将在下一段比较系统地给予介绍。本段只举一个简单递归过程(或函数)的例子来说明如何建立相应的递归方程,同时不加推导地给出它们在最坏情况下的时间复杂性的渐近阶。</P><P>例:再次考察函数b_search,这里将它改写成一个递归函数。为了简明,我们已经运用前面的规则(l)-(6),统计出执行各行语句所需要的时间,并标注在相应行的右端:</P>
b
 楼主| 发表于 2004-5-29 03:25:33 | 显示全部楼层
Function b_search(C,L,U:integer):integer;    单位时间数
var index,element:integer;
begin
if (U&lt;L) then                                   1
b_search:=0;                                    1
      else
begin
   index:=(L+U) div 2;                          3
element:=A[index];                             2
if element=C then                              1
b_search:=index                                1
else if element&gt;C then
b_search:=b_search(C,L,index-1)           3+T(m/2)
else
   b_search:=b_search(C,index+1,U);        3+T(m/2)

    end;
   
end;
您需要登录后才可以回帖 登录 | 注-册-帐-号

本版积分规则

小黑屋|手机版|Archiver|数学建模网 ( 湘ICP备11011602号 )

GMT+8, 2024-11-30 19:45 , Processed in 0.052052 second(s), 12 queries .

Powered by Discuz! X3.4

Copyright © 2001-2021, Tencent Cloud.

快速回复 返回顶部 返回列表