算法导论实验

合集下载

计算导论实验报告

计算导论实验报告

一、实验目的1. 理解计算机科学的基本概念,掌握计算的基本原理。

2. 掌握算法设计的基本方法,提高算法分析能力。

3. 熟悉计算机编程语言,能够编写简单的计算程序。

二、实验内容1. 计算导论基础知识2. 算法设计与分析3. 计算机编程实现三、实验步骤1. 计算导论基础知识(1)学习计算机科学的基本概念,如计算机系统组成、信息处理过程、数据结构等。

(2)掌握计算机编程语言的基本语法和常用数据类型。

2. 算法设计与分析(1)学习算法设计的基本方法,如分治法、贪心法、动态规划等。

(2)掌握算法的时间复杂度和空间复杂度的分析方法。

(3)针对实际问题,设计合适的算法,并进行优化。

3. 计算机编程实现(1)选择一种编程语言(如Python、Java、C++等)进行编程。

(2)根据实验要求,编写计算程序,实现算法。

(3)调试程序,确保程序正确运行。

四、实验结果与分析1. 计算导论基础知识(1)掌握了计算机科学的基本概念,如计算机系统组成、信息处理过程、数据结构等。

(2)了解了计算机编程语言的基本语法和常用数据类型。

2. 算法设计与分析(1)学会了分治法、贪心法、动态规划等算法设计方法。

(2)能够分析算法的时间复杂度和空间复杂度。

(3)针对实际问题,设计并实现了高效的算法。

3. 计算机编程实现(1)掌握了编程语言的基本语法和常用数据类型。

(2)能够编写简单的计算程序,实现算法。

(3)通过调试程序,确保程序正确运行。

五、实验心得1. 通过本次实验,我对计算机科学的基本概念有了更深入的了解,认识到计算机科学在现代社会的重要性。

2. 在算法设计与分析方面,我学会了如何根据实际问题设计合适的算法,并分析算法的效率。

3. 在编程实现方面,我提高了自己的编程能力,学会了如何将算法转化为程序,并通过调试程序解决实际问题。

4. 本次实验让我体会到理论与实践相结合的重要性,只有将所学知识应用于实际,才能真正掌握。

六、实验建议1. 在实验过程中,应注重基础知识的学习,为后续实验打下坚实基础。

算法导论4-3

算法导论4-3

算法导论4-3读书笔记代⼊法求解递归式分为两步:1. 猜测解的形式。

2. ⽤数学归纳法求出解中的常数,并证明解是正确的。

但是并不存在通⽤的⽅法来猜测递归式的正确解,但是也是有⼀些技巧的:1. 使⽤递归树辅助猜测2. 先猜测⼀个较为宽松的上界和下界,然后缩⼩范围课后习题证明:T(n)=T(n−1)+n的解为O(n2)猜测:T(n)≤cn2证明:T(n)=T(n−1)+n≤c(n−1)2+n=cn2−2cn+c+n≤cn2此处只要−2cn+c+n≤0,上述不等式成⽴;所以c≥n 2n−1因此可令c=1,证毕。

证明:T(n)=T(⌈n/2⌉)+1的解为O(lg n)证明:T(n)=T(⌈n/2⌉)+1=c lg n2+1=c lg n−c+1≤c lg n令c=1,上式成⽴,证毕;我们看到T(n)=2T(⌊n/2⌋)+n的解为O(n lg n)。

证明Ω(n lg n)也是这个递归式的解。

从⽽得出结论: 解为θ(n lg n)。

证明:T(n)=2T(⌊n/2⌋)+n=cn lg n2+n=cn lg n−cn+n≥cn lg n令c=1,上式成⽴,证毕;证明:通过做出不同的归纳假设,我们不必调整归纳证明中的边界条件,即可克服递归式(4.19)中边界条件T(1)=1带来的困难。

将假设换位T(n)≤cn lg n+d,其中d≥0即可;证明:归并排序的严格递归式(4.3)的解为θ(n lg n)。

