中南大学算法实验报告

合集下载

中南大学大一下学期c++程序设计实验报告1.0

中南大学大一下学期c++程序设计实验报告1.0

中南大学本科生课程设计(实践)任务书、设计报告(C++语言程序设计)题目多功能集成程序系统学生姓名闵杰指导教师罗芳学院材料科学与工程专业班级材料类1003学生学号**********计算机基础教学实验中心2011 年 6 月 30 日《集合简单计算、信息管理、绘图及多媒体系统设计》C++实践报告关键词:C++程序设计MFC[.exe] 面向对象计算信息管理绘图播放器一、引言1.1实践任务:1、计算程序设计。

如:计算器、一元二次方程的求解、华氏温度和摄氏温度之间的转换、求阶乘等。

2、文本编辑程序设计。

3、绘图程序设计。

如:吹泡泡程序、曲线等图形绘制。

4、信息管理程序设计。

能完成信息的添加、删除和修改等功能。

5、多媒体程序设计。

如:音频播放器、flash动画播放器等。

1.2实践目的:当今社会是信息时代,科技的高速发展要求我们能过熟练掌握并运用新的科学技术。

而信息的获取需要我们能够掌握应用程序的深层代码,运用所掌握的计算机程序知识对数据进行管理。

C++是由C发展而来的,与C兼容。

所以它可以用于面向过程的结构化程序设计,但是它又有自己的特点,它也可以用于面向对象的程序设计,是一种功能强大的混合型的程序设计语言。

通过本次实践,1、可以加深我们对面向对象的认识,巩固C++的基础知识,了解基于对话框的应用程序、文档/视图应用程序的框架结构和运行机制,初步掌握创建MFC应用程序的方法、过程。

2、掌握常用的控件的重要属性、主要消息、常用成员函数,并熟练地应用这些控件设计应用程序。

3、掌握绘制图形的方法、定时器的使用,鼠标消息处理函数和键盘消息处理函数的编写、对话框使用和菜单设计的技术。

4、培养我们的独立思考、设计综合程序的能力;同时培养自学能力;训练小论文撰写能力。

因此,计算机程序设计是大多数专业的必修课。

随着软件工程技术的不断发展,面向对象的程序设计方法已成为当今软件开发的主流技术,我们肩负着博采众长的使命,运用好该程序将使我们受益匪浅。

中南大学数据结构实验报告1(线性表)

中南大学数据结构实验报告1(线性表)

