算法实验报告二

合集下载

算法实验报告

算法实验报告

实验一分治与递归算法的应用一、实验目的1.掌握分治算法的基本思想(分-治-合)、技巧和效率分析方法。

2.熟练掌握用递归设计分治算法的基本步骤(基准与递归方程)。

3.学会利用分治算法解决实际问题。

二 . 实验内容金块问题老板有一袋金块(共n块,n是2的幂(n≥2)),最优秀的雇员得到其中最重的一块,最差的雇员得到其中最轻的一块。

假设有一台比较重量的仪器,希望用最少的比较次数找出最重和最轻的金块。

并对自己的程序进行复杂性分析。

三.问题分析:一般思路:假设袋中有n 个金块。

可以用函数M a x(程序1 - 3 1)通过n-1次比较找到最重的金块。

找到最重的金块后,可以从余下的n-1个金块中用类似法通过n-2次比较找出最轻的金块。

这样,比较的总次数为2n-3。

分治法:当n很小时,比如说,n≤2,识别出最重和最轻的金块,一次比较就足够了。

当n 较大时(n>2),第一步,把这袋金块平分成两个小袋A和B。

第二步,分别找出在A和B中最重和最轻的金块。

设A中最重和最轻的金块分别为HA 与LA,以此类推,B中最重和最轻的金块分别为HB 和LB。

第三步,通过比较HA 和HB,可以找到所有金块中最重的;通过比较LA 和LB,可以找到所有金块中最轻的。

在第二步中,若n>2,则递归地应用分而治之方法程序设计据上述步骤,可以得出程序1 4 - 1的非递归代码。

该程序用于寻找到数组w [ 0 : n - 1 ]中的最小数和最大数,若n < 1,则程序返回f a l s e,否则返回t r u e。

当n≥1时,程序1 4 - 1给M i n和M a x置初值以使w [ M i n ]是最小的重量,w [ M a x ]为最大的重量。

首先处理n≤1的情况。

若n>1且为奇数,第一个重量w [ 0 ]将成为最小值和最大值的候选值,因此将有偶,数个重量值w [ 1 : n - 1 ]参与f o r循环。

当n 是偶数时,首先将两个重量值放在for 循环外进行比较,较小和较大的重量值分别置为Min和Max,因此也有偶数个重量值w[2:n-1]参与for循环。

算法实验报告

算法实验报告

算法实验报告算法实验报告引言:算法是计算机科学的核心内容之一,它是解决问题的方法和步骤的描述。

算法的设计和分析是计算机科学与工程中的重要研究方向之一。

本实验旨在通过对算法的实际应用和实验验证,深入理解算法的性能和效果。

实验一:排序算法的比较在本实验中,我们将比较三种常见的排序算法:冒泡排序、插入排序和快速排序。

我们将通过对不同规模的随机数组进行排序,并记录每种算法所需的时间和比较次数,以评估它们的性能。

实验结果显示,快速排序是最快的排序算法,其时间复杂度为O(nlogn),比较次数也相对较少。

插入排序的时间复杂度为O(n^2),比较次数较多,但对于小规模的数组排序效果较好。

而冒泡排序的时间复杂度也为O(n^2),但比较次数更多,效率相对较低。

实验二:图的最短路径算法在图的最短路径问题中,我们将比较Dijkstra算法和Floyd-Warshall算法的效率和准确性。

我们将使用一个带权有向图,并计算从一个顶点到其他所有顶点的最短路径。

实验结果表明,Dijkstra算法适用于单源最短路径问题,其时间复杂度为O(V^2),其中V为顶点数。

而Floyd-Warshall算法适用于多源最短路径问题,其时间复杂度为O(V^3)。

两种算法在准确性上没有明显差异,但在处理大规模图时,Floyd-Warshall算法的效率较低。

实验三:动态规划算法动态规划是一种通过将问题分解成子问题并记录子问题的解来解决复杂问题的方法。

在本实验中,我们将比较两种动态规划算法:0-1背包问题和最长公共子序列问题。

实验结果显示,0-1背包问题的动态规划算法可以有效地找到最优解,其时间复杂度为O(nW),其中n为物品个数,W为背包容量。

最长公共子序列问题的动态规划算法可以找到两个序列的最长公共子序列,其时间复杂度为O(mn),其中m和n分别为两个序列的长度。

结论:通过本次实验,我们对不同算法的性能和效果有了更深入的了解。

排序算法中,快速排序是最快且效率最高的;在图的最短路径问题中,Dijkstra算法和Floyd-Warshall算法分别适用于不同的场景;动态规划算法可以解决复杂的问题,并找到最优解。

实验二时间片轮转算法实验报告

实验二时间片轮转算法实验报告

实验二时间片轮转算法实验报告一、实验目的本次实验的主要目的是了解时间片轮转算法的工作原理,学习如何使用时间片轮转算法进行进程调度,并了解时间片大小对进程调度的影响。

二、实验原理时间片轮转算法是一种公平的进程调度算法,它采用循环队列的形式,将所有需要运行的进程按照到达时间排序,并将它们按照轮转的方式依次执行,每个进程在一个时间片内执行一定的时间(时间片大小),然后被暂停并放在队列的末尾等待下一次调度。

当一个进程的时间片用完后,它会被暂停并放在队列的最后,而在这个时间片内没有执行完的进程会被暂停并放到队列的开头,以便继续下一轮的运行。

这样一直循环下去,直到所有进程都运行完毕。

三、实验步骤1.设定进程数量和时间片大小。

2.定义进程结构体,包括进程ID、到达时间、服务时间、剩余时间等信息。

3.初始化所有进程,并按照到达时间排序。

4.创建一个循环队列,并将所有已到达的进程入队。

5.按照时间片大小循环执行以下步骤:a.从队列中取出一个进程,执行一次时间片大小的时间。

b.更新队列中所有进程的剩余时间。

c.如果剩余时间大于0,将进程放入队尾。

d.如果剩余时间等于0,表示进程执行完毕,将其从队列中移除。

e.输出每个时间片的调度情况。

6.统计平均等待时间和平均周转时间,并输出结果。