严格递归式4.3:T(n)=θ(1)if n=1 T(⌈n/2⌉)+T(⌊n/2⌋)+θ(n)if n>1 {证明:T(n)=2T(⌊n/2⌋+17)+n的解为O(n lg n)。

证明:T(n)=2T(⌊n/2⌋+17)+n//todo使⽤4.5节中的主⽅法,可以证明T(n)=4T(n/3)+n的解为T(n)=θ(n log43)。

说明基于假设T(n)≤cn log43的代⼊法不能证明这⼀结论。

然后说明如何通过减去⼀个低阶项完成代⼊法证明。

中国科技大学算法导论_第二次实验报告

中国科技大学算法导论_第二次实验报告

第二次实验报告红黑树1.红黑树1.1 需求分析本实验要求实现红黑树各种操作如SEARCH ,PREDECESOR ,SUCCESSOR ,MINIMUM,MAXIMUM,INSERT,DELETE 等。

红黑树是一种自平衡二叉查找树,是在计算机科学中用到的一种数据结构,典型的用途是实现关联数组。

它是在1972 年由Rudolf Bayer 发明的,他称之为"对称二叉B 树",它现代的名字是在Leo J. Guibas 和Robert Sedgewick 于1978 年写的一篇论文中获得的。

它是复杂的,但它的操作有着良好的最坏情况运行时间,并且在实践中是高效的: 它可以在O(log n)时间内做查找,插入和删除,这里的n 是树中元素的数目。

红黑树是每个节点都带有颜色属性的二叉查找树,颜色或红色或黑色。

在二叉查找树强制一般要求以外,对于任何有效的红黑树我们增加了如下的额外要求:1. 每个结点或红或黑。

2. 根结点为黑色。

3. 每个叶结点(实际上就是NULL 指针)都是黑色的。

4. 如果一个结点是红色的,那么它的周边3 个节点都是黑色的。

5. 对于每个结点,从该结点到其所有子孙叶结点的路径中所包含的黑色结点个数都一样。

这些约束强制了红黑树的关键性质: 从根到叶子的最长的可能路径不多于最短的可能路径的两倍长。

结果是这个树大致上是平衡的。

因为操作比如插入、删除和查找某个值的最坏情况时间都要求与树的高度成比例,这个在高度上的理论上限允许红黑树在最坏情况下都是高效的,而不同于普通的二叉查找树。

要知道为什么这些特性确保了这个结果,注意到属性5 导致了路径不能有两个毗连的红色节点就足够了。

最短的可能路径都是黑色节点,最长的可能路径有交替的红色和黑色节点。

因为根据属性4 所有最长的路径都有相同数目的黑色节点,这就表明了没有路径能多于任何其他路径的两倍长。

在很多树数据结构的表示中,一个节点有可能只有一个子节点,而叶子节点包含数据。

中国科技大学算法导论_第一次实验报告

中国科技大学算法导论_第一次实验报告

快速排序实验报告SA14225010一、题目当输入数据已经“几乎”有序时,插入排序速度很快。

在实际应用中,我们可以利用这一特点来提高快速排序的速度。

当对一个长度小于k的子数组调用快速排序时,让它不做任何排序就返回。

当上层的快速排序调用返回后,对整个数组运行插入排序来完成排序过程。

试证明:这一排序算法的期望时间复杂度为O (nk+nlg(n/k))。

分别从理论和实践的角度说明我们应该如何选择k?二、算法思想当输入数据已经“几乎”有序时,插入排序速度很快。

当对一个长度小于k的子数组调用快速排序时,让它不做任何排序就返回。

当上层的快速排序调用返回后,对整个数组运行插入排序来完成排序过程。

累加k的值,计算出当k为不同值时算法运行的时间,来算出当k大约为什么值时运行的时间最短,并与传统的快速排序算法的运行时间进行比较。

三、实验结果输入100个不同的整数值,选取不同的k的值,观察所用时间四、实验分析理论上看,k的值选取为20到25较好;但是,从实际上来看,当k为50左右时间为39毫秒,最少,但不同的时刻运行后的时间都不相同,而且不同的输入时刻的运行时间也不相同,当数据较大时候,对k 的值的选取有会有所不同,同时不同性能的机器对测试结果也不同,所以对于k值的选取没有固定的数值。

#include<iostream>#include<sys/timeb.h>using namespace std;#define M 40void swap(int * a,int * b){int tem;tem=*a;*a=*b;*b=tem;}int partition(int v[],const int low,const int high){int i,pivotpos,pivot;pivotpos=low;pivot=v[low];for(i=low+1;i<=high;++i){if(v[i]<pivot){pivotpos++;if(pivotpos!=i)swap(v[i],v[pivotpos]);}}v[low]=v[pivotpos];v[pivotpos]=pivot;//cout<<"the partition function is called\n";return pivotpos;}/*void QuickSort(int a[], const int low,const int high) {int item;if(low<high){item=partition(a,low,high);QuickSort(a,low,item-1);QuickSort(a,item+1,high);}}*/void QuickSort(int a[], const int low,const int high) {int item;if(high-low<=M)return;if(low<high){item=partition(a,low,high);QuickSort(a,low,item-1);QuickSort(a,item+1,high);}// cout<<"the QuickSort is called"<<endl;}void InsertSort(int a[],const int low,const int high){int i,j;int tem;for(i=1;i<high+1;++i){tem=a[i];j=i-1;while(j>=0&&tem<a[j]){a[j+1]=a[j];j--;}a[j+1]=tem;}//cout<<"the InsertSort is called"<<endl;}void HybridSort(int a[],const int low,const int high){QuickSort(a,low,high);InsertSort(a,low,high);cout<<"the HybidSort is called"<<endl;}int main(){int i,a[100];//int *a=NULL;long int t;struct timeb t1,t2;/*cout<<"please input the number of the element:"<<endl;cin>>n;a = (int*)malloc(n*sizeof(int));cout<<"please input every element:"<<endl;*/for( i=0; i<100; i++){a[i]=i+10;}//QuickSort(a,0,n-1);ftime(&t1);HybridSort(a,0,99);cout<<" after sorted quickly,the result is"<<endl;for(i=0; i<100; i++){cout<<a[i]<<" ";if(i%10==0)cout<<endl;}cout<<endl;ftime(&t2);t=(t2.time-t1.time)*1000+(litm); /* 计算时间差 */ printf("k=%d 用时%ld毫秒\n",M,t);//cout<<"the memory of array a is free"<<endl;//free(a);cout<<"\n"<<endl;return 0;}。

算法课设实验报告(3篇)

算法课设实验报告(3篇)

第1篇一、实验背景与目的随着计算机技术的飞速发展,算法在计算机科学中扮演着至关重要的角色。

为了加深对算法设计与分析的理解,提高实际应用能力,本实验课程设计旨在通过实际操作,让学生掌握算法设计与分析的基本方法,学会运用所学知识解决实际问题。

二、实验内容与步骤本次实验共分为三个部分,分别为排序算法、贪心算法和动态规划算法的设计与实现。

1. 排序算法(1)实验目的:熟悉常见的排序算法,理解其原理,比较其优缺点,并实现至少三种排序算法。

(2)实验内容:- 实现冒泡排序、快速排序和归并排序三种算法。

- 对每种算法进行时间复杂度和空间复杂度的分析。

- 编写测试程序,对算法进行性能测试,比较不同算法的优劣。

(3)实验步骤:- 分析冒泡排序、快速排序和归并排序的原理。

- 编写三种排序算法的代码。

- 分析代码的时间复杂度和空间复杂度。

- 编写测试程序,生成随机测试数据,测试三种算法的性能。

- 比较三种算法的运行时间和内存占用。

2. 贪心算法(1)实验目的:理解贪心算法的基本思想,掌握贪心算法的解题步骤,并实现一个贪心算法问题。

(2)实验内容:- 实现一个贪心算法问题,如活动选择问题。

- 分析贪心算法的正确性,并证明其最优性。

(3)实验步骤:- 分析活动选择问题的贪心策略。

- 编写贪心算法的代码。

- 分析贪心算法的正确性,并证明其最优性。

- 编写测试程序,验证贪心算法的正确性。

3. 动态规划算法(1)实验目的:理解动态规划算法的基本思想,掌握动态规划算法的解题步骤,并实现一个动态规划算法问题。

(2)实验内容:- 实现一个动态规划算法问题,如背包问题。

- 分析动态规划算法的正确性,并证明其最优性。

(3)实验步骤:- 分析背包问题的动态规划策略。

- 编写动态规划算法的代码。

- 分析动态规划算法的正确性,并证明其最优性。

- 编写测试程序,验证动态规划算法的正确性。

三、实验结果与分析1. 排序算法实验结果:- 冒泡排序:时间复杂度O(n^2),空间复杂度O(1)。

《算法导论》贪心算法实验指导书(二)

《算法导论》贪心算法实验指导书(二)

《算法导论》贪心算法实验指导书(二)
《算法导论》实验指导书
本书共分阶段4个实验,每个实验有基本题和提高题。

基本题必须完成,提高题根据自己实际情况进行取舍。

题目不限定如下题目,可根据自己兴趣爱好做一些与实验内容相关的其他题目,如动态规划法中的图象压缩,回溯法中的人机对弈等。

其具体要求和步骤如下:
实验三贪心算法(4学时)
一、实验要求与目的
1、熟悉贪心算法的基本原理与适用范围。

2、使用贪心算法编程,求解最小生成树问题。

二、实验内容
1、任选一种贪心算法(Prim或Kruskal),求解最小生成树。

对算法进行描述和复杂性分析。

编程实现,并给出测试实例
一、实验要求与目的
3、熟悉贪心算法的基本原理与适用范围。

4、使用贪心算法编程,求解霍夫曼编码问题。

二、实验内容
2、采用贪心算法,求解霍夫曼编码。

对算法进行描述和复杂性分析。

编程实现,并给出测试实例
一、实验目的与要求
1、掌握汽车加油问题的算法;
2、进一步掌握贪心算法;
二、实验题
一辆汽车加满油后可以行驶N千米。

旅途中有若干个加油站。

若要使沿途的加油次数最少,设计一个有效的算法,指出应在那些加油站停靠加油。

并证明你的算法能产生一个最优解。

三、实验提示
把两加油站的距离放在数组中,a[1..n]表示从起始位置开始跑,经过n个加油站,a[k]表示第k-1个加油站到第k个加油站的距离。

汽车在运行的过程中如果能跑到下一个站则不加油,否则要加油。

(算法略)。

算法实践教学设计模板(3篇)

算法实践教学设计模板(3篇)

第1篇一、教学目标1. 知识目标:(1)使学生掌握算法的基本概念、原理和设计方法。

(2)使学生熟悉常见算法(如排序、查找、递归等)的实现过程。

(3)使学生了解算法分析的基本方法,包括时间复杂度和空间复杂度。

2. 能力目标:(1)培养学生运用算法解决问题的能力。

(2)提高学生的编程技能,包括代码编写、调试和优化。

(3)培养学生的团队协作和沟通能力。

3. 情感目标:(1)激发学生对算法学习的兴趣,培养学生严谨的学术态度。

(2)增强学生的自信心,提高面对复杂问题的解决能力。

(3)培养学生的创新意识和实践能力。

二、教学内容1. 算法概述- 算法的定义与特点- 算法的基本要素- 算法的分类2. 算法设计方法- 分解与抽象- 排序算法(冒泡排序、选择排序、插入排序等)- 查找算法(顺序查找、二分查找等)- 递归算法3. 算法分析- 时间复杂度- 空间复杂度4. 实践项目- 项目一:实现排序算法- 项目二:实现查找算法- 项目三:设计递归算法解决实际问题三、教学方法1. 讲授法- 讲解算法的基本概念、原理和设计方法。

- 分析常见算法的优缺点和适用场景。

2. 案例分析法- 通过实际案例,展示算法在实际问题中的应用。

- 分析案例中算法的设计思路和实现方法。

3. 实践教学法- 指导学生完成实践项目,让学生在实践中掌握算法知识。

- 引导学生分析算法的时间复杂度和空间复杂度。

4. 小组讨论法- 将学生分组,针对实践项目进行讨论,互相学习、共同进步。

- 激发学生的创新意识和团队协作能力。

四、教学过程1. 引入- 通过实例介绍算法的重要性,激发学生的学习兴趣。

- 明确教学目标,让学生了解本节课的学习内容。

2. 讲解- 讲解算法的基本概念、原理和设计方法。

- 分析常见算法的优缺点和适用场景。

3. 案例分析- 展示实际案例,让学生了解算法在实际问题中的应用。

- 分析案例中算法的设计思路和实现方法。

4. 实践指导- 指导学生完成实践项目,让学生在实践中掌握算法知识。

中科大软院算法导论区间树实验报告

中科大软院算法导论区间树实验报告

区间树实验报告1.区间树的实验源码见另外一个文件2.区间树实验分析2.1 需求分析基础数据结构选择红黑树,每个结点x 包含一个区间域int[x],x 的关键字为区间的低端点low[int[x]],对树;进行中序遍历就可按低端点的次序列出个区间,结点还包含一个max[x],即以x 为根的子树中所有区间的端点的最大值。

如:实验要求:将红黑树扩展为区间树(1)区间的端点为正整数,随机生成;(2)内部节点数为n:2^4,2^6,2^8,2^10,2^12;(3)测试插入,删除,查找的时间并绘出曲线,运行次数为10 次;2.2 程序设计区间树的操作基本和红黑树的相同,在其基础上增加了一个新方法:INTERVAL_SEARCH(T,i);它用来找出树中覆盖区间i 的那个结点。

如果树中不存在,则返回nil[T]指针。

代码如下:ITNode* IntervalTree::Interval_Search(Interval i){ITNode* x=root;while(x!=Nil && !x->Overlap(i)){// x != nil and i doesn't overlap int[x]if (x->left!=Nil && x->left->max>=i.low)x=x->left;else x=x->right;}return x;}区间树的插入、删除除了有可能改变红黑树性质,还有可能改变结点的max 值。

前者向红黑树那样处理就可以了,又max[x] = max(high[int[x]], max[left[x]], max[right[x]])为解决后者,增加一方法Nodemax(),让它来维护结点的max 值。

Nodemax()如下:void ITNode::NodeMax(ITNode* xl, ITNode* xr){Type tp=this->interval->high;if (tp < xl->max)tp=xl->max;if(tp < xr->max)tp=xr->max;this->max=tp;}在左旋、右旋时调用此方法。

重庆大学算法导论跳桩得珠宝问题项目报告(包含报告和源代码)

重庆大学算法导论跳桩得珠宝问题项目报告(包含报告和源代码)

大学项目报告项目题目:跳桩得珠宝问题学院:专业班级:计科年级:2011级姓名:学号:完成时间:2013 年 6 月7 日指导教师:波大学教务处制项目报告正文一.问题描述有m排n列的柱桩,每一排的柱桩从左向右标号为1,2,…,n,且在每个柱桩上预先放好价值不一样的宝石。

现在有位杂技演员从第一排的第1号柱桩开始跳跃,每次都必须跳到下一排的柱桩上,且每次跳跃最多只能向左或向右移动一个桩子。

也就是说如果现在杂技演员站在第j号桩上,那么他可跳到下一排的第j号桩上,也可跳到下一排的第j-1 (if j>1)或者j+1 (if j<n) 号桩上,并得到桩上的宝石。

计算出一条最佳的跳跃顺序,使杂技演员获得的宝石的总价值最大。

二.算法思想问题抽象:对于这个问题,可以抽象为:从顶部出发,在每一结点可以选择向左走,向下走或是向右走,一直走到底层,要求找出一条路径,使路径上的值最大。

问题分析:这道题如果用枚举法,在数塔层数稍大的情况下(如40),则需要列举出的路径条数将是一个非常庞大的数目。

如果用贪心法又往往得不到最优解。

在用动态规划考虑数塔问题时可以自顶向下的分析,自底向上的计算。

于是在确定使用动态规划的情况下,对该问题进行分析。

算法思想:从顶点出发时到底向左走,向下走还是向右走应取决于是从哪个方向走能取到最大值,只要左中右三道路径上的最大值求出来了才能作出决策。

同样的道理下一层的走向又要取决于再下一层上的最大值是否已经求出才能决策。

这样一层一层推下去,直到倒数第二层时就非常明了。

所以实际求解时,可从底层开始,层层递进,最后得到最大值。

首先,我可以确定,对于矩阵可以用一个二维数组dp储存它,并且可以用(i,j)描述一个数字在矩阵中的位置。

对于中间的一个点来说,想经过它则必须经过它的上方或左上或右上,也就是说经过这个点的数字和最大等于经过上方或左上方或右上方的所得的“最大和”中一个更大的加上这个点中的数字。

西电算法导论上机实验报告

西电算法导论上机实验报告

算法导论上机实验报告册班级:xxxxxx学号:xxxxxxx 姓名:xxxx 教师:xxxxxx目录实验一排序算法 (1)题目一: (1)1、题目描述: (1)2、所用算法: (1)3、算法分析: (1)4、结果截图: (1)5、总结: (2)题目二: (3)1、题目描述: (3)2、所用算法: (3)3、算法分析: (3)4、结果截图: (3)5、总结: (4)题目三: (4)1、题目描述: (4)2、所用算法: (4)3、算法分析: (5)4、结果截图: (5)5、总结: (5)题目四: (6)1、题目描述: (6)3、算法分析: (6)4、结果截图: (6)5、总结: (7)实验二动态规划 (7)题目一: (7)1、题目描述: (7)2、所用策略: (7)3、算法分析: (7)4、结果截图: (8)5、总结: (8)题目二: (9)1、题目描述: (9)2、所用策略: (9)3、算法分析: (9)4、结果截图: (9)5、总结: (10)题目三: (10)1、题目描述: (10)2、所用策略: (10)3、算法分析: (10)4、结果截图: (11)题目四: (12)1、题目描述: (12)2、所用策略: (12)3、算法分析: (12)4、结果截图: (12)5、总结: (13)题目五: (13)1、题目描述: (13)2、所用策略: (13)3、算法分析: (13)4、结果截图: (14)5、总结: (14)实验三贪心算法 (14)题目一: (14)1、题目描述: (14)2、所用策略: (14)3、算法分析: (14)4、结果截图: (15)5、总结: (16)题目二: (16)1、题目描述: (16)3、算法分析: (16)4、结果截图: (17)5、总结: (17)题目三: (17)1、题目描述: (17)2、所用算法: (18)3、算法分析: (18)4、结果截图: (18)5、总结: (19)题目四: (19)1、题目描述: (19)2、所用算法: (19)3、算法分析: (19)实验四回溯法 (19)题目一: (19)1、题目描述: (20)2、所用策略: (20)3、算法分析: (20)题目二: (21)1、题目描述: (21)2、所用策略: (21)实验一排序算法题目一:1、题目描述:描述一个运行时间为θ(nlgn)的算法,给定n个整数的集合S和另一个整数x,该算法能确定S中是否存在两个其和刚好为x的元素。

中科大算法导论作业标准标准答案

中科大算法导论作业标准标准答案

第8次作业答案16.1-116.1-2543316.3-416.2-5参考答案:16.4-1证明中要三点:1.有穷非空集合2.遗传性3.交换性第10次作业参考答案16.5-1题目表格:解法1:使用引理16.12性质(2),按wi单调递减顺序逐次将任务添加至Nt(A),每次添加一个元素后,进行计算,{计算方法:Nt(A)中有i个任务时计算N0 (A),…,Ni(A),其中如果存在Nj (A)>j,则表示最近添加地元素是需要放弃地,从集合中删除};最后将未放弃地元素按di递增排序,放弃地任务放在所有未放弃任务后面,放弃任务集合内部排序可随意.解法2:设所有n个时间空位都是空地.然后按罚款地单调递减顺序对各个子任务逐个作贪心选择.在考虑任务j时,如果有一个恰处于或前于dj地时间空位仍空着,则将任务j赋与最近地这样地空位,并填入; 如果不存在这样地空位,表示放弃.答案(a1,a2是放弃地):<a5, a4, a6, a3, a7,a1, a2>or <a5, a4, a6, a3, a7,a2, a1>划线部分按上表di递增地顺序排即可,答案不唯一16.5-2(直接给个计算例子说地不清不楚地请扣分)题目:本题地意思是在O(|A|)时间内确定性质2(性质2:对t=0,1,2,…,n,有Nt(A)<=t,Nt(A)表示A中期限不超过t地任务个数)是否成立.解答示例:思想:建立数组a[n],a[i]表示截至时间为i地任务个数,对0=<i<n,如果出现a[0]+a[1]+…+a[i]>i,则说明A不独立,否则A独立.伪代码:int temp=0;for(i=0;i<n;i++) a[i]=0; ******O(n)=O(|A|)for(i=0;i<n;i++) a[di]++; ******O(n)=O(|A|)for(i=0;i<n;i++) ******O(n)=O(|A|) {temp+=a[i];//temp就是a[0]+a[1]+…+a[i]if(temp>i)//Ni(A)>iA不独立;}17.1-1(这题有歧义,不扣分)a) 如果Stack Operations包括Push Pop MultiPush,答案是可以保持,解释和书上地Push Pop MultiPop差不多.b) 如果是Stack Operations包括Push Pop MultiPush MultiPop,答案就是不可以保持,因为MultiPush,MultiPop交替地话,平均就是O(K).17.1-2本题目只要证明可能性,只要说明一种情况下结论成立即可17.2-1第11次作业参考答案17.3-1题目:答案:备注:最后一句话展开:采用新地势函数后对i 个操作地平摊代价:)1()())1(())(()()(1''^'-Φ-Φ+=--Φ--Φ+=Φ-Φ+=-Di Di c k Di k Di c D D c c i i i i i i17.3-2题目:答案:第一步:此题关键是定义势能函数Φ,不管定义成什么首先要满足两个条件 对所有操作i ,)(Di Φ>=0且)(Di Φ>=)(0D Φ比如令k j+=2i ,j,k 均为整数且取尽可能大,设势能函数)(Di Φ=2k;第二步:求平摊代价,公式是)1()(^-Φ-Φ+=Di Di c c i i 按上面设置地势函数示例:当k=0,^i c =…=2当k !=0,^i c =…=3 显然,平摊代价为O(1)17.3-4题目:答案:结合课本p249,p250页对栈操作地分析很容易有下面结果17.4-3题目:答案:αα=(第i次循环之后地表中地entry 假设第i个操作是TABLE_DELETE, 考虑装载因子:inum size数)/(第i次循环后地表地大小)=/i i第12 次参考答案19.1.1题目:答案:如果x不是根,则degree[sibling[x]]=degree[child[x]]=degree[x]-1如果x是根,则sibling为二项堆中下一个二项树地根,因为二项堆中根链是按根地度数递增排序,因此degree[sibling[x]]>degree[x]19.1.2题目:答案:如果x是p[x]地最左子节点,则p[x]为根地子树由两个相同地二项树合并而成,以x为根地子树就是其中一个二项树,另一个以p[x]为根,所以degree[p[x]]=degree[x]+1;如果x不是p[x]地最左子节点,假设x是p[x]地子节点中自左至右地第i个孩子,则去掉p[x]前i-1个孩子,恰好转换成第一种情况,因而degree[p[x]]=degree[x]+1+(i-1)=degree[x]+i;综上,degree[p[x]]>degree[x]19.2.2题目:题目:19.2.519.2.6第13次作业参考答案20.2-1题目:解答:20.2-3 题目:解答:20.3-1 题目:答案:20.3-2 题目:答案:第14次作业参考答案这一次请大家自己看书处理版权申明本文部分内容,包括文字、图片、以及设计等在网上搜集整理.版权为个人所有This article includes some parts, including text, pictures, and design. Copyright is personal ownership.6ewMy。

中科大软院算法导论-第五次实验报告-最长公共子序列实验报告

中科大软院算法导论-第五次实验报告-最长公共子序列实验报告

第五次实验报告——最长公共子序列的生成算法1.1算法应用背景最长公共子序列是一个序列S ,如果分别是两个或多个已知序列的子序列,且是所有符合此条件序列中最长的,则S称为已知序列的最长公共子序列。

而最长公共子串(要求连续)和最长公共子序列是不同的。

最长公共子序列是一个十分实用的问题,它可以描述两段文字之间的“相似度”,即它们的雷同程度,从而能够用来辨别抄袭。

对一段文字进行修改之后,计算改动前后文字的最长公共子序列,将除此子序列外的部分提取出来,这种方法判断修改的部分,往往十分准确。

简而言之,百度知道、百度百科都用得上。

1.2算法原理若给定序列X={x1,x2,…,xm},则另一序列Z={z1,z2,…,zk},是X的子序列是指存在一个严格递增下标序列{i1,i2,…,ik}使得对于所有j=1,2,…,k有:zj=xij。

例如,序列Z={B,C,D,B}是序列X={A,B,C,B,D,A,B}的子序列,相应的递增下标序列为{2,3,5,7}。

例:∑= {x, y, z} ,A = x y z y x z x zx x x 是长度为3 的子序列x z y z x 是长度为5 的子序列例:A = x y z y x z x z,B = x z y x x y z xx x x是长度为3 的公共子序列x z y z 是长度为4 的公共子序列x z y x x z 是长度为6 的最长公共子序列1.3算法描述记L n,m为序列A n和B m的最长公共子序列长度,则L i,j为序列A i和Bj的最长公共子序列的长度。

根据最长公共子序列的性质,则得到:阶段的划分和最长公共子序列长度的获取第一阶段:计算A1和Bj的最长公共子序列的长度L1,j ,j=1,2,…m第二阶段:计算A2和B j的最长公共子序列的长度L2,j, j=1,2,…m第n 阶段:计算A n和B j的最长公共子序列的长度L n,j, j=1,2,…m第n 阶段的L m,n便是序列A n和B m的最长公共子序列的长度为了得到A n和B m最长公共子序列,设置一个二维的状态字数组s i,j,在上述每一个阶段计算L n,j过程中,根据公共子序列的性质则有按照如下方法把搜索状态登记于状态字s i,j中:s i,j =1 a i=b js i,j =2 a i≠b j L i-1,j>= L i,j-1s i,j =3 a i≠b j L i-1,j< L i,j-1设L n,m=k,S k=c1c2……c k是序列A n和B m的长度为k的最长公共子序列。

算法导论上机报告

算法导论上机报告

算法导论上机报告班级: 1313012学号:姓名:黄帮振描述一个运行时间为θ(nlgn)的算法给定n个整数的集合S和另一个整数x该算法能确定S中是否存在两个其和刚好为x的元素。

一、算法分析1、运用归并排序算法归并排序运用的是分治思想,时间复杂度为θ(nlgn)能够满足题目要求的运行时间。

归并排序的分解部分是每次将数组划分两个部分,时间复杂度为θ(1)再对已经分解的两个部分再进行分解直到将数组分解成单个元素为止。

解决部分是递归求解排序子序列,合并部分是将已经排序的子序列进行合并得到所要的答案,时间复杂度为θ(lgn)。

2、在已经排好序的基础上,对其运用二分查找二分查找算法的时间复杂度为θ(lgn)在题目要求的范围内,二分查找的条件为待查的数组为有序序列。

算法的主要思想为设定两个数low指向最低元素high指向最高元素,然后比较数组中间的元素与待查元素进行比较。

如果待查元素小于中间元素,那么表明查找元素在数组的前半段,反之,如果待查元素大于中间元素,那么表明查找元素在数组的后半段。

实现优先队列排序算法,需要支持以下操作:INSERT(S,x):把元素x插入到集合S中MAXMUM(S):返回S中具有最大key的元素EXTRACT-MAX(S):去掉并返回S中的具有最大key的元素INCREASE-KEY(S,x,k):将元素x的关键字值增到k。

一、算法原理快速排序采用分治策略,时间复杂度为θ(nlgn),但是最坏情况下为θ(n2),并且快速排序算法属于原地排序,并不需要开辟空间。

快速排序复杂的步骤为其分解的步骤分解的过程数组A[p..r]被划分为两个子数组A[p..q-1]和A[q+1..r],使得A[p..q-1]中的每个元素都小于A[q],而A[q]也小于等于A[q+1..r]中的每个元素。

而在实现的过程总是选择将A[r]作为基准点进行划分A[p..r]数组。

二、伪代码QUICKSORT(A,p,r)1 if p < r2 q = PARTITION(A,p,q)3 QUICKSORT(A,p,q-1)4 QUICKSORT(A,q+1,r)PARTITION(A,p,r)1 x = A[r]2 i = p-13 for j = p to r-14 if A[j]?x5 i = i+16 exchange A[i] with A[j]7 exchange A[i+1] with A[r]8 return i + 1三、实验总结问题答案:当选取第一个或者最后一个为基准点时,当n个元素相同的时候为最坏情况比较次数为n*(n-1)/2;快速排序比较次数最少为θ(nlgn),,最大的比较次数为θ(n2)。

算法导论学习报告

算法导论学习报告

算法设计与分析学习报告第一部分学习内容归纳“计算机算法是以一步接一步的方式来详细描述计算机如何将输入转化为所要求的输出的过程,或者说,算法是对计算机上执行的计算过程的具体描述。

”(参考文献:百度百科)《算法设计与分析》是一门面向设计,在计算机科学中处于核心地位的课程。

这门课程主要讲授了在计算机应用中经常遇到的问题和求解的方法,分治法、动态规划法、随机算法等设计算法的基本原理、技巧和算法复杂性的分析,以及计算理论简介。

第一部分“概论和数学准备”在简单了解了算法的基本概念和复杂性、研究步骤等几个重要知识点后,着重学习了算法的数学基础,包括生成函数、差方方程的求解等,主要适用于求解算法的时间复杂性。

“任何可以用计算机求解的问题所需要的计算时间都与其规模有关:问题的规模越小,解题所需的计算时间往往也越短,从而也就比较容易处理。

”(参考文献:《计算机算法设计与分析(第3版)》)而第二部分介绍的算法常用技术之首——分治法就运用了这样的思想。

分治法的要领在于Divide(子问题的划分)-Conquer(子问题的求解)-Combine(子问题解的组合)。

由于子问题和原问题是同类的,递归的思想在分治法中显得尤其重要,它们经常同时运用在算法设计中。

这部分内容从Select(求第k小元)算法,寻找最近点对算法和快速傅立叶变换FFT等实际应用中深化对分治法思想的理解,同时也强调了平衡思想的重要性。

第三部分“动态规划”与分治法类似,同样是把问题层层分解成规模越来越小的同类型的子问题。

但与分治法不同的是,分治法中的子问题通常是相互独立的,而动态规划法中的子问题很多都是重复的,因此通常采用递推的方法以避免重复计算。

然而,也不是所有的情况下都采用递推法,当有大量的子问题无需求解时,更好的方式是采用动态规划法的变形——备忘录方法。

通常需要用到动态规划法求解的问题都具有子问题的高度重复性和最优子结构性质两大特征,这也是我们分析问题和设计算法时的关键点。

算法导论

算法导论

几种重要的算法一高级技术和分析技术1.动态规划------------------------------------------------------√1.1动态规划的本质动态规划是在20世纪50年代初,为了解决一类多阶段决策问题而诞生的。

那么,什么样的问题被称作多阶段决策问题呢?多阶段决策问题通过下面这个例子来说明。

[例一]多段图中的最短路径问题:在图1.1中找出从Al到D1的最短路径(图中的边上的数字表示该边上的权)。

图1多阶段决策问题这个图有一个特点,就是可以将图中的点分为四类(图1.1中的A、B、C、D),那么图中所有的边都处于相邻的两类点之间,并且都从前一类点指向后一类点。

这样,图中的边就被分成了三类(A→B、B→C、C→D)。

这时需要从每一类中选出一条边来,组成从Al到Dl的一条路径,并且这条路径是所有这样的路径中的最短者。

这是多阶段决策问题。

更精确的定义如下:多阶段决策过程,是指这样的一类特殊的活动过程,问题可以按时间顺序分解成若干相互联系的阶段,在每一个阶段都要做出决策,全部过程的决策是一个决策序列。

要使整个活动的总体效果达到最优的问题,称为多阶段决策问题。

多阶段决策问题有两个要素:一个是阶段,一个是决策。

1.1.2阶段与状态阶段:将所给问题的过程,按时间或空间特征分解成若干相互联系的阶段,以便按次序去求每阶段的解。

常用字母k表示阶段变量。

阶段是问题的属性。

多阶段决策问题中通常存在着若干个阶段,如上图中就有A、B、C、D这四个阶段。

在一般情况下,阶段是和时间有关的;但是在很多问题中,阶段和时间是无关的。

从阶段的定义中,可以看出阶段的两个特点:一是“相互联系”,二是“次序”。

阶段之间是怎样相互联系的?就是通过状态和状态转移。

状态:各阶段开始时的客观条件叫做状态。

描述各阶段状态的变量称为状态变量,常用Sk表示第k阶段的状态变量,状态变量Sk的取值集合称为状态集合,用Sk表示。

状态是阶段的属性。

《算法导论》中的计算思维与问题解决的教学方案

《算法导论》中的计算思维与问题解决的教学方案

算法导论中的计算思维与问题解决的教学方案概述《算法导论》是一本经典的计算机科学教材,其中涵盖了许多重要的算法和数据结构概念。

但除了这些具体的知识点之外,该书还强调了一种更为重要的能力,即计算思维和问题解决能力。

本文将介绍一个基于《算法导论》中的教学方案,旨在培养学生的计算思维和问题解决能力。

教学目标•理解并掌握基本的计算思维模式,如分解、抽象、模式识别等。

•理解问题解决过程中所涉及到的关键概念和原则。

•培养独立思考和创新能力,并能够将其应用于实际问题中。

•培养团队合作和沟通能力。

教学内容与方法1. 引言阶段在引言阶段,通过介绍计算思维在现代社会中的应用场景以及其重要性,激发学生对该主题的兴趣,并让他们意识到它与自身专业发展的紧密联系。

可以使用案例分析、实际问题解决的例子等方式来展示计算思维的作用。

2. 计算思维基础知识在这个阶段,需要重点讲解计算思维的基本概念和思维模式,如分解问题、抽象建模、模式识别等。

同时,通过编程演示和讲解经典算法案例,帮助学生理解这些概念并能够应用到实际问题中。

3. 问题解决过程与原则在这个阶段,需要介绍问题解决的一般过程,并探讨其中涉及到的关键原则和策略。

例如,分析问题、寻找最优解、评估方案效果等。

通过案例分析和实践操作,引导学生学会正确地调整方法和策略应对不同类型的问题。

4. 实践项目为了巩固所学知识并提高实际应用能力,可以组织学生参与具体项目的开发或者挑战赛。

以实际需求为背景,让学生运用所学的计算思维和问题解决技巧进行系统设计和开发,并要求他们合理地选择算法和数据结构来优化解决方案。

教学评估方法为了评估学生在计算思维和问题解决能力方面的学习情况,可以采用以下评估方法: - 课堂参与:通过讨论、互动等方式观察学生的思考能力和表达能力。

- 作业与项目评估:通过对学生提交的作业和项目进行评估,检查他们是否正确应用了所学知识和技巧。

- 考试/测试:设立针对计算思维和问题解决能力的考试或测试来全面衡量学生对这一主题的掌握程度。

算法初步实验课教案

算法初步实验课教案

算法初步实验课教案一、教学目标1. 理解算法的基本概念和特点2. 掌握算法的设计方法和分析手段3. 熟练使用编程语言实现算法4. 培养学生的创新能力和团队合作精神二、教学内容1. 算法的基本概念和特点2. 算法的设计方法:递归、分治、贪心、动态规划等3. 算法分析:时间复杂度、空间复杂度4. 常见算法实现:排序、查找、图论算法等5. 算法实验:编程实现并分析给定算法三、教学方法1. 讲授:讲解算法的基本概念、设计方法和分析手段2. 实践:学生动手编程实现算法3. 讨论:分组讨论算法实现过程中遇到的问题和解决方法4. 报告:学生提交算法实验报告,进行分析总结四、教学安排1. 第一课时:算法的基本概念和特点2. 第二课时:算法的设计方法3. 第三课时:算法分析4. 第四课时:常见算法实现5. 第五课时:算法实验及报告五、教学评价1. 课堂参与度:学生提问、回答问题、参与讨论的情况2. 编程实践:学生算法实现的正确性和效率3. 实验报告:学生的分析总结能力和团队合作精神4. 课后作业:巩固所学知识,提高自主学习能力六、教学资源1. 教材:算法导论、计算机算法等2. 编程环境:Python、C++、Java等编程语言及其开发工具3. 网络资源:相关算法论文、开源算法实现等七、教学过程1. 引入:通过生活中的实例引入算法概念,激发学生兴趣2. 讲解:详细讲解算法的基本概念、设计方法和分析手段3. 实践:学生动手编程实现经典算法4. 讨论:分组讨论算法实现过程中遇到的问题和解决方法5. 报告:学生提交算法实验报告,进行分析总结八、教学注意事项1. 关注学生个体差异,因材施教,提供不同难度级别的编程任务2. 强调算法思维,引导学生从问题出发,设计并分析算法3. 注重团队合作,鼓励学生互相学习、互相帮助4. 及时给予学生反馈,提高教学效果九、教学拓展1. 算法竞赛:介绍国内外算法竞赛,鼓励学生参加锻炼能力2. 算法研究:引导学生关注前沿算法研究,培养创新能力3. 实际应用:探讨算法在实际产业中的应用,提高学生算法应用能力十、课后作业1. 复习课堂所学内容,巩固算法基本概念和分析方法2. 完成课后编程练习,加深对算法实现的理解3. 阅读相关算法论文或书籍,拓展算法知识体系4. 结合自身兴趣或实际问题,尝试设计与分析新的算法十一、教学评估1. 课堂问答:评估学生对算法基本概念的理解和掌握程度。

算法导论_实验一 快速排序

算法导论_实验一  快速排序

实验一快速排序1.问题描述:实现对数组的普通快速排序与随机快速排序.2.算法原理:设要排序的数组是A[0]……A[N-1],首先选取一个数据(普通快排选择的是最后一个元素, 随记快排是随机选择一个元素)作为关键数据,然后将所有比它小的数都放到它前面,所有比它大的数都放到它后面,这个过程称为一趟快速排序。

一趟快速排序的算法是:1)设置两个变量i、j,排序开始的时候:i=0,j=N-1;2)以第一个数组元素作为关键数据,赋值给key,即key=A[0];3)从j开始向前搜索,即由后开始向前搜索(j--),找到第一个小于key的值A[j],将A[j]赋给A[i];4)从i开始向后搜索,即由前开始向后搜索(i++),找到第一个大于key的A[i],将A[i]赋给A[j];5)重复第3、4步,直到i=j;(3,4步中,没找到符合条件的值,即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值,使得j=j-1,i=i+1,直至找到为止。

找到符合条件的值,进行交换的时候i,j指针位置不变。

另外,i==j这一过程一定正好是i+或j-完成的时候,此时令循环结束)。