中南⼤学数据结构实验报告1(线性表)实验⼀线性表的操作算法⼀、实验⽬的:1了解线性表的逻辑结构和存储结构,以及定义在逻辑结构上的各种基本运算2分别以数组和链表为存储结构,实现线性表的插⼊,删除,查找,排序,合并等操作⼆、实验内容:⽤C/C++语⾔编写程序,分别以数组和链表为存储结构,完成以下功能:1输⼊数据,创建⼀个线性表2可在线性表的任意位置插⼊新结点3可删除线性表的任意⼀个结点4可在线性表中查找结点5将线性表从⼩⾄⼤排序6将两个线性表合并三、详细设计:顺序表#includeusing namespace std;#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;typedef int ElemType;#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef struct { //结构体ElemType *elem;int length;int listsize;}SqList;SqList Lx;Status InitList_Sq(SqList &L) //分配空间{ L.elem=new ElemType[LIST_INIT_SIZE];if(!L.elem)exit(OVERFLOW);L.length =0;L.listsize=LIST_INIT_SIZE;return OK;}Status ListInsert(SqList &L,int i,ElemType e) //插⼊新元素{ int *q,*p;ElemType *newbase; if(i<1 || i>L.length+1) return ERROR;if(L.length>=L.listsize){ newbase=new ElemType[L.listsize+LISTINCREMENT];if(!newbase) exit(OVERFLOW);L.elem=newbase;L.listsize+=LISTINCREMENT;}q=&(L.elem[i-1]);for (p=&(L.elem[L.length-1]);p>=q;--p)*(p+1)=*p;*q=e;++L.length;return OK;}Status Listlength(SqList L) //长度{ int *p=L.elem; //判断线形表是否存在while(p){ return (L.length); }}Status GetElem(SqList L, int i,ElemType &e) //取元素{ if(i<1 || i>L.length)return ERROR;else{ e=L.elem[i-1];return e;}}void MergeList(SqList La,SqList Lb,SqList &Lc) //合并{ ElemType ai,bj;InitList_Sq(Lc);int i=1,j=1,k=0;int La_len,Lb_len;La_len=Listlength(La);Lb_len=Listlength(Lb);while((i<=La_len)&&(j<=Lb_len)){ GetElem(La,i,ai);GetElem(Lb,j,bj);if(ai<=bj){ ListInsert(Lc,++k,ai);++i; }else{ ListInsert(Lc,++k,bj);++j; }}while(i<=La_len){ GetElem(La,i++,ai);ListInsert(Lc,++k,ai);}while(j<=Lb_len){ GetElem(Lb,j++,bj);ListInsert(Lc,++k,bj);}}void show(SqList L,int i) //显⽰{ int j;ElemType k;cout<<"顺序表显⽰如下:"<for(j=0;j{ k=L.elem[j];cout<"; }if(j==i-1 && i>0){ k=L.elem[j]; cout<cout<}void create(SqList &L,int n) //输⼊元素{ int e; for(int i=0;i{ cin>>e;L.elem[i]=e;L.length=i+1; }}Status ListDelete_Sq(SqList &L,int i,ElemType &e) //删除{ ElemType *p, *q; if(i<1 || i>L.length) return ERROR;p=&(L.elem[i-1]);e=*p;q=L.elem+L.length-1;for(++p;p<=q;++p) *(p-1)=*p;--L.length;return OK;}Status Listxiugei(SqList &L,int i,ElemType &e) //修改{ if(i<1 || i>L.length) return ERROR;else{ L.elem[i-1]=e;return OK; }}void shuru(SqList &L1) //顺序表的创建{ int a;InitList_Sq(L1);cout<<"请输⼊顺序表的长度:";cin>>a;cout<<"请输⼊顺序表的元素(共"<create(L1,a);show(L1,a);}void shanchu(SqList &L1) //删除顺序表⾥的元素{ int a;int j; ElemType e1;a=L1.length;cout<<"请选择所要删除元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输⼊有误,请重新输⼊"<cout<<"请选择所要删除元素的位置:";cin>>j; }ListDelete_Sq(L1,j,e1);cout<<"修改后的顺序表数据:"<show(L1,a-1);}void charu(SqList &L1) //插⼊元素到顺序表⾥{ int a; int j; ElemType e1; a=L1.length;cout<<"请选择所要插⼊元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输⼊有误,请重新输⼊"<cout<<"请选择所要插⼊元素的位置:";cin>>j; }cout<<"要插⼊的元素:";cin>>e1;ListInsert(L1,j,e1);cout<<"修改后的顺序表数据:"<show(L1,a+1);}void hebing(SqList &L3) //合并两个顺序表{ SqList L1,L2;int a,b;InitList_Sq(L1); InitList_Sq(L2);cout<<"请输⼊第⼀个有序表的长度:"; cin>>a;cout<<"请输⼊第⼀个有序表的元素(共"<create(L1,a);show(L1,a);cout<<"请输⼊第⼆个有序表的长度:"; cin>>b;cout<<"请输⼊第⼆个有序表的元素(共"<create(L2,b);show(L2,b);MergeList(L1,L2,L3);cout<<"合并后的有序表如下:"; show(L3,a+b);}void main() //主菜单{ int choice;for(;;){ cout<<"顺序表的基本操作"<cout<<"1.顺序表的创建"<cout<<"2.顺序表的显⽰"<cout<<"3.顺序表的长度"<cout<<"4.插⼊元素到顺序表⾥"<cout<<"5.删除顺序表⾥的元素"<cout<<"6.合并两个顺序表"<cout<<"7.退出系统"<cout<<"请选择:";cin>>choice;switch(choice){ case 1: shuru(Lx);break;case 2: show(Lx,Lx.length);break;case 3: cout<<"顺序表的长度:"<case 4: charu(Lx);break;case 5: shanchu(Lx);break;case 6: hebing(Lx);break;case 7: cout<<"退出系统!"<default : cout<<"输⼊有误,请重新选择"< }}链表#includeusing namespace std;#define true 1#define false 0#define ok 1#define error 0#define overflow -2typedef int Status;typedef int ElemType;typedef struct LNode //存储结构{ ElemType data;struct LNode *next;}LNode,*LinkList;void CreateList(LinkList &L,int n) //尾插法创建单链表{ LinkList p;L=new LNode;L->next=NULL; //建⽴⼀个带头结点的单链表LinkList q=L; //使q指向表尾for(int i=1;i<=n;i++){ p=new LNode;cin>>p->data;p->next=NULL;q->next=p;q=p; }}Status GetElem(LinkList L,int i,ElemType &e)//取第i个元素{ LinkList p=L->next;int j=1;while(p&&j{ p=p->next;++j; }if(!p||j>i) return error; //第i个元素不存在e=p->data;return ok;}Status LinkInsert(LinkList &L,int i,ElemType e) //插⼊{ LinkList p=L;int j=0;while(p&&j{ p=p->next;++j; } //寻找第i-1个结点 if(!p||j>i-1)return error; //i⼩于1或者⼤于表长加1 LinkList s=new LNode; //⽣成新结点s->data=e;s->next=p->next; //插⼊L中p->next=s;return ok;}Status ListDelete(LinkList &L,int i,ElemType &e) // 删除{ LinkList p=L;LinkList q;int j=0;while(p->next&&j{ //寻找第i个结点,并令p指向其前驱 p=p->next;++j; }if(!(p->next)||j>i-1) return error; //删除位置不合理q=p->next;p->next=q->next; //删除并释放结点e=q->data;delete(q);return ok;}void MergeList(LinkList &La,LinkList &Lb,LinkList &Lc) { //合并两个顺序链表LinkList pa,pc,pb; pa=La->next;pb=Lb->next;Lc=pc=La;while(pa&&pb){ if(pa->data<=pb->data){ pc->next=pa;pc=pa;pa=pa->next; }else{ pc->next=pb;pc=pb;pb=pb->next; }}pc->next=pa?pa:pb;delete(Lb);}void show(LinkList L) //显⽰{ LinkList p;p=L->next;while(p){ cout<data<<"-->";p=p->next; }cout<}int Length(LinkList L,int i) //表长{ i=0;LinkList p=L->next;while(p){ ++i;p=p->next; }return i;}void xiugai(LinkList L) //修改{ int i,j=1;ElemType k;ElemType e,m;LinkList p=L->next;cout<<"请输⼊要修改的元素位置(0 cin>>i;GetElem(L,i,e);cout<<"该位置的元素:"<cout<<"修改后的元素值:";cin>>k;while(p&&j{ p=p->next;++j; }m=p->data;p->data=k;cout<<"修改后的单链表显⽰如下:"< show(L);}void hebing() //合并两个单链表{ int a,b;LinkList La,Lb,Lc;cout<<"请输⼊第⼀个有序链表的长度:"<cin>>a;cout<<"请输⼊第⼀个有序链表的元素共("< CreateList(La,a);show(La);cout<<"请输⼊第⼆个有序链表的长度:"< cin>>b;cout<<"请输⼊第⼆个有序链表的元素共("< CreateList(Lb,b);show (Lb);MergeList(La,Lb,Lc);cout<<"合并后的有序链表如下:"<show(Lc);}void main() //主函数{ int select;int x;ElemType y;LinkList list;for(;;){ cout<<"单链表的基本操作"<cout<<"1.单链表的创建"<cout<<"2.单链表的显⽰"<cout<<"3.单链表的长度"<cout<<"4.插⼊元素到单链表⾥"<cout<<"5.删除单链表⾥的元素"<cout<<"6.合并两个单链表"<cout<<"7.退出系统"<cout<<"请选择:";cin>>select;switch(select){ case 1:cout<<"请输⼊单链表的长度:"< cin>>x;cout<<"请输⼊"<CreateList(list,x);break;case 2: cout<<"单链表显⽰如下:"<show(list);break;case 3: int s;cout<<"单链表的长度为:"<break;case 4: cout<<"请选择要插⼊的位置:"; cin>>x; while(x<0||x>Length(list,s)){ cout<<"输⼊有误,请重新输⼊"<cout<<"请选择所要插⼊元素的位置:"; cin>>x; }cout<<"要插⼊的元素值:";cin>>y;LinkInsert( list,x,y);cout<<"插⼊后单链表显⽰如下:"<show(list);break;case 5: cout<<"请选择要删除的位置:"; cin>>x; while(x<0||x>Length(list,s)){ cout<<"输⼊有误,请重新输⼊"<cout<<"请选择所要删除元素的位置:"; cin>>x; }ListDelete(list,x,y);cout<<"要删除的元素值:"<cout<<"删除后的单链表显⽰如下:"<show(list);break;case 6: hebing();break;case 7: exit(0);break;default : cout<<"输⼊有误,请重新输⼊"< break;}}}四、实验结果:顺序表链表。