四、实验结果本次实验我们设置了4个进程,并且时间片大小为3、以下是每个时间片的调度情况:时间片1:进程1执行,剩余时间为2时间片2:进程2执行,剩余时间为4时间片3:进程3执行,剩余时间为5时间片4:进程1执行,剩余时间为1时间片5:进程2执行,剩余时间为3时间片6:进程3执行,剩余时间为4时间片7:进程4执行,剩余时间为2时间片8:进程1执行,剩余时间为0,进程1执行完毕时间片9:进程2执行,剩余时间为2时间片10:进程3执行,剩余时间为3时间片11:进程4执行,剩余时间为1时间片12:进程2执行,剩余时间为1时间片13:进程3执行,剩余时间为2时间片14:进程4执行,剩余时间为0,进程4执行完毕时间片15:进程2执行,剩余时间为0,进程2执行完毕时间片16:进程3执行,剩余时间为1时间片17:进程3执行,剩余时间为0根据以上调度情况,我们可以计算出平均等待时间和平均周转时间。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

- 编写贪心算法的代码。

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

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

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

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

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

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

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

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

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

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

实验二:图形填充算法实验报告

实验二:图形填充算法实验报告

《计算机图形学》实验报告(实验二:图形填充算法)一、实验目的及要求用两种方法做图形的填充算法!二、理论基础1.边填充算法对于每一条扫描线和每条多边形的交点(x1,y1),将该扫描线上的交点右方的所有像素取补。

2.种子填充算法利用栈来实现种子填充算法。