3.实验数据:●输入:首先输入一个n 表示要排序的元素的个数, 然后分别系统会随机生成n 个整数.●输出:输出排序完成后的序列,以及对这n 个数进行排序所花费的时间.4.实验截图:●普通快排随机快排5.结果分析:从理论上而言, 随机快排的时间应该比普通快排的时间短一些, 从程序运行的结果上看, 正如所猜测的那样. 普通快排对10000个随机生成的数字排序花费的时间是1002900us ,随机快排对10000个随机生成的数字排序花费的时间是1000700us6.源代码:普通排序#include <iostream>#include <windows.h>using namespace std;void QUICKSORT(int *array, int start, int end){if(start>=end) return;int x = array[end];int i = start - 1;for (int j = start; j < end; j++){if (x >= array[j]){i++;int t=array[i];array[i]= array[j];array[j]= t;}}int t=array[i+1];array[i+1]= x;array[end]=t;QUICKSORT(array, start, i);QUICKSORT(array, i+2, end);}int main(){int array[10000],n;cout<<"请输入要排序的数字的个数"<<endl;cin>>n;for(int i=0; i<n; i++){array[i]=rand();}FILETIME beg,end;GetSystemTimeAsFileTime(&beg);QUICKSORT(array,0,n-1);GetSystemTimeAsFileTime(&end);for(int i=0;i<n;i++)cout<<array[i]<<" ";cout<<endl<<endl;cout<<"一共"<<n<<" 个数,耗时" << 100*(end.dwLowDateTime-beg.dwLowDateTime) << "us"<<endl;return 0;}随机排序#include <iostream>#include <stdlib.h>#include <windows.h>using namespace std;void QUICKSORT(int *array, int start, int end){if(start>=end) return;int ram=(int)(rand()%(end-start+1))+start;int k=array[ram];array[ram]=array[end];array[end]=k;int x = array[end];int i = start - 1;for (int j = start; j < end; j++){if (x >= array[j]){i++;int t=array[i];array[i]= array[j];array[j]= t;}}int t=array[i+1];array[i+1]= x;array[end]=t;QUICKSORT(array, start, i);QUICKSORT(array, i+2, end);}int main(){int array[10000],n;cout<<"请输入要排序的数字的个数"<<endl;cin>>n;for(int i=0; i<n; i++){array[i]=rand();}FILETIME beg,end;GetSystemTimeAsFileTime(&beg);QUICKSORT(array,0,n-1);GetSystemTimeAsFileTime(&end);for(int i=0;i<n;i++)cout<<array[i]<<" ";cout<<endl<<endl;cout<<"一共"<<n<<" 个数,耗时" << 100*(end.dwLowDateTime-beg.dwLowDateTime) << "us"<<endl;return 0; }。