中南大学 计算机体系结构实验报告

中南大学 计算机体系结构实验报告

计算机体系结构课程设计学院:信息科学与工程学院专业班级:指导老师:学号:姓名:目录实验 1 对指令操作码进行霍夫曼编码 (3)一、实验目的 (3)二、实验内容 (3)三、设计思路 (4)四、关键代码 (4)五、实验截图 (5)六、源代码 (5)实验 2 使用LRU 方法更新Cache (8)一、实验目的 (8)二、实验内容 (8)三、设计思路 (9)四、程序截图 (9)五、实验代码 (9)实验总结 (16)参考文献 (16)实验1 对指令操作码进行霍夫曼编码一、实验目的了解和掌握指令编码的基本要求和基本原理二、实验内容1. 使用编程工具编写一个程序,对一组指令进行霍夫曼编码,并输出最后的编码结果以及对指令码的长度进行评价。

与扩展操作码和等长编码进行比较。

2. 问题描述以及问题分析举例说明此问题,例如:P1P2P3P4P5P6P70.450.300.150.050.030.010.01下表所示:对此组指令进行HUFFMAN 编码正如下图所示:最后得到的HUFFMAN 编码如下表所示:P1P2P3P4P5P6P7 010110111011110111110111111最短编码长度为:H=0.45*1+0.30*2+0.15*3+0.05*4+0.03*5+0.01*6+0.01*6=-1.95.要对指令的操作码进行HUFFMAN 编码,只要根据指令的各类操作码的出现概率构造HUFFMAN 树再进行HUFFAM 编码。

此过程的难点构造HUFFMAN 树,进行HUFFAM 编码只要对你所生成的HUFFMAN 树进行中序遍历即可完成编码工作。