种子像素入栈,当栈非空时重复执行如下步骤:将栈顶像素出栈,将出栈像素置成多边形色,按左,上,右,下顺序检查与出栈像素相邻的四个像素,若其中某个像素不再边界且未置成多边形,则把该像素入栈!三、算法设计与分析1、边填充算法void CEdge_mark_fillView::OnDraw(CDC* pDC){CEdge_mark_fillDoc* pDoc = GetDocument();ASSERT_V ALID(pDoc);int d[500][500]={0};int inside;int x,y;Bresenham(80,101,100,400,d);Bresenham(100,300,290,400,d);Bresenham(292,400,382,50,d);Bresenham(380,50,202,150,d);Bresenham(200,150,82,101,d);for(y=0;y<500;y++){inside=0;for(x=0;x<500;x++){if(d[x][y]==1)if(d[x+1][y]!=1){inside=!(inside);}if(inside!=0)pDC->SetPixel(x,y,12);}}}2、种子填充int x=299,y=51;COLORREF oldcolor;COLORREF newcolor;oldcolor=RGB(256,256,256);newcolor=RGB(123,123,123);pDC->MoveTo (40,40);pDC->LineTo (80,40);pDC->LineTo (70,80);pDC->LineTo (40,40);FloodFill(51,51,RGB(255,255,255),RGB(0,0,255));pDC->LineTo (40,40);void CMyView::FloodFill(int x,int y,COLORREF oldcolor,COLORREF newcolor) {CDC* pDC;pDC=GetDC();if(pDC->GetPixel(x,y)==oldcolor){pDC->SetPixel(x,y,newcolor);FloodFill(x,y-1,oldcolor,newcolor);FloodFill(x,y+1,oldcolor,newcolor);FloodFill(x-1,y,oldcolor,newcolor);FloodFill(x+1,y,oldcolor,newcolor);}四、程序调试及结果的分析1、2、四、实验心得及建议由于很多不会,所以这次没能按时当堂完成,下来花了不少时间才弄出来,第二种尤其比较麻烦,在同学的帮助下才做出来了。

算法设计与分析实验报告

算法设计与分析实验报告

算法设计与分析实验报告实验一全排列、快速排序【实验目的】1. 掌握全排列的递归算法。

2. 了解快速排序的分治算法思想。

【实验原理】一、全排列全排列的生成算法就是对于给定的字符集,用有效的方法将所有可能的全排列无重复无遗漏地枚举出来。

任何n个字符集的排列都可以与1~n的n个数字的排列一一对应,因此在此就以n 个数字的排列为例说明排列的生成法。

n个字符的全体排列之间存在一个确定的线性顺序关系。

所有的排列中除最后一个排列外,都有一个后继;除第一个排列外,都有一个前驱。

每个排列的后继都可以从它的前驱经过最少的变化而得到,全排列的生成算法就是从第一个排列开始逐个生成所有的排列的方法。

二、快速排序快速排序(Quicksort)是对冒泡排序的一种改进。

它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。

【实验内容】1.全排列递归算法的实现。

2.快速排序分治算法的实现。

【实验结果】1. 全排列:2. 快速排序:实验二最长公共子序列、活动安排问题【实验目的】1. 了解动态规划算法设计思想,运用动态规划算法实现最长公共子序列问题。

2. 了解贪心算法思想,运用贪心算法设计思想实现活动安排问题。

【实验原理】一、动态规划法解最长公共子序列设序列X=和Y=的一个最长公共子序列Z=,则:i. 若xm=yn,则zk=xm=yn且Zk-1是Xm-1和Yn-1的最长公共子序列;ii. 若xm≠yn且zk≠xm ,则Z是Xm-1和Y的最长公共子序列;iii. 若xm≠yn且z k≠yn ,则Z是X和Yn-1的最长公共子序列。

其中Xm-1=,Yn-1=,Zk-1=。

最长公共子序列问题具有最优子结构性质。

由最长公共子序列问题的最优子结构性质可知,要找出X=和Y=的最长公共子序列,可按以下方式递归地进行:当xm=yn时,找出Xm-1和Yn-1的最长公共子序列,然后在其尾部加上xm(=yn)即可得X和Y的一个最长公共子序列。

《算法设计与分析》课程实验报告 (回溯法(二))

《算法设计与分析》课程实验报告 (回溯法(二))

《算法设计与分析》课程实验报告实验序号:10实验项目名称:实验十一回溯法(二)一、实验题目1.图的着色问题问题描述:给定无向连通图G和m种不同的颜色。

用这些颜色为图G的各顶点着色,每个顶点着一种颜色。

如果有一种着色法使G中每条边的2个顶点着不同颜色,则称这个图是m可着色的。

图的m着色问题是对于给定图G和m种颜色,找出所有不同的着色法。

2.旅行商问题问题描述:给出一个n个顶点的带权无向图,请寻找一条从顶点1出发,遍历其余顶点一次且仅一次、最后回到顶点1的最小成本的回路——即最短Hamilton回路。

3.拔河比赛问题描述:某公司的野餐会上将举行一次拔河比赛。

他们想把参与者们尽可能分为实力相当的两支队伍。

每个人都必须在其中一只队伍里,两队的人数差距不能超过一人,且两队的队员总体重应该尽量接近。

4.批处理作业调度问题描述:给定n个作业的集合J=(J1,J2, .. Jn)。

每个作业J都有两项任务分别在两台机器上完成。

每个作业必须先由机器1处理,再由机器2处理。

作业i需要机器j的处理时间为tji(i=1,2, ..n; j=1,2)。

对于一个确定的作业调度,设Fji是作业i在机器j上完成处理的时间,则所有作业在机器2上完成处理的时间和,称为该作业调度的完成时间和。

批处理作业调度问题要求,对于给定的n个作业,制定最佳作业调度方案,使其完成时间和达到最小。

二、实验目的(1)通过练习,理解回溯法求解问题的解状态空间树与程序表达的对应关系,熟练掌握排列树、子集树的代码实现。

(2)通过练习,体会减少搜索解空间中节点的方法,体会解的状态空间树的组织及上界函数的选取对搜索的影响。

(3)通过练习,深入理解具体问题中提高回溯算法效率的方法。

(4)(选做题):在掌握回溯法的基本框架后,重点体会具体问题中解的状态空间搜索时的剪枝问题。

三、实验要求(1)每题都必须实现算法、设计测试数据、记录实验结果,并给出时间复杂度分析。

四、实验过程(算法设计思想、源码)1.图的着色问题(1)算法设计思想用邻接矩阵a[i][j]存储无向图,对于每一个顶点有m种颜色可以涂。

算法设计与分析实验报告

算法设计与分析实验报告

实验一找最大和最小元素与归并分类算法实现(用分治法)一、实验目的1.掌握能用分治法求解的问题应满足的条件;2.加深对分治法算法设计方法的理解与应用;3.锻炼学生对程序跟踪调试能力;4.通过本次实验的练习培养学生应用所学知识解决实际问题的能力。

二、实验内容1、找最大和最小元素输入n 个数,找出最大和最小数的问题。

2、归并分类将一个含有n个元素的集合,按非降的次序分类(排序)。

三、实验要求(1)用分治法求解问题(2)上机实现所设计的算法;四、实验过程设计(算法设计过程)1、找最大和最小元素采用分治法,将数组不断划分,进行递归。

递归结束的条件为划分到最后若为一个元素则max和min都是这个元素,若为两个取大值赋给max,小值给min。

否则就继续进行划分,找到两个子问题的最大和最小值后,比较这两个最大值和最小值找到解。

2、归并分类使用分治的策略来将一个待排序的数组分成两个子数组,然后递归地对子数组进行排序,最后将排序好的子数组合并成一个有序的数组。

在合并过程中,比较两个子数组的首个元素,将较小的元素放入辅助数组,并指针向后移动,直到将所有元素都合并到辅助数组中。

五、源代码1、找最大和最小元素#include<iostream>using namespace std;void MAXMIN(int num[], int left, int right, int& fmax, int& fmin); int main() {int n;int left=0, right;int fmax, fmin;int num[100];cout<<"请输入数字个数:";cin >> n;right = n-1;cout << "输入数字:";for (int i = 0; i < n; i++) {cin >> num[i];}MAXMIN(num, left, right, fmax, fmin);cout << "最大值为:";cout << fmax << endl;cout << "最小值为:";cout << fmin << endl;return 0;}void MAXMIN(int num[], int left, int right, int& fmax, int& fmin) { int mid;int lmax, lmin;int rmax, rmin;if (left == right) {fmax = num[left];fmin = num[left];}else if (right - left == 1) {if (num[right] > num[left]) {fmax = num[right];fmin = num[left];}else {fmax = num[left];fmin = num[right];}}else {mid = left + (right - left) / 2;MAXMIN(num, left, mid, lmax, lmin);MAXMIN(num, mid+1, right, rmax, rmin);fmax = max(lmax, rmax);fmin = min(lmin, rmin);}}2、归并分类#include<iostream>using namespace std;int num[100];int n;void merge(int left, int mid, int right) { int a[100];int i, j,k,m;i = left;j = mid+1;k = left;while (i <= mid && j <= right) {if (num[i] < num[j]) {a[k] = num[i++];}else {a[k] = num[j++];}k++;}if (i <= mid) {for (m = i; m <= mid; m++) {a[k++] = num[i++];}}else {for (m = j; m <= right; m++) {a[k++] = num[j++];}}for (i = left; i <= right; i++) { num[i] = a[i];}}void mergesort(int left, int right) { int mid;if (left < right) {mid = left + (right - left) / 2;mergesort(left, mid);mergesort(mid + 1, right);merge(left, mid, right);}}int main() {int left=0,right;int i;cout << "请输入数字个数:";cin >> n;right = n - 1;cout << "输入数字:";for (i = 0; i < n; i++) {cin >> num[i];}mergesort(left,right);for (i = 0; i < n; i++) {cout<< num[i];}return 0;}六、运行结果和算法复杂度分析1、找最大和最小元素图1-1 找最大和最小元素结果算法复杂度为O(logn)2、归并分类图1-2 归并分类结果算法复杂度为O(nlogn)实验二背包问题和最小生成树算法实现(用贪心法)一、实验目的1.掌握能用贪心法求解的问题应满足的条件;2.加深对贪心法算法设计方法的理解与应用;3.锻炼学生对程序跟踪调试能力;4.通过本次实验的练习培养学生应用所学知识解决实际问题的能力。

常见算法设计实验报告(3篇)

常见算法设计实验报告(3篇)

第1篇一、实验目的通过本次实验,掌握常见算法的设计原理、实现方法以及性能分析。

通过实际编程,加深对算法的理解,提高编程能力,并学会运用算法解决实际问题。

二、实验内容本次实验选择了以下常见算法进行设计和实现:1. 排序算法:冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序。

2. 查找算法:顺序查找、二分查找。

3. 图算法:深度优先搜索(DFS)、广度优先搜索(BFS)、最小生成树(Prim算法、Kruskal算法)。

4. 动态规划算法:0-1背包问题。

三、实验原理1. 排序算法:排序算法的主要目的是将一组数据按照一定的顺序排列。

常见的排序算法包括冒泡排序、选择排序、插入排序、快速排序、归并排序和堆排序等。

2. 查找算法:查找算法用于在数据集中查找特定的元素。

常见的查找算法包括顺序查找和二分查找。

3. 图算法:图算法用于处理图结构的数据。

常见的图算法包括深度优先搜索(DFS)、广度优先搜索(BFS)、最小生成树(Prim算法、Kruskal算法)等。

4. 动态规划算法:动态规划算法是一种将复杂问题分解为子问题,通过求解子问题来求解原问题的算法。

常见的动态规划算法包括0-1背包问题。

四、实验过程1. 排序算法(1)冒泡排序:通过比较相邻元素,如果顺序错误则交换,重复此过程,直到没有需要交换的元素。

(2)选择排序:每次从剩余元素中选取最小(或最大)的元素,放到已排序序列的末尾。

(3)插入排序:将未排序的数据插入到已排序序列中适当的位置。

(4)快速排序:选择一个枢纽元素,将序列分为两部分,使左侧不大于枢纽,右侧不小于枢纽,然后递归地对两部分进行快速排序。

(5)归并排序:将序列分为两半,分别对两半进行归并排序,然后将排序好的两半合并。

(6)堆排序:将序列构建成最大堆,然后重复取出堆顶元素,并调整剩余元素,使剩余元素仍满足最大堆的性质。

2. 查找算法(1)顺序查找:从序列的第一个元素开始,依次比较,直到找到目标元素或遍历完整个序列。

算法实验报告(完美版)

算法实验报告(完美版)

实验报告实验一:一、实验名称二分搜索法二、实验目的编写程序实现用二分法在一有序序列中查找一个数三、实验内容1、程序源代码#include<stdio.h>int Research(int a[],int x,int n){int left=0,right=n-1,mid;if(n>0&&x>=a[0]){while(left<right){mid=(left+right+1)/2;if(x<a[mid])right=mid-1;elseleft=mid;}if(x==a[left])return left;}return -1;}void Input(){int a[30],n,i,j,x;printf("输入数组长度n :");scanf("%d",&n);printf("输入有序数组:\n\n");for(i=0;i<n;i++){printf("a[%d]:",i);scanf("%d",&a[i]);}printf("输入要查询的数字:");scanf("%d",&x);j=Research(a,x,n);if(j>=0)printf("%d 在数组中的下标为%d!\n\n",x,j);elseprintf("没找到!\n\n");}main(){Input();}运行结果图一图二实验心得:本次实验让我了解了二分搜索法的基本思想,同时我们应该注意二分搜索法必须是在有序的元素中进行,不能在无序的元素中使用。

快速排序:#include<iostream>using namespace std;#define MAXSIZE 100int Partition(int q[MAXSIZE],int low,int hight);void Qsort(int q[],int low,int hight);int main(){int q[MAXSIZE]; //存储数列的数组q[0]=0;int n=0;cout<<"请输入需要排序的数的个数:";cin>>n;cout<<"\n请输入需要排序的数:\n";for(int i=1;i<=n;i++) //用循环方式输入数列{cin>>q[i];}Qsort(q,1,n); //调用Partition()函数cout<<"\n排序后结果为:\n";for(i=1;i<=n;i++) //循环输出结果{cout<<q[i]<<" ";}cout<<endl;return 0;}int Partition(int q[MAXSIZE],int low,int high) //对数列及数列部分划分成高低两个部分{int pivotkey; //用于标记q[low]这个关键数q[0]=q[low]; //q[0]用于存储q[low]这个数,q[low]空出pivotkey=q[low];while(low<high) //判断长度是否大于1{while(low<high && q[high]>=pivotkey)high--;q[low]=q[high]; //当pivotkey的值大于q[high],将q[high]放入q[low]中,q[high]空出while(low<high && q[low]<=pivotkey)low++;q[high]=q[low]; //当pivotkey的值小于q[low],将q[low]放入q[high]中,q[low]空出}q[low]=q[0]; //将q[0]中存储的数放入它合适的位置return low;}void Qsort(int q[MAXSIZE],int low,int high){int pivotkey; //记录关键数上一次排序后的位子if(low<high){pivotkey=Partition(q,low,high);Qsort(q,low,pivotkey-1); //对比关键数小的数(左侧)排序Qsort(q,pivotkey+1,high); //对比关键数大的数(右侧)排序}}运行结果:实验总结:在实验过程中,我只考虑了对数进行排序,没有其他的指针,所以就直接用了int型的数组。

实验二银行家算法实验报告

实验二银行家算法实验报告

实验二银行家算法实验报告一、实验目的通过本次实验,主要学习了解了银行家算法的原理和实现方式,掌握银行家算法的应用场景,了解了安全序列的概念和判断方法,并通过代码实现加深对银行家算法的理解和掌握。

二、实验过程1、阅读银行家算法的相关理论知识。

2、编写银行家算法的代码实现。

3、根据实验要求,设置不同的初始资源分配和不同的进程请求资源情况,分别计算是否存在安全序列。

三、实验结果与分析1、首先按照实验要求设置一个初始的资源分配情况:可用的资源数目:4 4 4进程数目:4各进程对三种资源的最初需要数目:Max:7 5 33 2 29 0 22 2 2已分配资源数目:Allocation:0 1 02 0 03 0 22 1 1剩余资源数目:Need: 7 4 31 2 26 0 00 1 1根据上述数据,计算出该初试分配情况下的安全序列为:1 -> 3 -> 4 -> 2。

2、然后设置一个进程请求资源的情况:进程 1 请求资源 [3,3,0],进程 2 请求资源 [1,0,1],进程 3 请求资源 [2,2,0],进程 4 请求资源 [0,0,2]。

根据银行家算法,先进行安全性检测,发现该系统不存在安全序列,因此不满足银行家算法的要求,请求不被满足。

3、接着修改初始的资源分配情况和请求的资源情况,进行比较:通过以上的实验操作,得出结论:只有当请求的资源不会导致系统不再安全时,才会满足请求。

银行家算法基于这个假设进行运算,它管理着一个可以分配的表格,该表格显示系统的各种资源已经分配和未分配的情况,并确定哪些进程可以分配资源,哪些不可以。

四、实验总结本次实验通过对银行家算法的概念、原理和应用场景的了解,对该算法有了更深的认识和理解,并通过代码实现和实验操作,进一步巩固和掌握了该算法的应用方法。

在实验过程中,也有一些需要注意的问题:如需要按照一定的顺序输入原数据,正确地计算资源分配和剩余情况;核实每个请求的资源数目是否足够,才进行安全性检测;注意计算过程中数值的准确性和解题思路的正确性等。

关于算法的实验报告(3篇)

关于算法的实验报告(3篇)

第1篇一、实验目的1. 理解快速排序算法的基本原理和实现方法。

2. 掌握快速排序算法的时间复杂度和空间复杂度分析。

3. 通过实验验证快速排序算法的效率。

4. 提高编程能力和算法设计能力。

二、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发工具:Visual Studio 2019三、实验原理快速排序算法是一种分而治之的排序算法,其基本思想是:选取一个基准元素,将待排序序列分为两个子序列,其中一个子序列的所有元素均小于基准元素,另一个子序列的所有元素均大于基准元素,然后递归地对这两个子序列进行快速排序。

快速排序算法的时间复杂度主要取决于基准元素的选取和划分过程。

在平均情况下,快速排序的时间复杂度为O(nlogn),但在最坏情况下,时间复杂度会退化到O(n^2)。

四、实验内容1. 快速排序算法的代码实现2. 快速排序算法的时间复杂度分析3. 快速排序算法的效率验证五、实验步骤1. 设计快速排序算法的C++代码实现,包括以下功能:- 选取基准元素- 划分序列- 递归排序2. 编写主函数,用于生成随机数组和测试快速排序算法。

3. 分析快速排序算法的时间复杂度。

4. 对不同规模的数据集进行测试,验证快速排序算法的效率。

六、实验结果与分析1. 快速排序算法的代码实现```cppinclude <iostream>include <vector>include <cstdlib>include <ctime>using namespace std;// 生成随机数组void generateRandomArray(vector<int>& arr, int n) {srand((unsigned)time(0));for (int i = 0; i < n; ++i) {arr.push_back(rand() % 1000);}}// 快速排序void quickSort(vector<int>& arr, int left, int right) { if (left >= right) {return;}int i = left;int j = right;int pivot = arr[(left + right) / 2]; // 选取中间元素作为基准 while (i <= j) {while (arr[i] < pivot) {i++;}while (arr[j] > pivot) {j--;}if (i <= j) {swap(arr[i], arr[j]);i++;j--;}}quickSort(arr, left, j);quickSort(arr, i, right);}int main() {int n = 10000; // 测试数据规模vector<int> arr;generateRandomArray(arr, n);clock_t start = clock();quickSort(arr, 0, n - 1);clock_t end = clock();cout << "排序用时:" << double(end - start) / CLOCKS_PER_SEC << "秒" << endl;return 0;}```2. 快速排序算法的时间复杂度分析根据实验结果,快速排序算法在平均情况下的时间复杂度为O(nlogn),在最坏情况下的时间复杂度为O(n^2)。

des算法的实验报告

des算法的实验报告

des算法的实验报告DES算法实验报告DES(Data Encryption Standard)算法是一种对称密钥加密算法,广泛应用于信息安全领域。

本实验旨在通过实验DES算法的加密和解密过程,以及密钥长度对加密效果的影响,来深入了解DES算法的原理和应用。

实验一:加密和解密过程首先,我们使用一个明文进行加密实验。

选择一个64位的明文作为输入,同时使用一个64位的密钥进行加密。

经过DES算法加密后,得到的密文长度也为64位。

然后,我们使用相同的密钥对密文进行解密,得到原始的明文。

实验结果表明,DES算法能够对明文进行有效的加密,并且使用相同的密钥能够对密文进行解密,得到原始的明文。

这说明DES算法是一种可靠的加密算法,能够保护数据的安全性。

实验二:密钥长度对加密效果的影响在第二个实验中,我们对不同长度的密钥进行加密实验,观察加密效果的变化。

我们分别使用56位、64位和128位的密钥进行加密,然后比较不同长度密钥的加密效果。

实验结果显示,密钥长度对加密效果有显著影响。

使用128位的密钥进行加密,能够得到更加安全的密文,而使用56位的密钥进行加密,则容易受到攻击。

这表明密钥长度是影响DES算法加密效果的重要因素。

结论通过本实验,我们深入了解了DES算法的加密和解密过程,以及密钥长度对加密效果的影响。

DES算法是一种可靠的加密算法,能够有效保护数据的安全性。

同时,密钥长度对加密效果有显著影响,因此在实际应用中需要选择足够长度的密钥来保障数据的安全。

总之,DES算法在信息安全领域有着重要的应用价值,通过本实验的学习,我们对DES算法有了更深入的了解,为进一步研究和应用提供了重要的参考。

实验报告二 进程调度算法

实验报告二 进程调度算法

实验报告二——进程调度算法的设计姓名: xxxx 学号: xxxxx班级: xxxx一、实习内容•实现短进程优先调度算法(SPF)•实现时间片轮转调度算法(RR)二、实习目的•通过对进程调度算法的设计, 深入理解进程调度的原理。

进程是程序在一个数据集合上运行的过程, 它是系统进行资源分配和调度的一个独立单位。

进程调度分配处理机, 是控制协调进程对CPU的竞争, 即按一定的调度算法从就绪队列中选中一个进程, 把CPU的使用权交给被选中的进程。

三、实习题目• 1.先来先服务(FCFS)调度算法原理: 每次调度是从就绪队列中, 选择一个最先进入就绪队列的进程, 把处理器分配给该进程, 使之得到执行。

该进程一旦占有了处理器, 它就一直运行下去, 直到该进程完成或因发生事件而阻塞, 才退出处理器。

将用户作业和就绪进程按提交顺序或变为就绪状态的先后排成队列, 并按照先来先服务的方式进行调度处理, 是一种最普遍和最简单的方法。

它优先考虑在系统中等待时间最长的作业, 而不管要求运行时间的长短。

按照就绪进程进入就绪队列的先后次序进行调度, 简单易实现, 利于长进程, CPU繁忙型作业, 不利于短进程, 排队时间相对过长。

• 2.时间片轮转调度算法RR原理: 时间片轮转法主要用于进程调度。

采用此算法的系统, 其程序就绪队列往往按进程到达的时间来排序。

进程调度按一定时间片(q)轮番运行各个进程.进程按到达时间在就绪队列中排队, 调度程序每次把CPU分配给就绪队列首进程使用一个时间片, 运行完一个时间片释放CPU, 排到就绪队列末尾参加下一轮调度, CPU分配给就绪队列的首进程。

固定时间片轮转法:1 所有就绪进程按FCFS 规则排队。

2 处理机总是分配给就绪队列的队首进程。

3 如果运行的进程用完时间片, 则系统就把该进程送回就绪队列的队尾, 重新排队。

4 因等待某事件而阻塞的进程送到阻塞队列。

5 系统把被唤醒的进程送到就绪队列的队尾。

RSA加密算法实验报告_2

RSA加密算法实验报告_2

现代密码学实验报告题目: RSA算法的实现过程
一、实验目的
二、简单实现RSA过程, 通过OpenSSL命令编辑器实现发送方对明文进行加
密, 签名, 接受方验证, 解密的简单过程。

三、实验原理
RSA加密算法的基本流程:
四、实验步骤
发送方对明文进行加密:
首先利用MD5对明文进行摘要操作:
然后生成秘钥文件:
再利用这个密钥对摘要进行加密:
然后对摘要进行签名操作:
发送方加密后要发送的东西是: 明文和摘要的签名传送到接收方后,接收方进行解密操作:
接收方进行验证:
通过比较可以发现所得摘要的结果是相同的, 则可以得到结论: 该明文没有被篡改。

五、实验心得
通过对RSA过程的简单模仿, 我们可以明白理论和现实是有一定差别的, 我们需要将明文利用MD5进行摘要处理, 然后在通过MD5对摘要进行验证, 从而判断密文是否经过修改, 达到数据的安全性, 完整性和保密性。

在使用OpenSSL进行RSA过程模仿时要注意文件名的对应, 这需要我们在命名文件时能做到见名之意, 方便我们后续的操作。

命令行的书写方式需要我们对字母有一定的敏感性, 经常会出现字母出现问题而导致错误的发生。

算法分析与设计实验报告 完整版

算法分析与设计实验报告 完整版

《算法分析与设计》课程实验实验报告专业:计算机科学与技术班级:姓名:学号:完成时间:2009年6月15日实验一算法实现一一、实验目的与要求熟悉C/C++语言的集成开发环境;通过本实验加深对分治法、贪心算法的理解。

二、实验内容:掌握分治法、贪心算法的概念和基本思想,并结合具体的问题学习如何用相应策略进行求解的方法。

三、实验题1. 【伪造硬币问题】给你一个装有n个硬币的袋子。

n个硬币中有一个是伪造的。

你的任务是找出这个伪造的硬币。

为了帮助你完成这一任务,将提供一台可用来比较两组硬币重量的仪器,利用这台仪器,可以知道两组硬币的重量是否相同。

试用分治法的思想写出解决问题的算法,并计算其时间复杂度。

2.【找零钱问题】一个小孩买了价值为33美分的糖,并将1美元的钱交给售货员。

售货员希望用数目最少的硬币找给小孩。

假设提供了数目有限的面值为25美分、10美分、5美分、及1美分的硬币。

给出一种找零钱的贪心算法。

四、实验步骤理解算法思想和问题要求;编程实现题目要求;上机输入和调试自己所编的程序;验证分析实验结果;整理出实验报告。

五、实验程序1.伪造硬币问题源程序://c语言实现#include<stdio.h>#include<stdlib.h>#include<math.h>#define N 100#define N1 12//只能判断是否相等的天平void solve(int coin[],int count,int first,int last) {if (count==2) {printf("无法判断\n");return;}if (first==last) {//只有一个硬币时候printf("假币的序号为%d, 假币的重量为%d\n", first, coin[first]);}else if(last-first==1){ //如果只剩下两个硬币(此时count不为)if (first > 0) { //不是最开始的硬币if (coin[first] == coin[0]) //如果第first和第个相等,说明first 位置不是伪币solve(coin,count,first+1,last);else//否则,说明first位置是伪币solve(coin,count,first,last-1);}else if(last<count-1){ //不是最后的硬币if (coin[first]==coin[count-1]) //如果第first和最后一个相等,说明last位置不是伪币solve(coin,count,first+1,last);else//否则,说明first位置是伪币solve(coin,count,first,last-1);}}else if (first<last){int temp=(last-first+1)/3; //将硬币分为三组int sum1=0, sum2=0;for(int i=0;i<temp;i++){sum1+=coin[first+i];sum2+=coin[last-i];}if (sum1==sum2){ //两边的总重相等,在中间,递归solve(coin,count,first+temp,last-temp);}else {//在两边,不在中间if (sum1==coin[first+temp]*temp){ //左边的和中间的相等,在右边,递归solve(coin,count,last-temp+1,last);}else {solve(coin,count,first,first+temp-1); //右边的和中间的相等,在左边,递归}}}}void main() {int i;int coin[N]; //定义数组coin用来存放硬币重量for(i=0;i<N;i++) //初始化数组coin[i]=0; //所用硬币初始值为coin[N1]=1; //第N1个设置为,即伪币int cnt = N;printf("硬币个数:%d\n",cnt);solve(coin,cnt,0,cnt-1);}2找零钱问题(1)零钱个数无限制的时候:源程序://c语言实现#include<stdio.h>main(){int T[]={25,10,5,1};int a[5];int money,i,j;printf("输入钱数:\n");scanf("%d",&money);for(i=0;i<4;i++){a[i]=money/T[i];money=money%T[i];}printf("找钱结果:\n硬币:\t");for(i=0;i<=3;i++){printf("%d\t|\t",T[i]);}printf("\n个数:\t");for(i=0;i<=3;i++){printf("%d\t|\t",a[i]);}printf("\n");return(0);}(2)当零钱个数有个数限制的时候:源程序://c语言实现#include<stdio.h>main(){int T[]={25,10,5,1}; //硬币的面值int a[5]; //用来记录找钱的个数int count[]={1,2,10,1000}; //各个面值硬币的个数int money,i;printf("输入钱数:\n");scanf("%d",&money);for(i=0;i<4;i++){if(money>T[i]*count[i]){ //当剩余钱数大于当前硬币总值a[i]=count[i]; //当前硬币个数取现有的最大值money=money-T[i]*count[i];}else{a[i]=money/T[i];money=money%T[i];}}printf("找钱结果:\n硬币:\t");for(i=0;i<=3;i++){printf("%d\t|\t",T[i]);}printf("\n\n个数:\t");for(i=0;i<=3;i++){printf("%d\t|\t",a[i]);}printf("\n");return(0);}六、实验结果1伪造硬币问题运行结果:硬币个数:100假币的序号为12, 假币的重量为1截图:2找零钱问题(1、硬币个数无限制)运行结果:输入钱数:67找钱结果:硬币: 25 | 10 | 5 | 1 |个数: 2 | 1 | 1 | 2 |截图:3找零钱问题(2、硬币个数有限制,其中硬币个数限制分别为1,2,10和1000。

实验报告2

实验报告2

实验报告21.综述计算机常用算法设计1.穷举法的基本思想是根据题目的部分条件确定答案的大致范围,并在此范围内对所有可能的情况逐一验证,直到全部情况验证完毕。

若某个情况验证符合题目的全部条件,则为本问题的一个解;若全部情况验证后都不符合题目的全部条件,则本题无解。

穷举法也称为枚举法。

2.回溯法(探索与回溯法)是一种选优搜索法,又称为试探法,按选优条件向前搜索,以达到目标。

但当探索到某一步时,发现原先选择并不优或达不到目标,就退回一步重新选择,这种走不通就退回再走的技术为回溯法,而满足回溯条件的某个状态的点称为“回溯点”。

3.能采用递归描述的算法通常有这样的特征:为求解规模为N的问题,设法将它分解成规模较小的问题,然后从这些小问题的解方便地构造出大问题的解,并且这些规模较小的问题也能采用同样的分解和综合方法,分解成规模更小的问题,并从这些更小问题的解构造出规模较大问题的解。

特别地,当规模N=1时,能直接得解。

4.在计算机科学中,分治法是一种很重要的算法。

字面上的解释是“分而治之”,就是把一个复杂的问题分成两个或更多的相同或相似的子问题,再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解,原问题的解即子问题的解的合并。

这个技巧是很多高效算法的基础,如排序算法(快速排序,归并排序),傅立叶变换(快速傅立叶变换)……5.贪心算法(又称贪婪算法)是指,在对问题求解时,总是做出在当前看来是最好的选择。

也就是说,不从整体最优上加以考虑,他所做出的仅是在某种意义上的局部最优解。

贪心算法不是对所有问题都能得到整体最优解,但对范围相当广泛的许多问题他能产生整体最优解或者是整体最优解的近似解。

6.动态规划程序设计是对解最优化问题的一种途径、一种方法,而不是一种特殊算法。

不像搜索或数值计算那样,具有一个标准的数学表达式和明确清晰的解题方法。

动态规划程序设计往往是针对一种最优化问题,由于各种问题的性质不同,确定最优解的条件也互不相同,因而动态规划的设计方法对不同的问题,有各具特色的解题方法,而不存在一种万能的动态规划算法,可以解决各类最优化问题。

实验二 A星算法实验

实验二 A星算法实验

人工智能基础(第2版)
实验二A*算法实验
1.提交期限和方法
2.实验目的
熟悉和掌握启发式搜索的定义、估价函数和算法过程,并利用A*算法求解N 数码难题,理解求解流程和搜索顺序。

3.实验任务
1)实现类似于如图所示N数码难题演示程序。