算法导论课程设计报告_棋盘移动棋子问题

算法导论课程设计报告_棋盘移动棋子问题

一、设计内容与设计要求1.设计内容:对课程《算法导论》中的常用算法进行综合设计或应用(具体课题题目见后面的供选题目)。

2.设计要求:●课程设计报告正文内容(一)问题的描述;(二)算法设计与分析,内容包括1,算法设计,对问题的分析和算法的设计2,算法描述,以伪代码形式的算法3,算法分析,主要是算法的正确性和运行时间的分析(三)算法实现所有程序的原代码,要求用C语言程序实现,并对程序写出必要的注释。

●书写格式a.要求用A4纸打印成册b.正文格式:一级标题用3号黑体,二级标题用四号宋体加粗,正文用小四号宋体;行距为22。

c.正文的内容:正文总字数要求在3000字左右(不含程序原代码)。

G.封面格式如下页。

●考核方式指导老师负责验收程序的运行结果,并结合学生的工作态度、实际动手能力、创新精神和设计报告等进行综合考评,并按优秀、良好、中等、及格和不及格五个等级给出每位同学的课程设计成绩。

具体考核标准包含以下几个部分:a.平时出勤(占10%)b.系统需求分析、功能设计、数据结构设计及程序总体结构合理与否(占10%)c.程序能否完整、准确地运行,个人能否独立、熟练地调试程序(占40%)G.设计报告(占30%)e.独立完成情况(占10%)。