三、设计思路观察上图,不难看出构造HUFFMAN 树所要做的工作:1、先对各指令操作码的出现概率进行排序,构造一个有序链表。

2、再取出两个最小的概率节点相加,生成一个生的节点加入到链表中,同时从两表中删除此两个节点。

3、在对链表进行排序,链表是否只有一个节点,是则HUFFAN 树构造完毕,否则继续做 2 的操作。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

- 编写贪心算法的代码。

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

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

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

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

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

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

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

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

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

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

最新中南大学算法实验报告

最新中南大学算法实验报告

算法分析与设计实验报告学院:信息科学与工程学院专业班级:物联网工程1301班指导老师:向瑶学号:姓名:目录实验一 ----------------------------------------3 实验目的 -----------------------------------------3 实验内容 -----------------------------------------3实验原理及部分代码---------------------------------3实验结果 ------------------------------------------4 源代码-------------------------------------------4 实验二 ----------------------------------------7 实验目的 -----------------------------------------7 实验内容 -----------------------------------------7实验原理及部分代码---------------------------------7实验结果 ------------------------------------------8 源代码-------------------------------------------8 实验三 ----------------------------------------10 实验目的 -----------------------------------------10 实验内容 -----------------------------------------10实验原理及部分代码---------------------------------10实验结果 ------------------------------------------11 源代码-------------------------------------------11 心得体会 -----------------------------------------14实验一递归与分治一、实验目的1、理解递归算法的思想和递归程序的执行过程,并能熟练编写递归程序。

中南大学数据结构实验报告1(线性表)

中南大学数据结构实验报告1(线性表)

