算法分析与设计教程习题解答_秦明
算法分析与设计习题集答案
算法分析与设计习题集基础篇1、算法有哪些特点？它有哪些特征？它和程序的主要区别是什么？特点：就是一组有穷的规则，它规定了解决某一特定类型问题的一系列运算〔书上定义〕特征：输入、输出、有穷性、明确性、有效性区别：算法是完成特定任务的有限指令集。
程序是用电脑语言编写的写成特定任务的指令序列。
2、算法的时间复杂度指的是什么？如何表示？算法的时间复杂度是一个函数，它定量描述了该算法的运行时间。
这是一个关于代表算法输入值的字符串的长度的函数。
时间复杂度常用大O符号表述，不包括这个函数的低阶项和首项系数。
〔百度百科〕3、算法的空间复杂度指的是什么？如何表示？一个程序的空间复杂度是指运行完一个程序所需内存的大小。
利用程序的空间复杂度，可以对程序的运行所需要的内存多少有个预先估计。
一个程序执行时除了需要存储空间和存储本身所使用的指令、常数、变量和输入数据外，还需要一些对数据进行操作的工作单元和存储一些为现实计算所需信息的辅助空间。
程序执行时所需存储空间包括以下两部分。
〔1〕固定部分。
这部分空间的大小与输入/输出的数据的个数多少、数值无关。
主要包括指令空间〔即代码空间〕、数据空间〔常量、简单变量〕等所占的空间。
这部分属于静态空间。
〔2〕可变空间，这部分空间的主要包括动态分配的空间，以及递归栈所需的空间等。
这部分的空间大小与算法有关。
一个算法所需的存储空间用f(n)表示。
S(n)=O(f(n))其中n为问题的规模，S(n)表示空间复杂度。
答：最坏情况时间复杂性：最好情况时间复杂性：：I*是DN中使T(N, I*)到达Tmax(N)的合法输入；P(I)是在算法的应用中出现输入I的概率10、限界函数的功能是什么？答：用限界函数剪去得不到最优解的子树11、设某一函数定义如下：编写一个递归函数计算给定x的M〔x〕的值。
本函数是一个递归函数，其递归出口是：M〔x〕= x-10x>100递归体是：M〔M〔x+11〕〕x ≤100实现此题功能的递归函数如下：intm ( intx ){ int y;if ( x>100 )return(x-10 );else {y =m(x+11) ;return (m (y ));}procedure M(x)if x>100 thenreturn(x-10)elsereturn M(M(x+11))endifend M12、已知一个顺序表中的元素按元素值非递减有序排列，编写一个函数删除表中多余的值相同的元素。
算法分析与设计重点课后习题答案
习题13．设计算法求数组中相差最小的两个元素（称为最接近数）的差。
要求分别给出伪代码和C++描述。
//采用分治法//对数组先进行快速排序//在依次比较相邻的差#include <iostream>using namespace std;int partions(int b[],int low,int high){int prvotkey=b[low];b[0]=b[low];while (low<high){while (low<high&&b[high]>=prvotkey)--high;b[low]=b[high];while (low<high&&b[low]<=prvotkey)++low;b[high]=b[low];}b[low]=b[0];return low;}void qsort(int l[],int low,int high){int prvotloc;if(low<high){prvotloc=partions(l,low,high); //将第一次排序的结果作为枢轴qsort(l,low,prvotloc-1); //递归调用排序由low 到prvotloc-1qsort(l,prvotloc+1,high); //递归调用排序由 prvotloc+1到 high}}void quicksort(int l[],int n){qsort(l,1,n); //第一个作为枢轴，从第一个排到第n个}int main(){int a[11]={0,2,32,43,23,45,36,57,14,27,39};int value=0;//将最小差的值赋值给valuefor (int b=1;b<11;b++)cout<<a[b]<<' ';cout<<endl;quicksort(a,11);for(int i=0;i!=9;++i){if( (a[i+1]-a[i])<=(a[i+2]-a[i+1]) )value=a[i+1]-a[i];elsevalue=a[i+2]-a[i+1];}cout<<value<<endl;return 0;}4．设数组a[n]中的元素均不相等，设计算法找出a[n]中一个既不是最大也不是最小的元素，并说明最坏情况下的比较次数。
《计算机算法-设计与分析导论》课后习题答案共39页word资料
4.1：在我们所了解的早期排序算法之中有一种叫做Maxsort 的算法。
它的工作流程如下：首先在未排序序列（初始时为整个序列）中选择其中最大的元素max ，然后将该元素同未排序序列中的最后一个元素交换。
这时，max 元素就包含在由每次的最大元素组成的已排序序列之中了，也就说这时的max 已经不在未排序序列之中了。
重复上述过程直到完成整个序列的排序。
(a) 写出Maxsort 算法。
其中待排序序列为E ，含有n 个元素，脚标为范围为0,,1n -K 。
void Maxsort(Element[] E) { int maxID = 0;for (int i=E.length; i>1; i--) { for (int j=0; j<i; j++) {if (E[j] > E[maxID]) maxID = k; E[i] <--> E[maxID];(b) 说明在最坏情况下和平均情况下上述算法的比较次数。
最坏情况同平均情况是相同的都是11(1)()2n i n n C n i -=-==∑。
4.2：在以下的几个练习中我们研究一种叫做“冒泡排序”的排序算法。
该算法通过连续几遍浏览序列实现。
排序策略是顺序比较相邻元素，如果这两个元素未排序则交换这两个元素的位置。
也就说，首先比较第一个元素和第二个元素，如果第一个元素大于第二个元素，这交换这两个元素的位置；然后比较第二个元素与第三个元素，按照需要交换两个元素的位置；以此类推。
(a)起泡排序的最坏情况为逆序输入，比较次数为11(1)()2n i n n C n i -=-==∑。
(b) 最好情况为已排序，需要(n-1)次比较。
4.3： (a)归纳法：当n=1时显然成立，当n=2时经过一次起泡后，也显然最大元素位于末尾；现假设当n=k-1是，命题也成立，则当n=k 时，对前k-1个元素经过一次起泡后，根据假设显然第k-1个元素是前k-1个元素中最大的，现在根据起泡定义它要同第k 个元素进行比较，当k 元素大于k-1元素时，它为k 个元素中最大的，命题成立；当k 元素小于k-1元素时，它要同k-1交换，这时处于队列末尾的显然时队列中最大的元素。
《算法设计与分析》复习题参考答案
《算法设计与分析》复习题参考答案一、概念题：请解释下列术语。
1．数据元素的集合。
2．队列是一个线性表，限制为只能在固定的一端进行插入，在固定的另一端进行删除。
3．对于算法a，如果存在一多项式p()，使得对a的每个大小为n的输入，a的计算时间为o(p(n))，则称a具有多项式复杂度4．二叉树的层数i与该层上的结点数n的关系为：n(i)=i2。
5．如果可满足性约化为一个问题L，则称该问题为NP-难度的。
6．算法就是一组有穷的规则，它规定了解决某一特定类型问题的一系列运算。
7．多数据单指令流8．若图的任意两个节点间均存在路径可达，则称该图为连通图。
9. 是指一个数学模型以及定义在该模型上的一组操作。
10．算法的复杂度只能用指数函数对其限界。
11．函数或过程直接或间接调用它自己。
12．和高度相同的满二叉树的每个对应的顶点编号相同的树13．由所有可行状态所构成的树。
14．如果L时NP难度的且L∈NP，则称问题L是NP-完全的。
15．算法是一个步骤的序列，满足：有穷性、可行性、确定性、输入、输出；过程不需要满足由穷性。
16．有向图的每条边有起点与终点之分，且用箭头指向边的终点。
无向图的边无起点和终点之分，边无箭头。
17．树(tree)是一个或多个结点的有限集合，，它使得：①有一个特别指定的称作根(root)的结点；②剩下的结点被分成m≥0个不相交的集合tl，…，tm，这些集合的每一个都是一棵树，并称t1，…，tm为这根的子树(subtree)。
18．P是所有可在多项式时间内用确定算法求解的判定问题的集合。
19．运算结果是唯一确定的算法20. nP是所有可在多项式时间内用不确定算法求解的判定问题的集合二、填空题1.n2.O ( n )3.最优化问题4.宽度优先搜索5.结点的最大级数6.互异7.内结点和外结点8.方形9.内部路径长度、外部路径长度10.一次11.归并分类算法12.贪心选择性质13.最优子结构14.二元归并15.最小成本生成树16.最优性17.最优决策18.可容许最大成本c19.最小成本三、程序填空题。
算法分析与设计习题答案
算法分析与设计习题答案《算法分析与设计》期末复习题及答案⼀、简要回答下列问题：1.算法重要特性是什么？2.算法分析的⽬的是什么？3.算法的时间复杂性与问题的什么因素相关？4.算法的渐进时间复杂性的含义？5.最坏情况下的时间复杂性和平均时间复杂性有什么不同？6.简述⼆分检索（折半查找）算法的基本过程。
7.背包问题的⽬标函数和贪⼼算法最优化量度相同吗？8.采⽤回溯法求解的问题，其解如何表⽰？有什么规定？9.回溯法的搜索特点是什么？10.n皇后问题回溯算法的判别函数place的基本流程是什么？11.为什么⽤分治法设计的算法⼀般有递归调⽤？12.为什么要分析最坏情况下的算法时间复杂性？13.简述渐进时间复杂性上界的定义。
14.⼆分检索算法最多的⽐较次数？15.快速排序算法最坏情况下需要多少次⽐较运算？16.贪⼼算法的基本思想？17.回溯法的解（x1,x2,……x n）的隐约束⼀般指什么？18.阐述归并排序的分治思路。
19.快速排序的基本思想是什么。
20.什么是直接递归和间接递归？消除递归⼀般要⽤到什么数据结构？21.什么是哈密顿环问题？22.⽤回溯法求解哈密顿环，如何定义判定函数？23.请写出prim算法的基本思想。
参考答案：1. 确定性、可实现性、输⼊、输出、有穷性2. 分析算法占⽤计算机资源的情况，对算法做出⽐较和评价，设计出额更好的算法。
3. 算法的时间复杂性与问题的规模相关，是问题⼤⼩n的函数。
4．当问题的规模n趋向⽆穷⼤时，影响算法效率的重要因素是T(n)的数量级，⽽其他因素仅是使时间复杂度相差常数倍，因此可以⽤T(n)的数量级(阶)评价算法。
时间复杂度T(n)的数量级(阶)称为渐进时间复杂性。
5. 最坏情况下的时间复杂性和平均时间复杂性考察的是n固定时，不同输⼊实例下的算法所耗时间。
最坏情况下的时间复杂性取的输⼊实例中最⼤的时间复杂度：W(n) = max{ T(n，I) } , I∈Dn平均时间复杂性是所有输⼊实例的处理时间与各⾃概率的乘积和：A(n) =∑P(I)T(n，I) I∈Dn6. 设输⼊是⼀个按⾮降次序排列的元素表A[i：j] 和x，选取A[(i+j)/2]与x⽐较，如果A[(i+j)/2]=x，则返回(i+j)/2，如果A[(i+j)/2]回溯法的搜索特点是什么7. 不相同。
算法设计与分析第二版课后习题及解答（可编辑）
算法设计与分析第二版课后习题及解答算法设计与分析基础课后练习答案习题1.14.设计一个计算的算法,n是任意正整数。
除了赋值和比较运算,该算法只能用到基本的四则运算操作。
算法求 //输入:一个正整数n2//输出:。
step1:a1; step2:若a*an 转step 3,否则输出a; step3:aa+1转step 2;5. a.用欧几里德算法求gcd(31415,14142)。
b. 用欧几里德算法求gcd(31415,14142),比检查min{m,n}和gcd(m,n)间连续整数的算法快多少倍?请估算一下。
a. gcd31415, 14142 gcd14142, 3131 gcd3131, 1618 gcd1618, 1513 gcd1513, 105 gcd1513, 105 gcd105, 43 gcd43, 19 gcd19, 5 gcd5, 4 gcd4, 1 gcd1, 0 1.b.有a可知计算gcd(31415,14142)欧几里德算法做了11次除法。
连续整数检测算法在14142每次迭代过程中或者做了一次除法,或者两次除法,因此这个算法做除法的次数鉴于1?14142 和 2?14142之间,所以欧几里德算法比此算法快1?14142/11 ≈1300 与2?14142/11 ≈ 2600 倍之间。
6.证明等式gcdm,ngcdn,m mod n对每一对正整数m,n都成立.Hint:根据除法的定义不难证明:如果d整除u和v, 那么d一定能整除u±v;如果d整除u,那么d也能够整除u的任何整数倍ku.对于任意一对正整数m,n,若d能整除m和n,那么d一定能整除n和rm mod nm-qn;显然,若d能整除n和r,也一定能整除mr+qn和n。
数对m,n和n,r具有相同的公约数的有限非空集,其中也包括了最大公约数。
故gcdm,ngcdn,r7.对于第一个数小于第二个数的一对数字,欧几里得算法将会如何处理?该算法在处理这种输入的过程中,上述情况最多会发生几次?Hint:对于任何形如0mn的一对数字,Euclid算法在第一次叠代时交换m和n, 即gcdm,ngcdn,m并且这种交换处理只发生一次.8.a.对于所有1≤m,n≤10的输入, Euclid算法最少要做几次除法?1次b. 对于所有1≤m,n≤10的输入, Euclid算法最多要做几次除法?5次gcd5,8习题1.21.农夫过河P?农夫W?狼 G?山羊 C?白菜2.过桥问题1,2,5,10---分别代表4个人, f?手电筒4. 对于任意实系数a,b,c, 某个算法能求方程ax^2+bx+c0的实根,写出上述算法的伪代码可以假设sqrtx是求平方根的函数算法Quadratica,b,c//求方程ax^2+bx+c0的实根的算法//输入:实系数a,b,c//输出:实根或者无解信息If a≠0D←b*b-4*a*cIf D0temp←2*ax1←-b+sqrtD/tempx2←-b-sqrtD/tempreturn x1,x2else if D0 return ?b/2*ael se return “no real roots”else //a0if b≠0 return ?c/belse //ab0if c0 return “no real numbers”else return “no real roots”5. 描述将十进制整数表达为二进制整数的标准算法a.用文字描述b.用伪代码描述解答:a.将十进制整数转换为二进制整数的算法输入:一个正整数n输出:正整数n相应的二进制数第一步:用n除以2,余数赋给Kii0,1,2,商赋给n第二步:如果n0,则到第三步,否则重复第一步第三步:将Ki按照i从高到低的顺序输出b.伪代码算法 DectoBinn//将十进制整数n转换为二进制整数的算法//输入:正整数n//输出:该正整数相应的二进制数,该数存放于数组Bin[1n]中i1while n!0 doBin[i]n%2;nintn/2;i++;while i!0 doprint Bin[i];i--;9.考虑下面这个算法,它求的是数组中大小相差最小的两个元素的差.算法略对这个算法做尽可能多的改进.算法 MinDistanceA[0..n-1]//输入:数组A[0..n-1]//输出:the smallest distance d between two of its elements 习题1.3考虑这样一个排序算法,该算法对于待排序的数组中的每一个元素,计算比它小的元素个数,然后利用这个信息,将各个元素放到有序数组的相应位置上去.a.应用该算法对列表”60,35,81,98,14,47”排序b.该算法稳定吗?c.该算法在位吗?解:a. 该算法对列表”60,35,81,98,14,47”排序的过程如下所示:b.该算法不稳定.比如对列表”2,2*”排序c.该算法不在位.额外空间for S and Count[]4.古老的七桥问题第2章习题2.17.对下列断言进行证明:如果是错误的,请举例a. 如果tn∈Ogn,则gn∈Ωtnb.α0时,Θαgn Θgn解:a这个断言是正确的。
最新算法分析与设计习题集答案
2、 算法的时间复杂度指的是什么？如何表示？
算法的时间复杂度是一个函数， 它定量描述了该算法的运行时间。 这是一个关于代表算法输
入值的字符串的长度的函数。时间复杂度常用大
O 符号表述，不包是什么？如何表示？ 一个程序的空间复杂度是指运行完一个程序所需内存的大小。
或是在满足约束条件的解中找出在
某种意义下的最优解；
（2）搜索方式的不同： 回溯法以深度优先的方式搜索解空间树， 而分支限界法则以
广度优先或以最小耗费优先的方式搜索解空间树。
9、 分枝限界法的基本思想是什么？ 答：分支限界法常以广度优先或以最小耗费（最大效益）优先的方式搜索问题的解空间树。
10、 限界函数的功能是什么？ 精品文档
if ( x>100 )return(x-10 ); else {
y =m(x+11) ; return (m (y )); } } procedure M ( x ) if x >100 then
return ( x - 10 ) else
return M ( M( x + 11 )) endif end M
4、 什么是最坏时间复杂性？什么是最好时间复杂性？ 答：最坏情况时间复杂性：
最好情况时间复杂性：：
I* 是 DN中使 T(N, I*) 达到 Tmax(N)的合法输入； P(I) 是在算法的应用中出现输入 I 的概率 精品文档
精品文档
5、 什么是递归算法？什么是递归函数？ 递归算法 （包括直接递归和间接递归子程序） 都是通过自己调用自己， 将求解问题转化成性 质相同的子问题， 最终达到求解的的。 递归算法充分地利用了计算机系统内部机能， 自动实 现调用过程中对相关且必要的信息的保存与恢复，从而省略了求解过程中的许多细节的描 述。【课本】 直接递归 子程序在运行完成前调用它们自己。 间接递归 子程序在运行过程中调用其它子程序，其他子程序反过来调用这个调用子程序。 递归函数， 把直接或间接地调用自身的函数称为递归函数。 函数的构建通常需要一个函数或 者一个过程来完成。
算法分析与设计(答案)
算法分析与设计（答案）一：二分查找的递归实现算法import java.util.Arrays;import java.util.Scanner;public class BinSearch {public static int binsearch(int[]a,int start,int stop,int b){if(start>stop)return -1;int i=(start+stop)/2;if(a[i]==b)return i;if(a[i]>b)return binsearch(a,start,i-1,b);return binsearch(a,i+1,stop,b);}/***@param args*/public static void main(String[] args) {// TODO Auto-generated method stubScanner sc=new Scanner(System.in);int n=sc.nextInt();int a[]=new int [n];System.out.println("输入数组元素");for(int i=0;i<n;i++){a[i]=sc.nextInt();}Arrays.sort(a);System.out.println("排序后的数组为");for(int i=0;i<a.length;i++){System.out.print(a[i]+" ");}System.out.println();System.out.println("输入要查找的数");int b=sc.nextInt();int x=binsearch(a,0,n-1,b);if(x==-1){System.out.println(b+"不在数组中，请输入另一个数");b=sc.nextInt();x=binsearch(a,0,n-1,b);}System.out.println(b+"在数组中的第"+(x+1)+"个位置");}}二：Ackerman函数的递归实现算法import java.util.Scanner;public class Test2 {private static int akm(int n, int m) {// 递归设计int r, g;if (n == 1 && m == 0)r = 2;else if (n == 0 && m >= 0)r = 1;else if (m == 1)r = n * 2;else if (m == 2)r = (int) Math.pow(2, n);else if (m == 0 && n >= 2)r = n + 2;else {g = akm(n-1, m);r = akm(g, m-1);// 两次连着递归}return r;}public static void main(String[] args) {try {System.out.println("请输入1个大于等于0的整数：");Scanner sc = new Scanner(System.in);int n = sc.nextInt();System.out.println("请再输入1个大于等于0的整数：");int m = sc.nextInt();System.out.println(akm(n, m));} catch (Exception e) {}}}三：全排列的递归实现算法import java.util.Scanner;public class AllSort{//全排列public static void main(String[] args) {Scanner sc=new Scanner(System.in);System.out.println("输入需要全排列的元素个数");int n=(char) sc.nextInt();int buf[]=new int [n];System.out.println("请依次输入每一个元素");for(int i=0;i<n;i++){buf[i]=sc.nextInt();}perm(buf,0,buf.length-1);}public static void perm(int[] buf,int start,int end){ if(start==end){//当只要求对数组中一个元素进行全排列时，只要就按该数组输出即可（特殊情况）for(int i=0;i<=end;i++){System.out.print(buf[i]);}System.out.println();}else{//多个字母全排列（普遍情况）for(int i=start;i<=end;i++){//（让指针start分别指向每一个数）int temp=buf[start];//交换数组第一个元素与后续的元素buf[start]=buf[i];buf[i]=temp;perm(buf,start+1,end);//后续元素递归全排列temp=buf[start];//将交换后的数组还原buf[start]=buf[i];buf[i]=temp;}}}}四：快速排序的递归实现算法import java.util.Scanner;public class QuickSort {public static int []a;public static void quicksort(int p,int r){if(p<r){int q=partition(p,r);quicksort(p,q-1);quicksort(q+1,r);}}public static int partition(int p,int r){int i=p,j=r+1;int x=a[p];while(true){while(a[++i]<x&&i<r);while(a[--j]>x);if(i>=j)break;int temp=a[i];a[i]=a[j];a[j]=temp;}a[p]=a[j];a[j]=x;return j;}/***@param args*/public static void main(String[] args) {// TODO Auto-generated method stubScanner sc=new Scanner(System.in);System.out.println("输入要排序的数组长度");int n=sc.nextInt();a=new int[n];System.out.println("输入"+n+"个元素");for(int i=0;i<n;i++)a[i]=sc.nextInt();quicksort(0,n-1);System.out.println("排序后的数组为");for(int j=0;j<a.length;j++)System.out.print(a[j]+" ");}}五：整数划分的递归实现算法import java.io.IOException;import java.util.*;public class ZhengshuHuafen {public static int a=0 ;public static int Devide(int input, int base, int []pData, int index){if(input<1||base<1)return 0;if(input==1||base==1){if(input==1){pData[index] = input;print(pData, index+1);}else{for(int k=0; k<input; k++){pData[index++] = base;}print(pData,index);}return 1;}if(input==base){pData[index] = base;print(pData,index+1);int temp = Devide(input,base-1,pData,index);return 1 + temp;}if(input<base){int temp = Devide(input,input,pData,index);return temp;}else{pData[index] = base;int temp1 = Devide(input-base,base,pData,index+1); int temp2 = Devide(input,base-1,pData,index);return temp1 + temp2;}}public static void print(int []pData ,int index){String s = new String();for(int i = 0 ; i < index - 1 ; i++){System.out.print(pData[i]+"+");s += String.valueOf(pData[i]);s += "+"; }System.out.println(pData[index-1]);s += String.valueOf(pData[index-1]) +"\r\n";}public static void main(String[] args) {int n ;Scanner in = new Scanner(System.in) ;System.out.print("请输入一个整数") ;n = in.nextInt() ;System.out.println("你刚才输入的数为"+n) ;int []pdata = new int[n] ;a=Devide(n, n, pdata, 0) ;System.out.println(""+a) ;}}六：合并排序的递归实现算法import java.util.Scanner;public class mergeSort {public static int []b;public static void mergeSort1(int []a,int left,int right) {if(left<right){int i=(left+right)/2;mergeSort1(a,left,i);mergeSort1(a,i+1,right);merge(a,b,left,i,right);copy(a,b,left,right);}}public static void merge(int []c,int []d,int l,int m,int r) {int i=l;int j=m+1;int k=l;while((i<=m)&&(j<=r))if(c[i]<=c[j])d[k++]=c[i++];else d[k++]=c[j++];if(i>m)for(int q=j;q<=r;q++)d[k++]=c[q];elsefor(int q=i;q<=m;q++)d[k++]=c[q];}public static void copy (int[]c,int[]b,int left,int right) {for(int i=left;i<=right;i++){c[i]=b[i];}}public static void main(String[]args){Scanner sc=new Scanner(System.in);int n=sc.nextInt();b=new int[n];int []a;a=new int [n];for(int i=0;i<n;i++){a[i]=sc.nextInt();}mergeSort.mergeSort1(a,0,n-1);for(int j=0;j<=n-1;j++)System.out.print(a[j]+" ");}}。
《算法分析与设计》练习题一答案.docx
《算法分析与设计》练习题一答案1.程序书写格式应该遵循哪四个原则？参考答案：（1）正确使用缩进：一定要有缩进，否则代码的层次不明显。
（2）在一行内只写一条语句。
（3）, '}'位置不可随意放置。
（4）变量和运算符之间最好加1个空格2.什么是算法？参考答案：用计算机解决问题的过程可以分成三个阶段：分析问题、设计算法和实现算法。
算法可以理解为冇基本运算及规定的运算顺序所构成的完整的解题步骤，它是求解问题类的、机械的、统一的方法，它由有限多个步骤组成，对于问题类屮每个给定的具体问题，机械地执行这些步骤就可以得到问题的解答。
或者看成按照要求设计好的有限的确切的计算序列，并且这样的步骤和序列可以解决一类问题。
3.什么是线性结构？什么是非线性结构？参考答案：线性结构：数据逻辑结构屮的一类。
它的特征是若结构为非空集，则该结构有且只有一个开始结点和一个终端结点，并且所冇结点都冇R只冇一个直接前趋和一个直接后继。
线性表就是一个典型的线性结构。
栈、队列、串等都是线性结构。
非线性结构：数据逻辑结构中的另一大类，它的逻辑特征是一个结点可能有多个直接而趋和直接后继。
数组、广义表、树和图等数据结构都是非线性结构。
4.已知二叉树后序遍丿力序列是DABEC,屮序遍丿力序列是DEBAC,则前序遍历序列是什么？参考答案：前序遍历序列是CEDBA5.什么是数制？参考答案：数制是人们利用符号进行计数的一种科学方法。
数制也称计数制，是用一组固定的符号和统一的规则來表示数值的方法。
6.如果将十进制数106转换为八进制数，结果是多少？参考答案：1527.请问查找算法的效率用什么进行度量？参考答案：平均查找长度ASL：在查找其关键字等于给定值的过程小，需要和给定值进行比较的关键字个数的期望值称为查找成功吋的平均查找长度。
AS厶=£皿/=1其屮，n是结点的个数；是杳找第i个结点的概率,是找到第i个结点所需要的比较次数。
《算法分析与设计》作业答案
《算法分析与设计》作业1、考虑,10≤≤i x 而不是x i ∈{0，1}的连续背包问题。
一种可行的贪婪策略是：按价值密度非递减的顺序检查物品，若剩余容量能容下正在考察的物品，将其装入；否则，往背包内装如此物品的一部分。
(a) 对于n=3，w=[100,10,10]，p=[20,15,15]，以及c=105，上述装入法获得结果是什么？(b)证明这种贪婪算法总能获得最优解。
(c) 用伪代码描述此算法。
答：（a ）利用贪婪算法，按价值密度考察的背包为w2，w3，w1；背包w2和w3重20，还可以容纳85，由于10≤≤i x ，背包w1还可以装入x1=0.85，则背包内物品总价值为15+15+20*0.85＝47.（b ）假设已按价值密度排好序，考察w1,w2,……,wi ，……，对应的价值为p1,p2,……,pi,……如果装到pi-1再装pi 时，恰好要取xi 个wi 。
（,10≤≤i x ） 因为比它价值密度大的都已装载完，所以此时获得的为最优解。
（c ）算法描述如下： template <class T>int ContainerLoading( int x[], T w[], T c, int n ) {int *t = new int[n+1]; IndirectSort(w, t, n); for( int i=1; i<=n; i++) x[i] = 0;for(i=1; i<=n && w[t[i]]<=c; i++){ x[t[i]] = 1; c += w[t[i]]; } delete []t; }2、证明当且仅当二分图没有覆盖时，下述算法找不到覆盖。
m＝0; //当前覆盖的大小对于A中的所有i，New[i]=Degree[i]对于B中的所有i，Cov[i]=falsewhile(对于A中的某些i，New[i]>0) {设v是具有最大的New[i]的顶点；C[m++]=v;for(所有邻接于v的顶点j) {If(!Cov[j]) {Cov[j] = true;对于所有邻接于j的顶点，使其New[k]减1}}}if (有些顶点未被覆盖) 失败else 找到一个覆盖2）给出一个具有覆盖的二分图，使得上述算法找不到最小覆盖。
算法分析与设计作业(一)及参考答案
《算法分析与设计》作业（一）本课程作业由两部分组成。
第一部分为“客观题部分”，由15个选择题组成，每题1分，共15分。
第二部分为“主观题部分”，由简答题和论述题组成，共15分。
作业总分30分，将作为平时成绩记入课程总成绩。
客观题部分：一、选择题（每题1分，共15题）1、递归算法：（C ）A、直接调用自身B、间接调用自身C、直接或间接调用自身D、不调用自身2、分治法的基本思想是将一个规模为n的问题分解为k个规模较小的字问题，这些子问题：（D ）A、相互独立B、与原问题相同C、相互依赖D、相互独立且与原问题相同3、备忘录方法的递归方式是：（C ）A、自顶向下B、自底向上C、和动态规划算法相同D、非递归的4、回溯法的求解目标是找出解空间中满足约束条件的：（A ）A、所有解B、一些解C、极大解D、极小解5、贪心算法和动态规划算法共有特点是：（ A ）A、最优子结构B、重叠子问题C、贪心选择D、形函数6、哈夫曼编码是：（B）A、定长编码B、变长编码C、随机编码D、定长或变长编码7、多机调度的贪心策略是：（A）A、最长处理时间作业优先B、最短处理时间作业优先C、随机调度D、最优调度8、程序可以不满足如下性质：（D ）A、零个或多个外部输入B、至少一个输出C、指令的确定性D、指令的有限性9、用分治法设计出的程序一般是：（A ）A、递归算法B、动态规划算法C、贪心算法D、回溯法10、采用动态规划算法分解得到的子问题：（ C ）A、相互独立B、与原问题相同C、相互依赖D、相互独立且与原问题相同11、回溯法搜索解空间的方法是：（A ）A、深度优先B、广度优先C、最小耗费优先D、随机搜索12、拉斯维加斯算法的一个显著特征是它所做的随机选性决策有可能导致算法：（ C ）A、所需时间变化B、一定找到解C、找不到所需的解D、性能变差13、贪心算法能得到：（C ）A、全局最优解B、0-1背包问题的解C、背包问题的解D、无解14、能求解单源最短路径问题的算法是：（A ）A、分支限界法B、动态规划C、线形规划D、蒙特卡罗算法15、快速排序算法和线性时间选择算法的随机化版本是：（ A ）A、舍伍德算法B、蒙特卡罗算法C、拉斯维加斯算法D、数值随机化算法主观题部分：二、写出下列程序的答案（每题2.5分，共2题）1、请写出批处理作业调度的回溯算法。
算法设计技巧与分析答案
算法设计技巧与分析参考答案第1章算法分析基本概念 1.1 (a)6 (b)5 (c)6 (d)6 1.4 算法执行了7+6+5+4+3+2+1=28次比较 45 33 24 45 12 12 24 12 12 33 24 45 45 12 24 12 12 12 24 45 45 33 24 12 12 12 12 45 45 33 24 24 12 24 12 12 45 33 45 24 12 12 12 24 24 33 45 45 12 12 12 24 24 33 45 45 12 12 12 24 24 33 45 45 1.5 (a)算法MODSELECTIONSORT执行的元素赋值的最少次数是0,元素已按非降序排列的时候达到最小值。
(b) 算法MODSELECTIONSORT执行的元素赋值的最多次数是,元素已按非升序排列的时候达到最小值。
2 1.7 4 3 12 5 6 7 2 9 1次 3 4 1次 3 4 12 2次 3 4 5 123 4 5 6 12 2次 7 12 3 4 5 6 2次 2 3 4 5 6 7 12 6次 7 9 23 4 5 6 12 2次由上图可以看到执行的比较次数为1+1+2+2+2+6+2=16次。
1.11 比较9次 2 4 5 7 8 11 12 13 15 17 19 比较为6次 2 4 5 8 11 13 17 19 7 12 15 比较为3次，2 5 17 19 4 8 11 13 7 12 15 2次，1次 2 17 5 19 11 134 8 12 15 7比较均为1次，共5次 2 17 19 5 13 11 4 8 15 12 7 由上图可以得出比较次数为5+6+6+9=26次。
1.13 FTF,TTT,FTF,TFF,FTF 1.16 (a)执行该算法，元素比较的最少次数是n-1。
元素已按非降序排列时候达到最小值。
(b) 执行该算法，元素比较的最多次数是。
算法设计与分析试题(三合一)答案.(优选)
算法设计与分析试题（三合一）答案算法分析与设计模拟试题一答案一、填空题答案（每小题4分，共计40分）1. 最坏、最好、平均、最坏2.)(2nO、)(log nO3. 常数因子4. 直接或间接地调用自身、用函数自身给出定义5. 最好、局部最优选择6. 贪心选择性质、最优子结构性质7. 贪心算法、动态规划算法8. 较小、互相独立、相同、合并9. 最优子结构（性质）、子问题重叠（性质）10.动态规划算法、贪心算法。
二、简答题答案（每小题10分，共计40分）1. 如果只需要求解问题的最优值，动态规划算法步骤如下：（1）找出最优解的性质，并刻画其结构特征；（2）递归地定义最优值；（3）以自底向上的方式计算出最优值；如果需要构造最优解，则还需要加上如下步骤：（4）根据计算最优值时得到的信息，构造最优解。
2. 所谓贪心选择性质是指，所求问题的全局最优解可以通过一系列局部最优选择，即贪心选择来达到。
3. 如果G的子图G’是一棵包含G的所有顶点的树，则称G’为G的生成树。
生成树上各边权的总和称为该生成树的耗费。
在G的所有生成树中，耗费最小的生成树称为G的最小生成树。
4. 动态规划算法需要知道所有子问题的解，而贪心算法不需要知道所有子问题的解，它只是在每一步迭代中选择看起来最好的解，并不从整体进行最优考虑，因此效率较高。
三、算法分析和设计题答案（每小题10分，共计20分）1. 汉诺塔问题的递归算法如下:public static void Hanoi(int n, int a, int b, int c){if( n>0 ){Hanoi( n-1, a,c,b );Move( a, b );Hanoi( n-1, c,b,a )；}}2. 算法如下：输入：正整数n和存储n个元素的数组a[1..n],被搜索的元素x输出：若x 在数组中则返回其下标否则返回0i=binarysearch(1,n,a,x); return I;end BINARYSEARCH1 过程 binarysearch(low,high,a,x)//在数组a 的下标为low 到high 范围内寻找x, //若找到x 则返回其下标否则返回0 if low>high then return 0; else mid=[]2/)(high low +;if a[mid]=x thenreturn mid;else if a[mid]<x thenreturn binarysearch(low,mid-1,a,x); else return binarysearch(mid+1,high,a,x); end if end if算法分析与设计模拟试题二答案一、填空题答案（每小题4分，共计40分） 1. 程序设计语言、有限性 2. 最坏3. 递归算法、递归函数4. 贪心算法、动态规划算法5. )(2n O 、O(C n )6.n log 、n 20、25n 、3n7. 分治策略、已排好序、)(log n O 、)(n O 8. 最优子结构（性质）、子问题重叠（性质） 9. 自顶向下、自底向上 10. 贪心算法、动态规划算法。
算法设计与分析-课后习题集答案
第一章3. 最大公约数为1。
快1414倍。
程序1-2的while 循环体做了10次，程序1-3的while 循环体做了14141次（14142-2循环）8.（1）画线语句的执行次数为log n ⎡⎤⎢⎥。
(log )n O 。
（2）画线语句的执行次数为111(1)(21)16jnii j k n n n ===++=∑∑∑。
3()n O 。
（3）画线语句的执行次数为。
O 。
（4）当n 为奇数时画线语句的执行次数为(1)(1)4n n +-， 当n 为偶数时画线语句的执行次数为 (2)4n n +。
2()n O 。
10.（1） 当 1n ≥ 时，225825n n n -+≤，所以，可选 5c =，01n =。
对于0n n ≥，22()5825f n n n n =-+≤，所以，22582()-+=O n n n 。
（2） 当 8n ≥ 时，2222582524n n n n n -+≥-+≥，所以，可选 4c =，08n =。
对于0n n ≥，22()5824f n n n n =-+≥，所以，22582()-+=Ωn n n 。
（3） 由（1）、（2）可知，取14c =，25c =，08n =，当0n n ≥时，有22212582c n n n c n ≤-+≤，所以22582()-+=Θn n n 。
11. (1) 当3n ≥时，3log log n n n <<，所以()20log 21f n n n n =+<，3()log 2g n n n n =+>。
可选212c =，03n =。
对于0n n ≥，()()f n cg n ≤，即()(())f n g n =O 。
（2） 当 4n ≥ 时，2log log n n n <<，所以 22()/log f n n n n =<，22()log g n n n n =≥。
可选 1c =，04n =。
算法分析与设计部分含计算的复习题及答案
算法分析与设计部分含计算的复习题及答案⼆、简答题：1.备忘录⽅法和动态规划算法相⽐有何异同？简述之。
2.简述回溯法解题的主要步骤。
3.简述动态规划算法求解的基本要素。
4.简述回溯法的基本思想。
5.简要分析在递归算法中消除递归调⽤，将递归算法转化为⾮递归算法的⽅法。
6.简要分析分⽀限界法与回溯法的异同。
7.简述算法复杂性的概念，算法复杂性度量主要指哪两个⽅⾯？ 8.贪⼼算法求解的问题主要具有哪些性质？简述之。
9.分治法的基本思想是什么？合并排序的基本思想是什么？请分别简述之。
10.简述分析贪⼼算法与动态规划算法的异同。
三、算法编写及算法应⽤分析题： 1.已知有3个物品：(w1,w2,w3)=(12,10,6),(p1,p2,p3)=(15,13,10),背包的容积M=20，根据0-1背包动态规划的递推式求出最优解。
2.按要求完成以下关于排序和查找的问题。
①对数组A={15，29，135，18，32，1，27，25，5}，⽤快速排序⽅法将其排成递减序。
②请描述递减数组进⾏⼆分搜索的基本思想，并给出⾮递归算法。
③给出上述算法的递归算法。
④使⽤上述算法对①所得到的结果搜索如下元素，并给出搜索过程：18，31，135。
3.已知1()*()i i k kij r r A a +=，k =1，2，3，4，5，6，r 1=5，r 2=10，r 3=3，r 4=12，r 5=5，r 6=50，r 7=6，求矩阵链积A 1×A 2×A 3×A 4×A 5×A 6的最佳求积顺序（要求给出计算步骤）。
4.根据分枝限界算法基本过程,求解0-1背包问题。
已知n=3,M=20，(w1,w2,w3)=(12,10,6),(p1,p2,p3)=(15,13,10)。
5.试⽤贪⼼算法求解汽车加油问题：已知⼀辆汽车加满油后可⾏驶n 公⾥，⽽旅途中有若⼲个加油站。
试设计⼀个有效算法，指出应在哪些加油站停靠加油，使加油次数最少，请写出该算法。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
算法分析与设计教程习题解答第1章 算法引论1. 解：算法是一组有穷的规则，它规定了解决某一特定类型问题的一系列计算方法。
频率计数是指计算机执行程序中的某一条语句的执行次数。
多项式时间算法是指可用多项式函数对某算法进行计算时间限界的算法。
指数时间算法是指某算法的计算时间只能使用指数函数限界的算法。
2. 解：算法分析的目的是使算法设计者知道为完成一项任务所设计的算法的优劣，进而促使人们想方设法地设计出一些效率更高效的算法，以便达到少花钱、多办事、办好事的经济效果。
3. 解：事前分析是指求出某个算法的一个时间限界函数（它是一些有关参数的函数）；事后测试指收集计算机对于某个算法的执行时间和占用空间的统计资料。
4. 解：评价一个算法应从事前分析和事后测试这两个阶段进行，事前分析主要应从时间复杂度和空间复杂度这两个维度进行分析；事后测试主要应对所评价的算法作时空性能分布图。
5. 解：①n=11； ②n=12； ③n=982； ④n=39。
第2章 递归算法与分治算法1． 解：递归算法是将归纳法的思想应用于算法设计之中，递归算法充分地利用了计算机系统内部机能，自动实现调用过程中对于相关且必要的信息的保存与恢复；分治算法是把一个问题划分为一个或多个子问题，每个子问题与原问题具有完全相同的解决思路，进而可以按照递归的思路进行求解。
2． 解：通过分治算法的一般设计步骤进行说明。
3． 解：int fibonacci(int n) {if(n<=1) return 1;return fibonacci(n-1)+fibonacci(n-2); }4. 解：void hanoi(int n,int a,int b,int c) {if(n>0) {hanoi(n-1,a,c,b); move(a,b);hanoi(n-1,c,b,a); } } 5. 解：①22*2)(--=n n f n② )log *()(n n n f O =6． 解：算法略。
时间复杂度分析：设时间复杂度为T （n ），则因此，T(n )≤2T(n-1)≤22T(n-2)≤···≤2n-1T(1)=)2(nO 。
7． 解：后序遍历二叉树的非递归算法如下： typedef struct{ BiTree link; int flag; }Stacktype;void NRpostOrder(BiTree b){Stacktype Stack[MAX_TREE_SIZE]; BiTree p; int top,sign;if(b==NULL) return;top=-1; /*栈顶位置初始化*/ p=b;while(!(p==NULL&&top==-1)){if(p!=NULL){ /*结点第一次进栈*/ Stack[++top].link=p; Stack[top].flag=1;p=p->lchild; /*找该结点的左孩子*/ } else{p=Stack[top].link; sign=Stack[top--].flag;if(sign==1){ /*结点第二次进栈*/Stack[++top].link=p;Stack[top].flag=2; /*标记第二次出栈*/ p=p->lchild; } else{Visit(p->data)； /*访问该结点数据域值*/ p=NULL; } } } }8. 解：第一趟排序后数组中的元素排列为35、37、38、36、47、65、53、73； 第二趟排序后数组中的元素排列为35、37、38、36、47、53、65、73； 第三趟排序后数组中的元素排列为35、36、37、38、47、53、65、73； 第四趟排序后数组中的元素排列为35、36、37、38、47、53、65、73。
0)2()1()(>≤⎪⎩⎪⎨⎧-+-=n n n T n T C n T9．解：①原数组是有序的；②n*(n-1)/2。
10．解：（略）思路同第8题。
11．解：void maxmin(int A[],int &e_max,int low,int high){int mid,x1,y1,x2,y2;if((high-low)<=1){if(A[high]>A[low]){e_max=A[high];e_min=A[low];}else{e_max=A[low];e_min=A[high];}}else{mid=(low+high)/2;maxmin(A,x1,y1,low,mid);maxmin(A,x2,y2,mid+1,high);e_max=max(x1,x2);e_min=min(x1,x2);}}12. 解：void poly_product(float p[],float q[],float r0[],int n) {int k,i;float *r1,*r2,*r3;r1=new float[2*n-1];r2=new float[2*n-1];r3=new float[2*n-1];for(i=0;i<2*n-1;i++)r0[i]= r1[i]=r2[i]=r3[i]=0;if(n==2)product(p,q,c);else{k=n/2;poly_product(p,q,r0,k);poly_product(p+k,q+k,r1+2*k,k);plus(p,p+k,r2+k,k);plus(q,q+k,r3,k);poly_product(r2+k,r3,r2+k,k);mins(r2+k,r0,2*k-1);mins(r2+k,r1+2*k,2*k-1);plus(r0+k,r2+k,r0+k,2*k-1);plus(r0+2*k,r1+2*k,r0+2*k,2*k-1);}delete r1;delete r2;delete r3;}void product(float p[],float q[],float c[]){c[0]=p[0]*q[0];c[2]=p[1]*q[1];c[1]=(p[0]+p[1])*(q[0]+q[1])-c[0]-c[2];}void plus(float p[],float q[],float c[],int n){int i;for(i=0;i<n;i++)c[i]=p[i]+q[i];}void mins(float p[],float q[],int n){int i;for(i=0;i<n;i++)p[i]=p[i]-q[i];}第3章贪心算法1．解：（1）最优解的序列为（1,2/3,1,0,1,1,1）；FO（I）=10+2/3*5+15+6+18+3=166/3；按Pi的非增次序输入时的序列为（1,0,1,4/7,0,1,0）；FG（I）=10+15+4/7*7+18=47；因此，FO（I）/FG（I）=166/141；（2）按wi的非降次序列输入时的序列为（1,1,4/5,0,1,1,1）；此时的背包问题解为FG*（I）=10+5+4/5*15+6+18+3=54；因此，FO（I）/FG*（I）=83/81。
2．解：举一个反例如下：设背包容量为13，有7件物品，它们的容量组成的向量为（1,2,4,5,3,3,7），它们的效益值组成的向量为（6,10,18,14,8,7,7）。
按照贪心算法计算求解总效益值为6+10+18+14=48，此时物品的总容量为1+2+4+5=12≤13；可是按照6+10+18+8+7=49，此时物品的总容量为1+2+4+3+3=13亦没有超过背包容量13，由于总效益值48＜49，因此该策略在这种情况下得不到最优解。
3．解：#include<iostream>using namespace std;const int N=12;void OutputResult(int Select[N]){cout<<”{0”;for(int i=1;i<N;i++)if(Select[i]==1)cout<<”,”<<i;cout<<’}’<<endl;}int main(){int Begin[N]={1,3,0,3,2,5,6,4,10,8,15,15};int End[N]={3,4,7,8,9,10,12,14,15,18,19,20};int Select[N]={0,0,0,0,0,0,0,0,0,0,0,0};int i=0;int TimeStart=0;while(i<N){if(Begin[i]>=TimeStart){Select[i]=1;TimeStart=End[i];}i++;}OutputResult(Select);result 0;}4.解题思路提示如下：连接法：将间距较小的相邻区间连接成一个大的新区间，然后将所得的几个新区间的距离相加继而求得最小长度。
5．解：class JobNode{friend void Greedy(JobNode *,int,int);friend void main(void);public:operator int()const{return time;}private:int ID,time;};class MachineNode{friend void Greedy(JobNode *,int,int);public:operator int()const{return avail;}private:int ID,avail;};template<class Type>void Greedy(Type a[],int n,int m){ if(n<=m){cout<<“为每个作业分配一台机器。
”<<endl;return;}Sort(a,n);MinHeap<MachineNode>H(m);MachineNode x;for(int i=1;i<=m;i++){x.avail=0;x.ID=i;H.Insert(x);}for(int i=n;i>=1;i--){H.DeleteMin(x);cout<<“将机器”<<x.ID<<“从”<<x.avail<<“到”<<(x.avail+a[i].time)<<“的时间段分配给作业”<<a[i].ID<<endl; x.avail+=a[i].time;H.Insert(x);}}6．解：#include <iostream>#include <cstring>using namespace std;void deleteS(char *p){while(*p){*p = *(p+1);p++;}}int main(){char S[240];int i,m;cout <<"请输入数字串:"<<endl;cin >> S;cout <<"请输入须删掉多少个数:N"<<endl;do {cout <<"0 < N <数字串的长度" <<endl;cin >> m;} while( m<0 || m >= (int)strlen(S) );while(m>0){i = 0;while( i<(int)strlen(S) &&(S[i]<=S[i+1]) )i++;deleteS(&S[i]);m--;}/*删除S串中高位的0*/;while(S[0]=='0') deleteS(&S[0]);if ( strlen(S)!=0 )cout << S <<endl;elsecout << ‘0’ <<endl;return 0;}7．解：#include<iostream>#include<cmath>using namespace std;#define maxn 1005struct POINT{double l,r;};double x[maxn],y[maxn];POINT points[maxn];int can,ans,n,d,mk[maxn];int comp(const void *a,const void *b) /*线段排序比较函数*/{POINT *aa,*bb;aa=(POINT *)a; bb=(POINT *)b; /*强制类型转换*/if(aa->r-bb->r<1e-8&&bb->r-aa->r<1e-8)/*aa的右端点与bb的右端点相同*/ return 0;if(aa->r<bb->r) /*aa的右端点在bb的右端点右边*/return -1;return 1; /*aa的右端点在bb的右端点左边*/}void init() /*输入与初始化*/{int i;for(can=1,i=0;i<n;i++){cin>>x[i]>>y[i]; /*输入岛屿i的坐标*/if（d+1e-8>y[i]） /*如果岛屿i在雷达监控范围内，计算海岸线上对应的雷达安装区域*/{points[i].l=x[i]-sqrt(double(d)*d-y[i]*y[i]);points[i].r=x[i]+sqrt(double(d)*d-y[i]*y[i]);}else can=0;}}void solve(){int i,j;qsort(points,n,sizeof(POINT),comp); /*将各岛屿按在海岸线的可安装雷达区域右端大小排序*/for(i=0;i<n;i++) mk[i]=0;for(ans=0,i=0;i<n;i++)if(!mk[i]){mk[i]=1; /*进行贪心策略选择*/ans++;for(j=i+1;j<n;j++)if((!mk[j])&&(points[j].l<=points[i].r+1e-8))mk[j]=1;}}int main(){int caseno=0;while(cin>>n>>d,(n>0||d>0)){cout<<"Case"<<++caseno<<":";init();if(!can)cout<<-1<<endl;else{solve();cout<<ans<<endl;}}return 0;}第4章动态规划算法1．解：最短路径为0->1->6->7->9，路径长度为17。