注意:不得抄袭他人的报告(或给他人抄袭),一旦发现,成绩为零分。

课程验收要求a.判定算法设计的合理性,运行相关程序,获得正确的数值结果。

b.回答有关问题。

c.提交课程设计报告。

G.提交软盘(源程序、设计报告文档)。

e.依内容的创新程度,完善程序情况及对程序讲解情况打分。

一、问题描述(一)问题的描述假设有一张n*n个方格的棋盘以及一个棋子。

必须根据以下的规则把棋子从棋盘的底边移动到棋盘的顶边。

在每一步你可以把棋子移动到三个方格中的一个:1) 正上方的方格2) 左上方的方格(只能当这个棋子不在最左列的时候)3) 右上方的方格(只能当这个棋子不在最右列的时候)每移动到一个方格就会得到相应方格内的钱。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

《算法导论》课程实验报告(院)系数理系 _ _____ 专业 ______ _信息与计算科学________ ____ 班级信科1001班学号_ 20 08 15__ 学生姓名刘俊伟_ 曹玮王舒斌指导教师_ 阳卫锋 ______ _____《算法导论》实验指导书实验目标通过实验,使同学掌握并能熟练运用散列表、贪心算法、动态规划算法。

实验三计数排序实验目的:掌握利用计数排序进行排序。