实验一线性表的操作算法一、实验目的:1了解线性表的逻辑结构和存储结构,以及定义在逻辑结构上的各种基本运算2分别以数组和链表为存储结构,实现线性表的插入,删除,查找,排序,合并等操作二、实验内容:用C/C++语言编写程序,分别以数组和链表为存储结构,完成以下功能:1输入数据,创建一个线性表2可在线性表的任意位置插入新结点3可删除线性表的任意一个结点4可在线性表中查找结点5将线性表从小至大排序6将两个线性表合并三、详细设计:顺序表#include<iostream>using namespace std;#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;typedef int ElemType;#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef struct { //结构体ElemType *elem;int length;int listsize;}SqList;SqList Lx;Status InitList_Sq(SqList &L) //分配空间{ L.elem=new ElemType[LIST_INIT_SIZE];if(!L.elem)exit(OVERFLOW);L.length =0;L.listsize=LIST_INIT_SIZE;return OK;}Status ListInsert(SqList &L,int i,ElemType e) //插入新元素{ int *q,*p;ElemType *newbase;if(i<1 || i>L.length+1) return ERROR;if(L.length>=L.listsize){ newbase=new ElemType[L.listsize+LISTINCREMENT];if(!newbase) exit(OVERFLOW);L.elem=newbase;L.listsize+=LISTINCREMENT;}q=&(L.elem[i-1]);for (p=&(L.elem[L.length-1]);p>=q;--p)*(p+1)=*p;*q=e;++L.length;return OK;}Status Listlength(SqList L) //长度{ int *p=L.elem; //判断线形表是否存在while(p){ return (L.length); }}Status GetElem(SqList L, int i,ElemType &e) //取元素{ if(i<1 || i>L.length)return ERROR;else{ e=L.elem[i-1];return e;}}void MergeList(SqList La,SqList Lb,SqList &Lc) //合并{ ElemType ai,bj;InitList_Sq(Lc);int i=1,j=1,k=0;int La_len,Lb_len;La_len=Listlength(La);Lb_len=Listlength(Lb);while((i<=La_len)&&(j<=Lb_len)){ GetElem(La,i,ai);GetElem(Lb,j,bj);if(ai<=bj){ ListInsert(Lc,++k,ai);++i; }else{ ListInsert(Lc,++k,bj);++j; }}while(i<=La_len){ GetElem(La,i++,ai);ListInsert(Lc,++k,ai);}while(j<=Lb_len){ GetElem(Lb,j++,bj);ListInsert(Lc,++k,bj);}}void show(SqList L,int i) //显示{ int j;ElemType k;cout<<"顺序表显示如下:"<<endl;for(j=0;j<i-1;j++){ k=L.elem[j];cout<<k<<"->"; }if(j==i-1 && i>0){ k=L.elem[j]; cout<<k; }cout<<endl;}void create(SqList &L,int n) //输入元素{ int e;for(int i=0;i<n;i++){ cin>>e;L.elem[i]=e;L.length=i+1; }}Status ListDelete_Sq(SqList &L,int i,ElemType &e) //删除{ ElemType *p, *q;if(i<1 || i>L.length) return ERROR;p=&(L.elem[i-1]);e=*p;q=L.elem+L.length-1;for(++p;p<=q;++p) *(p-1)=*p;--L.length;return OK;}Status Listxiugei(SqList &L,int i,ElemType &e) //修改{ if(i<1 || i>L.length)return ERROR;else{ L.elem[i-1]=e;return OK; }}void shuru(SqList &L1) //顺序表的创建{ int a;InitList_Sq(L1);cout<<"请输入顺序表的长度:";cin>>a;cout<<"请输入顺序表的元素(共"<<a<<"个)"<<endl;create(L1,a);show(L1,a);}void shanchu(SqList &L1) //删除顺序表里的元素{ int a;int j; ElemType e1;a=L1.length;cout<<"请选择所要删除元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要删除元素的位置:";cin>>j; }ListDelete_Sq(L1,j,e1);cout<<"修改后的顺序表数据:"<<endl;show(L1,a-1);}void charu(SqList &L1) //插入元素到顺序表里{ int a; int j; ElemType e1;a=L1.length;cout<<"请选择所要插入元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要插入元素的位置:";cin>>j; }cout<<"要插入的元素:";cin>>e1;ListInsert(L1,j,e1);cout<<"修改后的顺序表数据:"<<endl;show(L1,a+1);}void hebing(SqList &L3) //合并两个顺序表{ SqList L1,L2;int a,b;InitList_Sq(L1); InitList_Sq(L2);cout<<"请输入第一个有序表的长度:"; cin>>a;cout<<"请输入第一个有序表的元素(共"<<a<<"个)"<<endl;create(L1,a);show(L1,a);cout<<"请输入第二个有序表的长度:"; cin>>b;cout<<"请输入第二个有序表的元素(共"<<b<<"个)"<<endl;create(L2,b);show(L2,b);MergeList(L1,L2,L3);cout<<"合并后的有序表如下:"; show(L3,a+b);}void main() //主菜单{ int choice;for(;;){ cout<<"顺序表的基本操作"<<endl;cout<<"1.顺序表的创建"<<endl;cout<<"2.顺序表的显示"<<endl;cout<<"3.顺序表的长度"<<endl;cout<<"4.插入元素到顺序表里"<<endl;cout<<"5.删除顺序表里的元素"<<endl;cout<<"6.合并两个顺序表"<<endl;cout<<"7.退出系统"<<endl;cout<<"请选择:";cin>>choice;switch(choice){ case 1: shuru(Lx);break;case 2: show(Lx,Lx.length);break;case 3: cout<<"顺序表的长度:"<<Listlength(Lx)<<endl;break;case 4: charu(Lx);break;case 5: shanchu(Lx);break;case 6: hebing(Lx);break;case 7: cout<<"退出系统!"<<endl;exit(0);break;default : cout<<"输入有误,请重新选择"<<endl;break; }}}链表#include<iostream>using namespace std;#define true 1#define false 0#define ok 1#define error 0#define overflow -2typedef int Status;typedef int ElemType;typedef struct LNode //存储结构{ ElemType data;struct LNode *next;}LNode,*LinkList;void CreateList(LinkList &L,int n) //尾插法创建单链表{ LinkList p;L=new LNode;L->next=NULL; //建立一个带头结点的单链表LinkList q=L; //使q指向表尾for(int i=1;i<=n;i++){ p=new LNode;cin>>p->data;p->next=NULL;q->next=p;q=p; }}Status GetElem(LinkList L,int i,ElemType &e)//取第i个元素{ LinkList p=L->next;int j=1;while(p&&j<i){ p=p->next;++j; }if(!p||j>i) return error; //第i个元素不存在e=p->data;return ok;}Status LinkInsert(LinkList &L,int i,ElemType e) //插入{ LinkList p=L;int j=0;while(p&&j<i-1){ p=p->next;++j; } //寻找第i-1个结点 if(!p||j>i-1)return error; //i小于1或者大于表长加1 LinkList s=new LNode; //生成新结点s->data=e;s->next=p->next; //插入L中p->next=s;return ok;}Status ListDelete(LinkList &L,int i,ElemType &e) // 删除{ LinkList p=L;LinkList q;int j=0;while(p->next&&j<i-1){ //寻找第i个结点,并令p指向其前驱 p=p->next;++j; }if(!(p->next)||j>i-1) return error; //删除位置不合理q=p->next;p->next=q->next; //删除并释放结点e=q->data;delete(q);return ok;}void MergeList(LinkList &La,LinkList &Lb,LinkList &Lc) { //合并两个顺序链表LinkList pa,pc,pb;pa=La->next;pb=Lb->next;Lc=pc=La;while(pa&&pb){ if(pa->data<=pb->data){ pc->next=pa;pc=pa;pa=pa->next; }else{ pc->next=pb;pc=pb;pb=pb->next; }}pc->next=pa?pa:pb;delete(Lb);}void show(LinkList L) //显示{ LinkList p;p=L->next;while(p){ cout<<p->data<<"-->";p=p->next; }cout<<endl;}int Length(LinkList L,int i) //表长{ i=0;LinkList p=L->next;while(p){ ++i;p=p->next; }return i;}void xiugai(LinkList L) //修改{ int i,j=1;ElemType k;ElemType e,m;LinkList p=L->next;cout<<"请输入要修改的元素位置(0<i<length):";cin>>i;GetElem(L,i,e);cout<<"该位置的元素:"<<e<<endl;cout<<"修改后的元素值:";cin>>k;while(p&&j<i){ p=p->next;++j; }m=p->data;p->data=k;cout<<"修改后的单链表显示如下:"<<endl;show(L);}void hebing() //合并两个单链表{ int a,b;LinkList La,Lb,Lc;cout<<"请输入第一个有序链表的长度:"<<endl;cin>>a;cout<<"请输入第一个有序链表的元素共("<<a<<"个):"<<endl;CreateList(La,a);show(La);cout<<"请输入第二个有序链表的长度:"<<endl;cin>>b;cout<<"请输入第二个有序链表的元素共("<<b<<"个):"<<endl;CreateList(Lb,b);show (Lb);MergeList(La,Lb,Lc);cout<<"合并后的有序链表如下:"<<endl;show(Lc);}void main() //主函数{ int select;int x;ElemType y;LinkList list;for(;;){ cout<<"单链表的基本操作"<<endl;cout<<"1.单链表的创建"<<endl;cout<<"2.单链表的显示"<<endl;cout<<"3.单链表的长度"<<endl;cout<<"4.插入元素到单链表里"<<endl;cout<<"5.删除单链表里的元素"<<endl;cout<<"6.合并两个单链表"<<endl;cout<<"7.退出系统"<<endl;cout<<"请选择:";cin>>select;switch(select){ case 1:cout<<"请输入单链表的长度:"<<endl;cin>>x;cout<<"请输入"<<x<<"个元素"<<endl;CreateList(list,x);break;case 2: cout<<"单链表显示如下:"<<endl;show(list);break;case 3: int s;cout<<"单链表的长度为:"<<Length(list,s)<<endl;break;case 4: cout<<"请选择要插入的位置:"; cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要插入元素的位置:";cin>>x; }cout<<"要插入的元素值:";cin>>y;LinkInsert( list,x,y);cout<<"插入后单链表显示如下:"<<endl;show(list);break;case 5: cout<<"请选择要删除的位置:"; cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误,请重新输入"<<endl;cout<<"请选择所要删除元素的位置:";cin>>x; }ListDelete(list,x,y);cout<<"要删除的元素值:"<<y<<endl;cout<<"删除后的单链表显示如下:"<<endl;show(list);break;case 6: hebing();break;case 7: exit(0);break;default : cout<<"输入有误,请重新输入"<<endl;break;}}}四、实验结果:顺序表链表。

