算法设计与分析期末复习

第一章 算法设计基础

１  算法及其特性

算法是对特定问题求解步骤的一种描述，是指令的有限序列。

算法的特性

输入 输出  有穷性 确定性  可行性

⑴ 输入：一个算法有零个或多个输入。

⑵ 输出：一个算法有一个或多个输出。

⑶ 有穷性：一个算法必须总是在执行有穷步之后结束，且每一步都在有穷时间内完成。

⑷ 确定性：算法中的每一条指令必须有确切的含义，对于相同的输入只能得到相同的输出。

⑸ 可行性：算法描述的操作可以通过已经实现的基本操作执行有限次来实现。

算法的其他特性

正确性  健壮性 可理解性 抽象分级 高效性

算法的描述方法

自然语言 程序流程图 伪代码 程序设计语言

⑴ 自然语言 优点：容易理解 缺点：冗长、二义性 使用方法：粗线条描述算法思想 注意事项：避免写成自然段

例：欧几里得算法

① 输入m 和n；

② 求m除以n的余数r；

③ 若r等于0，则n为最大公约数，算法结束；否则执行第④步；

④ 将n的值放在m中，将r的值放在n中；

⑤ 重新执行第②步。

⑵ 流程图 优点：流程直观 缺点：缺少严密性、灵活性 使用方法：描述简单算法 注意事项：注意抽象层次

 

⑶ 程序设计语言 优点：能由计算机执行 缺点：抽象性差，对语言要求高 使用方法：算法需要验证 注意事项：将算法写成子函数

#include <iostream.h>
int CommonFactor(int m, int n)
{
    int r=m % n;
    while (r!=0) 
   {
      m=n;
      n=r;
      r=m % n;
   }
   return n;
}
void main( )
{
   cout<<CommonFactor(63, 54)<<endl;
}

⑷ 伪代码——算法语言 伪代码（Pseudocode）：

介于自然语言和程序设计语言之间的方法，它采用某一程序设计语言的基本语法，操作指令可以结合自然语言来设计。 优点：表达能力强，抽象性强，容易理解

1. r = m % n;  

  2. 循环直到 r 等于0      

    2.1 m = n;          

\2.2 n = r;        

  2.3 r = m % n;    

3. 输出 n ;

算法设计的一般过程

1．理解问题

2．选择算法设计技术

3. 设计并描述算法

4. 手工运行算法

5．分析算法的效率

6．实现算法

第二章 算法分析基础

百鸡问题

公元5世纪末，我国古代数学家张丘建在他所撰写的《算经》中，提出了这样一个问题：“鸡翁一，值钱五；鸡母一，值钱三；鸡雏三，值钱一。百钱买百鸡，问鸡翁、母、雏各几何？”意思是公鸡每只5元、母鸡每只3元、小鸡3只1元，用100元钱买100只鸡，求公鸡、母鸡、小鸡的只数。  

令a为公鸡只数，b为母鸡只数，c为小鸡只数。列出约束方程：  

   a+b+c=100     （1）    

 5a+3b+c/3=100  （2）  

   c%3=0  （3）

分析: a、b、c的可能取值范围为0~100，对a、b、c的所有组合进行测试，满足约束方程的组合是问题的解。把问题转化为用 n 元钱买 n 只鸡，则上式变为：

a+b+c=n                       （1'）  

  5a+3b+c/3=n                （2'）

1. void chicken_question(int n,int &k,int g[],int m[],int s[])
2. {
3.     int  a,b,c;
4.     k = 0;	
5.     for (a=0;a<=n;a++){
6.         for (b=0;b<=n;b++){
7.             for (c=0;c<=n;c++) {
8.                 if ((a+b+c==n)&&(5*a+3*b+c/3==n)&&(c%3==0)) {
9.                     g[k] = a;
10.                   m[k] = b;
11.                   s[k] = c;
12.                   k++;    
13.                 }    
14.             }
15.         }
16.     }
17. }

改进一下

1. void chicken_problem(int n,int &k,int g[],int m[],int s[])
2. {int  i,j,a,b,c; k = 0; i = n/5; j = n/3;
3. for (a=0;a<=i;a++){
4.        for (b=0;b<=j;b++) {
5.             c = n–a–b;
6.             if ((5*a+3*b+c/3==n)&&(c%3==0)) {
7.                 g[k] = a;
8.                 m[k] = b;
9.                 s[k] = c;
10.               k++;
11.             }
12.         } 
13.     }
14. }

算法分析

算法分析（Algorithm Analysis）：对算法所需要的两种计算机资源——时间和空间进行估算  时间复杂性（Time Complexity）  

空间复杂性（Space Complexity）