实验内容:对数组利用计数排序进行排序。

实验要求:1)利用计数排序法。

2)记录每一步数组的中元素的变化代码:import java.awt.BorderLayout;import java.awt.Button;import ponent;import java.awt.Frame;import bel;import java.awt.Panel;import java.awt.TextArea;import java.awt.TextField;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.awt.geom.Area;import javax.swing.Box;import javax.swing.JFrame;class CountingSort extends Frame {public static void main(String[] args) {new CountingSort().lauchFrame();}private void lauchFrame() {Frame f = new JFrame("计数排序");f.setBounds(350, 150, 600, 300);Box horizontal = Box.createHorizontalBox();Box vertical = Box.createVerticalBox();final TextField tf = new TextField(50);Button button = new Button("排序");final TextArea ta = new TextArea();horizontal.add(tf);horizontal.add(button);vertical.add(ta);f.add(horizontal, BorderLayout.NORTH);f.add(vertical);tf.setText("请输入数字,以空格隔开");button.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { String str1 = tf.getText();if(str1.startsWith(" ")) {ta.setText("请按正确的格式输入!!!");try {Thread.sleep(10000);} catch (InterruptedException e1) {e1.printStackTrace();}System.exit(-1);}int[] a = new CountingSort().getArr(str1);Sort s = new Sort(a);s.method(s.getK(a));int[] b = s.getB();String str2 = " ";for(int i = 0; i < b.length; i++) {str2 = str2 + b[i] + " ";}str1 = "排序前:" + str1;str2 = "排序后:" + str2;ta.setText(str1 + "\n" +str2);}});f.setVisible(true);}private int[] getArr(String str) {String[] strArr = str.split(" ");int[] a = new int[strArr.length];for (int i = 0; i < strArr.length; i++) { a[i] = Integer.valueOf(strArr[i]);}return a;}}package com.algorithm1;class Sort //计数排序类 {private int[] c;//计数数组private int[] b;//通过计数排序之后的数组private int[] a;//原数组Sort(int[] a) {this.a = a;b = new int[a.length];}public void method(int k) {int[] c = new int[k+1];for (int i = 0; i < k ; i++ ) {c[i] = 0;}for (int j = 0; j < a.length ; j++ ) {c[a[j]] = c[a[j]] + 1;}for (int i = 1; i <= k ; i++ ) {c[i] = c[i] + c[i-1];}for (int j = a.length -1; j >= 0 ; j-- ) {b[c[a[j]]-1] = a[j];c[a[j]] = c[a[j]] - 1;}}public int getK(int[] a)//获取K值 {int k = a[0];//假设a[0]是最大值for (int i = 1 ; i < a.length ; i++ ) {if (k < a[i]) {k = a[i];}}return k;}public int[] getB() {return b;}}运行结果:实验四动态规划程序设计实验目的:掌握并实现动态规划算法。