中南大学计算机实践报告.doc

中南大学计算机实践报告.doc

中南大学计算机实践报告中南大学计算机实践报告中南大学本科生课程设计(实践)任务书、设计报告(计算机程序设计基础FORTRAN)题目线性方程组求解问题学生姓名指导教师学院专业班级学生学号刘卫国土木工程学院土建类班计算机基础教学实验中心202*年6月29日一、实践目的通过本课程设计,培养程序设计能力以及综合解决实际问题的能力。

通过自己分析问题、寻求算法、编写、调试程序的过程,掌握FORTRAN程序设计与调试方法,提高灵活运用所学知识解决问题的能力。

二、设计任务线性病态方程组问题:1/21/31/4x10.951/31/41/5x0.6721/41/51/6x30.52(1)求方程的解。

(2)将方程右边向量元素b3改为0.53,再求解,并比较b3的变化和解的相对变化。

(3)计算系数矩阵A的条件数并分析结论。

提示:矩阵A的条件数等于A的范数与A的逆矩阵的范数的乘积,即cond(A)AA1。

这样定义的条件数总是大于1的。

条件数越接近于1,矩cond(A)AA1阵的性能越好,反之,矩阵的性能越差。

矩阵A的条件数Amax{aij}1jni1m,其中,aij系矩阵A的元素。

要求:(1)方程的系数矩阵、常数向量均从文件中读入。

(2)定义求解线性方程组Ax=b的子程序,要求该子程序能求解任意线性方程组。

(3)在主程序中调用子程序,并对求解结果进行对比分析。

(4)绘制常数向量修改前后所求得的方程解的数据分布图。

三系统坏境系统开发环境为CONSOLEAPPLICAT三.系统功能及系统详细设计四系统功能及系统详细设计。

系统功能分析针对题目要求,我设计的系统主要为了解决题目中所提出并要求的问题。

子程序则各尽其用,不仅可以作为整体系统的重要部分,还可以使用于通用问题。

如三角分解法,可以解决线性方程组的求解问题。

求范数和矩阵求逆的子程序,可以解决相应的问题。

再如绘图程序,将问题(2)的结果直观化,更直观明显的表现了病态方程的特点与定义。

中南大学自动化专业离散数学实验报告2

中南大学自动化专业离散数学实验报告2

中南大学自动化专业离散数学实验报告2离散数学作为计算机科学与技术专业的基础课程之一,对于培养学生的逻辑思维和抽象思维能力具有重要意义。

本次实验是关于离散数学中的图论部份,通过实际操作和计算来理解和应用图的相关概念和算法。