2)用你所熟悉的程序语言实现,可以B/S实现,也可以C/S实现。

4、实验内容
1)分别以8数码和15数码为例实际求解A*算法。

2)画出A*算法求解框图。

3)分析估价函数对搜索算法的影响。

4 )分析A*算法的特点。

5、提交要求
1、本次实验为个人任务,需独立完成,以纸质和电子档的形式把实验报告提交给学习委员,再由学习委员在规定期限内提交给任课老师。

2、要求把所做的程序的演示图附加到实验报告上,代码不需要添加到实验报告上。

3、撰写实验报告
实验报告具体内容如下:
实验题目、实验目的、实验原理、实验条件、实验内容、实验步骤、程序代码、个人实验小结。

4、未按时提交实验报告者,每迟交一天扣1分,扣完为止。

经辅导员同意并签字的事病假时间不计入迟交范围。

凡被发现实验报告有抄袭者,本次成绩以零分记。

RSA实验报告2024

RSA实验报告2024

RSA实验报告(二)引言:RSA算法是一种公钥加密算法,被广泛应用于信息安全领域。

本次实验旨在通过实现RSA算法,深入理解其原理和实际应用。

本文将通过对RSA算法进行实验,并详细分析实验结果,探讨RSA算法的性能和安全性。

概述:RSA算法是由三位密学家Rivest、Shamir和Adleman于1977年共同提出的。