算法分析的目的：  设计算法——设计出复杂性尽可能低的算法  选择算法——在多种算法中选择其中复杂性最低者

时间复杂性分析的关键： 问题规模：输入量的多少；

基本语句：执行次数与整个算法的执行时间成正比的语句

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

问题规模：n 基本语句：x++

一个算法中所有语句的频度之和构成了该算法的运行时间。

  例如：     for(j=1;j<=n;++j)            

   for(k=1;k<=n;++k)              

  ++x；        语句“++x、k<=n、++k”的频度是n的平方    

 语句“ j=1、k=1”的频度是1，      

语句“j<=n;++j”的频度是n。  

   算法运行时间为：3*n的平方+2n+2。

对于较复杂的算法,计算算法的运行时间,经常从算法中选取一种对于所研究的问题来说是基本(或者说是主要) 的原操作,以该基本操作在算法中重复执行的次数作为算法运行时间的衡量准则。这个原操作,多数情况下是最深层次循环体内的语句中的原操作。

for(i=1;i<=n;++i)
                  for(j=1;j<=n;++j)
                    { c[i,j]=0;
                      for(k=0;k<=n;++k)
                        c[i,j]=c[i,j]+a[i,k]*b[k,j];
                     }

该算法的基本操作是乘法操作,时间复杂度为n3 。

渐进符号

1. 大O符号

定义1.1  若存在两个正的常数c和n0，对于任意n≥n0，都有T(n)≤c×f(n)，则称T(n)=O(f(n))

2. 大Ω符号

定义1.2  若存在两个正的常数c和n0，对于任意n≥n0，都有T(n)≥c×g(n)，则称T(n)=Ω(g(n))

3. Θ符号 

定义1.3 若存在三个正的常数c1、c2和n0，对于任意n≥n0都有c1×f(n)≥T(n)≥c2×f(n)，则称T(n)=Θ(f(n))

例： T(n)＝5n2＋8n＋1
当n≥1时，5n2＋8n＋1≤5n2＋8n＋n
                ＝5n2＋9n≤5n2＋9n2≤14n2＝O(n2)
当n≥1时，5n2＋8n＋1≥5n2＝Ω(n2)
∴ 当n≥1时，14n2≥5n2＋8n＋1≥5n2
      则：5n2＋8n＋1＝Θ(n2)

*定理1.1  若T(n)=amnm +am-1nm-1 + … +a1n+a0（am>0），则有T(n)=O(nm)且T(n)=Ω(n m)，因此，有T(n)=Θ(n m)。

算法(渐进)时间复杂度,一般均表示为以下几种数量级的形式(n为问题的规模,c为一常量)：

Ο(1)称为常数级      

      Ο(logn)称为对数级    

        Ο(n)称为线性级      

      Ο(nc)称为多项式级        

          Ο(cn)称为指数级        

    Ο(n!)称为阶乘级

常见阶乘的比较

C<log2n<n<nlog2n<n2<n3<2n<3n<n!

算法分类分析

非递归算法的分析

1．仅依赖于问题规模的时间复杂度     有一类简单的问题，其操作具有普遍性，也就是说对所有的数据均等价地进行处理，这类算法的时间复杂度，很容易分析。

 思考：例1.交换i和j的内容。     Temp=i；i=j；j=temp；  

  以上三条单个语句的频度均为1，该算法段的执行时间是一个与问题规模n无关的常数。算法的时间复杂度为常数阶，记作T(n)=Ο(1)。  

  如果算法的执行时间不随着问题规模n的增加而增长，即使算法中有上千条语句,其执行时间也不过是一个较大的常数。此类算法的时间复杂度是Ο(1)。

思考：例2.循环次数直接依赖规模n。  

    (1)  x=0；y=0；      

(2)  for(k=1；k<=n；k++)    

  (3)  x++；      

(4)  for(i=1；i<=n；i++)

  (5)  for(j=1；j<=n；j++)    

  (6)  y++；  

  该算法段的时间复杂度为T(n)=Ο(n2）。     当有若干个循环语句时，算法的时间复杂度是由嵌套层数最多的循环语句中最内层语句的频度f(n)决定的。

2.算法的时间复杂度还与输入实例的初始状态有关  

  这类算法的时间复杂度的分析比较复杂，一般分最好情况（处理最少的情况),最坏情况(处理最多的情况)和平均情况分别进行讨论。

非递归算法分析

1. 决定用哪个（或哪些）参数作为算法问题规模的度量

2. 找出算法中的基本语句

3. 检查基本语句的执行次数是否只依赖于问题规模

4. 建立基本语句执行次数的求和表达式

5. 用渐进符号表示这个求和表达式 关键：建立一个代表算法运行时间的求和表达式，然后用渐进符号表示这个求和表达式。