实验一开始,我们首先学习了图的基本概念和术语,例如顶点、边、路径、回路等。

然后,我们学习了图的表示方法,包括邻接矩阵和邻接表。

通过实际操作,我们发现邻接矩阵适合表示稠密图,而邻接表适合表示稀疏图。

这种不同的表示方法对于图的遍历和搜索算法有着重要的影响。

接下来,我们进行了图的遍历实验。

通过深度优先搜索和广度优先搜索算法,我们可以遍历图中的所有节点,并找到特定节点之间的路径。

深度优先搜索算法通过递归的方式进行,它会首先访问一个节点的所有邻接节点,然后再递归地访问这些邻接节点的邻接节点。

广度优先搜索算法则是通过队列的方式进行,它会首先访问一个节点的所有邻接节点,然后将这些邻接节点按照访问的顺序加入队列中,再逐个出队进行访问。

通过实验,我们发现深度优先搜索算法更适适合于寻觅路径,而广度优先搜索算法更适适合于寻觅最短路径。

在实验的后半部份,我们学习了最小生成树和最短路径算法。

最小生成树算法用于找到一个连通图的最小生成树,其中包含了连接图中所有节点的最短路径。

我们学习了Prim算法和Kruskal算法,它们分别基于贪心算法和并查集来实现。

通过实验,我们发现Prim算法适适合于稠密图,而Kruskal算法适适合于稀疏图。

最短路径算法用于找到两个节点之间的最短路径,我们学习了Dijkstra算法和Floyd算法。

Dijkstra算法通过贪心策略逐步更新节点之间的最短路径,而Floyd算法则通过动态规划的方式计算所有节点之间的最短路径。

通过实验,我们发现Dijkstra算法适适合于稀疏图,而Floyd算法适适合于稠密图。

总结起来,本次实验让我们深入了解了离散数学中的图论部份,并通过实际操作和计算来应用图的相关概念和算法。

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

中南大学算法分析与设计实验报告学生姓名涂茂麟学号专业班级计算机科学与技术1303指导老师学院信息科学与工程学院目录实验一 DFS与BFS 3实验二最近点对问题 7实验三拓扑排序 10实验四 N皇后问题 12实验五 0-1背包问题 16实验六最短路径 20实验一 DFS与BFS实验目的:实现深度优先算法、宽度优先算法实现原理:深度优先搜索:从图中某顶点v出发:(1)访问顶点v;(2)依次从v的未被访问的邻接点出发,对图进行深度优先遍历;直至图中和v有路径相通的顶点都被访问;(3)若此时图中尚有顶点未被访问,则从一个未被访问的顶点出发,重新进行深度优先遍历,直到图中所有顶点均被访问过为止。

广度优先搜索:已知图G=(V,E)和一个源顶点s,宽度优先搜索以一种系统的方式探寻G的边,从而“发现”s所能到达的所有顶点,并计算s到所有这些顶点的距离(最少边数),该算法同时能生成一棵根为s且包括所有可达顶点的宽度优先树。

对从s 可达的任意顶点v,宽度优先树中从s到v的路径对应于图G中从s到v的最短路径,即包含最小边数的路径。

该算法对有向图和无向图同样适用。

具体设计:1. 数据结构采用邻接链表作为图的数据结构。