它基于数论中的大数分解问题,通过巧妙地利用素数和模幂运算的特性,实现了一种快速且安全的加密算法。

本次实验将从密钥对、加密和解密三个方面对RSA算法进行实验。

正文内容:一、密钥对1.选择素数:通过随机的方法选择两个大的素数p和q,保证其大小和位数的安全性。

2.计算n和φ(n):根据选择的p和q,计算出n和φ(n),其中n=pq,φ(n)为欧拉函数的值。

3.选择公钥:选择一个与φ(n)互质的整数e,作为公钥。

4.计算私钥:根据选择的公钥e和φ(n),通过扩展欧几里得算法计算出私钥d。

5.密钥完毕:将公钥(n,e)和私钥(n,d)存储起来,用于后续的加密和解密操作。

二、加密1.明文转化:将要加密的明文转化为对应的整数,使用ASCII 码或其他字符编码方式进行转化。

2.加密运算:使用公钥(n,e),对明文进行模幂运算,得到密文。

3.密文输出:将得到的密文输出。

三、解密1.密文转化:将接收到的密文转化为对应的整数。

2.解密运算:使用私钥(n,d),对密文进行模幂运算,得到解密后的明文。

3.明文输出:将得到的明文输出。

四、性能分析1.密钥长度:根据实验结果统计不同密钥长度下加密和解密的速度,比较性能差异。