实验内容:对比如维数为序列(5,10,3,12,5,50,6)的各矩阵。

找出其矩阵链乘的一个最优加全括号。

实验要求:利用动态规划思想写出算法的伪代码和C程序代码代码:public class MatrixMulitply {public static void main(String[] args) {int[] matrixChain = {25, 15, 15, 5, 10, 20, 25};matrixMultiply(matrixChain);} //矩阵连乘public static void matrixMultiply(int[] matrixChain) {int dimension = matrixChain.length;int[][] timeResult = new int[dimension][dimension];int[][] tagResult = new int[dimension][dimension];matrixMultiply(matrixChain, timeResult, tagResult);System.out.println("划分规则为:");traceBack(tagResult, 1, dimension - 1);} //矩阵连乘public static void matrixMultiply(int[] matrixChain, int[][] timeResult, int[][] tagResult) {//timeResult 存放次数结果,矩阵的的行与列以1开始,tagResult 存放标记结果,矩阵的的行与列以1开始int n = matrixChain.length - 1;for(int i = 1; i <= n; i++) //初始化矩阵timeResult[i][i] = 0;for(int r = 2; r <= n; r++) //从列号的第二位开始for(int i = 1; i <= n - r + 1; i++ ) { //i为行号int j = i + r - 1; //j为列号timeResult[i][j] = timeResult[i + 1][j] + matrixChain[i - 1] * matrixChain[i] * matrixChain[j];tagResult[i][j] = i;for(int k = i + 1; k < j; k++) {int temp = timeResult[i][k] + timeResult[k + 1][j]+ matrixChain[i - 1] * matrixChain[k] * matrixChain[j];if(temp < timeResult[i][j]) { //寻找最小值timeResult[i][j] = temp;tagResult[i][j] = k; //记录划分标记}}}} //按计算出断点矩阵tagResult指示的加括号方式public static void traceBack(int[][] tagResult, int i, int j) { if(i == j) return;traceBack(tagResult, i, tagResult[i][j]);traceBack(tagResult, tagResult[i][j] + 1, j);System.out.println("Multiply A(" + i + "," + tagResult[i][j] + ")and A(" + (tagResult[i][j] + 1) + "," + j + ")");}}运行结果:实验五贪心算法程序设计实验目的:掌握贪心算法。

实验内容:设n是一个正整数。

现在要求将n分解为若干个互不相同的自然数的和,且使这些自然数的乘积最大。

对于给定的正整数n,编程计算最优分解方案。

实验要求:利用贪心算法思想写出算法的伪代码和C程序代码。

代码:import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;public class TanXin {public int N = this.GetN();public int[] A = new int[100];// 取得用户需要实现算法的一个正整数public int GetN() {int dvalue = 0;String value;System.out.print("请输入一个正整数: ");BufferedReader bfr = new BufferedReader(new InputStreamReader(System.in));try {value = bfr.readLine();dvalue = Integer.parseInt(value);//如果输入的不是数字,系统自动退出,并提示:“输入正确的数值!”。

相关文档
最新文档