public class Graph {//图public VNode[] arrVnode=new VNode[100] ;//头结点数组public int vexmun,arcmun;//节点总数、边界总数public int time;//记录打开、关闭节点的时间}public class VNode {//节点类public int data;//节点的内容public boolean visited=false;//是否访问过public boolean ifclosed=false;//是否被放在关闭的表中public int distance=10000;//距离某一点的最短距离public int front=10000;//前驱节点public ArcNode nextarc=null;//下一条边public int entertime,exittime;//打开、关闭节点的时间}public class ArcNode{//边类public int adjvex;//该弧所指向的顶点的位置public int weight=0;//该边的权值public ArcNode nextarc=null;//下一条边}2. DFSpublic void DFS(Graph G){//DFS的起始调用方法int vexmun=G.vexmun;G.time=0;for(int v=1;v<=vexmun;v++){if(G.arrVnode[v].visited==false){DFS_VISIT(G,v);}}}public void DFS_VISIT(Graph G,int v){//应用递归的DFS访问G.arrVnode[v].visited=true;G.time++;//time是给后面的拓扑排序实验用的G.arrVnode[v].entertime=G.time;System.out.println(G.arrVnode[v].data);ArcNode node=G.arrVnode[v].nextarc;while(node!=null){int p=node.adjvex;if(G.arrVnode[p].visited==false&&G.arrVnode[p]!=null){ DFS_VISIT( G , p);}node=node.nextarc;}G.time++;G.arrVnode[v].exittime=G.time;}3. BFSpublic void BFS(Queue Queue , Graph G ,int v){if(visited[v]==false){visited[v]=true;System.out.print(G.arrVnode[v].data);System.out.print(" "); ArcNode node =G.arrVnode[v].nextarc;// QueueFunction.EnQueue(Queue, v);// while(Queue!=null){while(node!=null){if(visited[node.adjvex]==false&&queueed[node.adjvex]==false){ QueueFunction.EnQueue(Queue, node.adjvex);queueed[node.adjvex]=true;}node=node.nextarc;}BFS(Queue,G,QueueFunction.DeQueue(Queue));}}实验结果:数据说明:5个节点,10条边,每行数字分别是起始节点、终止节点、权值。

实验总结:DFS与BFS较为简单,是图论的基础。

在以后的实验中,不管是动态规划、贪心算法、回溯法都会以DFS或BFS为基础,应当是我们每个人都要掌握的。

实验二最近点对问题实验目的:运用分治算法,解决最近点对问题。

实现原理:使用分治法解决最近点对问题就是将集合S分成两个子集是S1和S2,每个子集中有N/2个点。

然后再每个子集中递归的求其最接近的点对,求出每个子集的最接近点对后,如果集合S中最接近的点对都在两个子集中,问题解决。

当两个点分别在两个子集中时,则最近点对为S1和S2的最接近点。

其时间复杂度为O(nlogn)。

具体设计:1. 排序第一步是将所有从文件获取的点按照X轴升序排列,若X坐标相同则按Y轴坐标由小到大排列。

// 按照X轴坐标升序排序Arrays.sort(point, new Comparator<Neighborpoint>() {public int compare(Neighborpoint o1, Neighborpoint o2) {if (o1.x < o2.x)return -1;if (o1.x > o2.x)return 1;if (o1.y < o2.y)return -1;if (o1.y > o2.y)return 1;return 0;}});2. 分治法求最近点对public static double Close_pair(Neighborpoint[] point,int left, int right){double d = 1e20;if(right == left)//同一点,返回很大值return d;if(left+1 == right)return distance(left,right);int mid =(left+right)>>1;//除以2double d1 = Close_pair(point,left,mid); double d2 = Close_pair(point,mid+1,right);d = min(d1,d2);int i,j,k=0;tmpt = new int[10000];//分离d区域for(i=left;i<=right;i++){if(Math.abs(point[mid].x-point[i].x) < d) tmpt[k++] = i;}实验结果:数据文件:点的显示:结果显示:实验总结:按照分治法,可以很方便的解决这个问题。

虽然心里还是很排斥递归,但是真正用到的话还是比较简洁的。

另外最开始做这个实验的时候,还不太熟悉比较器,本来是可以直接把点记录下来的,但当时是将点的值存入到数组以后再排序的,所以没能很方便的读出最近点的坐标,这个有时间再进行改进。

实验三拓扑排序实验目的:实现一个拓扑排序实现原理:由AOV网构造拓扑序列的拓扑排序算法主要是循环执行以下两步,直到不存在入度为0的顶点为止。

(1) 选择一个入度为0的顶点并输出之;(2) 从网中删除此顶点及所有出边。

循环结束后,若输出的顶点数小于网中的顶点数,则输出“有回路”信息,否则输出的顶点序列就是一种拓扑序列。

具体设计:1. 数据结构与DFS拓扑排序基本上和DFS没什么区别,它的本质其实就是DFS关闭节点的倒序输出。

所以在数据结构上,和第一个实验用的是相同的数据结构来保存图。

public int time;//记录打开、关闭节点的时间public int entertime,exittime;//打开、关闭节点的时间值得注意的是,以上两个变量,是用来实现拓扑排序的关键部分。

2. 拓扑排序的实现public void Toposortmethod(Graph G){MaxPQ<VNode> pq1= new MaxPQ<VNode>(new Comparator<VNode>() { public int compare(VNode o1, VNode o2) {if (o1.exittime < o2.exittime) return -1;else if (o1.exittime == o2.exittime) return 0;else return 1;}});GrahpFuntion.DFS1(G);for(int i=1;i<=G.vexmun;i++){pq1.insert(G.arrVnode[i]);}System.out.println("拓扑排序顺序:");VNode Vnode;for(int i=1;i<=G.vexmun;i++){ Vnode=pq1.delMax();System.out.println(Vnode.data); }}实验结果:数据文件:结果显示:上面那个是因为调用了DFS而产生的DFS输出结果实验总结:由于有了之前的铺垫,所以拓扑排序相对来说比较简单,我只是在图的设计类中添加了一个时间变量,而在节点的打开、关闭的过程中增加了时间。

拓扑排序是计算机网络的基础,在很多地方都有体现,值得我们注意。

实验四 N皇后问题实验目的:应用回溯法解决N皇后问题实现原理:(1)针对所给问题,定义问题的解空间;(2)确定易于搜索的解空间结构;(3)以深度优先的方式搜索解空间,并且在搜索过程中用剪枝函数避免无效搜索。

首先找出解空间:给棋盘的行和列都编上1到N的号码,皇后也给编上1到N的号码。

由于一个皇后应在不同的行上,为不失一般性,可以假定第i个皇后将放在第i行上的某列。

相关文档
最新文档