2.加解密时间:通过实验测量不同明文长度下的加密和解密时间,分析RSA算法的执行效率。

3.密文大小:研究密文与明文的关联性,分析密文对明文的扩展效果。

4.安全性分析:基于已知攻击手段,分析RSA算法的安全性,包括素数选择、模幂运算等环节。

五、实验结果1.密钥:统计不同长度密钥所需时间,并分析其对RSA算法的影响。

《算法设计与分析》实验二

《算法设计与分析》实验二

14210501022017 3 281234121010 3201741112//枢轴元素t为数组最左侧的元素//i往右移动j往左移动当指向同一位置时扫描完成//如果右侧指针元素比轴测元素大,指针元素左移//确保i在j左边//当右侧指针元素比轴测元素小时,交换两指针指向数的位置//如果左侧指针元素比轴测元素小,指针元素右移//确保i在j左边//当左侧指针元素比轴测元素大时,交换两指针指向数的位置//对左边进行排序//对右边进行排序printf("\n");system("pause");getchar();}运行结果经验归纳结合以前学的数据结构及应用算法,较容易理解。

题目二:对用户输入的杂乱无序的数字序列按照由小到大的顺序排序:合并排序题目分析合并排序的基本思想是:将待排序的元素分成大小大相同的两个子集合,分别对两个子集合进行排序,最终将排序好的子集合合并成所要求的拍好序的集合。

算法构造核心代码来自书上:MergePass(Type x[],Type y[],int s,int n)//合并大小为s的相邻序列子数组Merge(Type c[],Type d[],int l,int m,int r) //合并c[l,m]和x[m+1,r]到y[l,r]算法实现//将a中的元素合并到数组b//将b中的元素合并到数组a//合并c[l,m]和x[m+1,r]到y[l,r]//合并大小为s的相邻序列子数组//合并大小为s的相邻2字段数组//合并x[i,i+s-1]和x[i+s,i+2*s-1]到y[i,i+2*s-1] //处理剩下的元素少于2sfor(int j=i;j<=n-1;j++)y[j]=x[j];}void main(){int a[100],i,n;printf("请输入要进行合并排序的数字的个数:\n");scanf_s("%d",&n);for( i=0;i<n;i++){printf("请输入要进行合并排序的第%d个数字:\n",i+1);scanf_s("%d",&a[i]);}MergeSort(a,n);printf("合并排序的结果:\n");for(i=0;i<n;i++)printf("%d,",a[i]);printf("\n");system("pause");}运行结果经验归纳结合以前学的数据结构及应用算法,用心理解还能明白。

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

算法设计与分析实验学院:信息工程专业:计算机科学与技术算法实验报告二排序问题求解一、实验目的:1)以排序(分类)问题为例,掌握分治法的基本设计策略。

2)熟练掌握一般插入排序算法的实现;3)熟练掌握快速排序算法的实现;4) 理解常见的算法经验分析方法;二、实验要求:1.生成实验数据.要求:编写一个函数datagenetare,生成2000个在区间[1,10000]上的随机整数,并将这些数输出到外部文件data.txt中。

这些数作为后面算法的实验数据。

2.实现直接插入排序算法.3.实现快速排序算法.三、实验主要步骤:#include<stdlib.h>#include<stdio.h>#include<time.h>#include<math.h>#define RAND_MAX 10000#define Max 1000int I_Change_count = 0; //插入排序比较计数器int I_Move_count = 0; //插入排序移动计数器int S_Change_count =0; //选择排序比较计数器int S_Move_count = 0; //选择排序移动计数器int Q_Change_count = 0; //快速排序比较计数器int Q_Move_count = 0; //快速排序移动计数器void main(){long num;long Array[Max],Brray[Max],Crray[Max];//分别用来保存随机数作为两个排序的对象int A_Length;int Low = 0;int High;time_t t;void InsertSort(long Array[],int A_Length);//void SelectSort(long Brray[],int A_Length);void QuickSort(long Crray[],int Low,int High);srand((unsigned) time(&t));/*用时间初始化随机函数*/int T,i;printf("输入你想要比较的数的个数,本算法是按照2的次方来计算的:");scanf("%d",&T);A_Length = (int)pow(2.,T);if(A_Length > 1000){exit(0); //如果比较次数大于100000,退出程序}High = A_Length - 1;printf("比较的个数为:%d\n",A_Length);printf("=======================原序列=========================\n");for(i=0;i<A_Length;i++){Array[i]=rand()%1000000;//产生1000000内的第一个随机数Brray[i]=Array[i];Crray[i]=Array[i];printf("%ld\t",Array[i]);}printf("\n\n");printf("=======================插入排序后的序列=========================\n");InsertSort(Array,A_Length);for(i=0;i<A_Length;i++){printf("%ld\t",Array[i]);}printf("\n=======================插入排序的时间复杂度=========================");printf("\n插入排序:比较次数=%d,移动次数=%d,时间复杂度=%d\n\n",I_Change_count,I_Move_count,I_Change_count+I_Move_count);/*printf("=======================选择排序后的序列=========================\n");SelectSort(Brray,A_Length);for(int i=0;i<A_Length;i++){printf("%ld\t",Brray[i]);}printf("\n=======================选择排序的时间复杂度=========================");printf("\n选择排序:比较次数=%d,移动次数=%d,时间复杂度=%d\n\n",S_Change_count,S_Move_count,S_Change_count+S_Move_count);*/printf("=======================快速排序后的序列=========================\n");QuickSort(Crray,Low,High);for( i=0;i<A_Length;i++){printf("%ld\t",Crray[i]);}printf("\n=======================快速排序的时间复杂度=========================");printf("\n插入排序:比较次数=%d,移动次数=%d,时间复杂度=%d\n",Q_Change_count,Q_Move_count,Q_Change_count+Q_Move_count);}void InsertSort(long Array[],int A_Length){int i,j;long signal;for(i = 1;i < A_Length;i++) //依次插入Array[1],…,Array[n-1]if(Array[i]<Array[i-1]||(I_Change_count++&&0))//比较失败时,比较计数器自加{I_Change_count ++; //比较成功时因为“||”后面的不执行所以比较计数器得自加signal = Array[i];j=i-1; //signal是哨兵,且是Array[i]的副本do{ //从右向左在有序区Array[1..i-1]中查找Array[i]的插入位置I_Change_count ++; //比较成功时直接执行所以比较计数器放在此处Array[j+1]=Array[j];//将关键字大于Array[i]的记录后移I_Move_count ++;j--;}while(signal < Array[j]);//当signal≥Array[j]时终止I_Change_count ++;//比较失败时,循环跳出比较计数器自加一次Array[j+1]=signal; //Array[i]插入到正确的位置上}//endif}void SelectSort(long Brray[],int A_Length){int i,j,k;long signal;for(i=0;i<A_Length;i++){k = i;for(j=i+1;j<A_Length;j++){S_Change_count ++; //因为不管比较成不成功都要比较A_Length-j次//所以将比较计数器放在比较前if(Brray[j] < Brray[k])k = j;}if(k != i){signal = Brray[i];Brray[i] = Brray[k];Brray[k] = signal;S_Move_count ++; //每次交换当做移动一次,因为其他赋值都是为了完成算法而写的//我们认为两者的交换只要一次就实现}}}void QuickSort(long Crray[],int Low,int High){int C_Low = Low,C_High = High;long signal = Crray[Low];if(Low >= High) return ;while(C_Low != C_High){while(C_Low < C_High && Crray[C_High] >= signal)C_High --;Crray[C_Low] = Crray[C_High];while(C_Low < C_High && Crray[C_Low] <= signal)C_Low ++;Crray[C_High] = Crray[C_Low];Q_Change_count ++;}Crray[C_Low] = signal;Q_Move_count ++;QuickSort(Crray,Low,C_Low-1);QuickSort(Crray,C_Low+1,High);}四、实验结果:输入7共有128个数排序,运行结果如下五、心得体会:通过本次实验更加深刻的了解的快速排序和直接插入排序算法,通过编写程序实现排序,掌握分治法的基本策略,明白了算法时间复杂度的分析,同一个要求,使用不同的算法,所需时间和空间不同,因此根据不同的实验要求,编写合适的算法是非常重要的,有利于缩短运行时间。

通过本次实验,为后面学习各种复杂算法打下坚实的基础。

相关文档
最新文档