北京理工大学《数据结构与算法设计》实验报告实验一

合集下载

北京理工大学数据结构实验报告一

北京理工大学数据结构实验报告一
实验报告一:线性表
班级:05111451姓名:任子龙学号:1120140167
1、需求分析
1.学生成绩利用单链表存储,方便随时插入和删除学生成绩记录,实现动态管理,一个学生的成绩信息作为一个结点。
2.程序以用户和计算机对话的方式执行,即在计算机终端上显示“提示信息”之后,用户在键盘上输入规定的数据,回车后,运算结果显示在其后。
p->next=NULL;
head=p;
printf("\t输入需要录入信息的学生人数\n");
scanf("%d",&n);
for(i=0;i<n;i++)//该循环语句是用来输入录入学生的各类信息//
{ q=(student*)malloc(sizeof(student));
q->num=i+1;
//若1≤i≤n,则在L的第i个元素后面插入新元素e。
voidDeletenode(&L,i);
//若1≤i≤n,则删除L的第i个元素。
其中,部分操作的伪码算法如下:
void input(){ //输入学生成绩信息//
int i=0,j=0,n;
p=(student*)malloc(sizeof(student));//申请空间,创建带头结点的空指针
p=head;
if(!p) {printf("提示:系统尚未录入任何信息!\n");exit(0);
}
p=head->next;
while(flag&&p)
{
if(p->studentnum==stdnum)
{
printf("学生的成绩信息如下:\n");

数据结构与算法分析实验报告

数据结构与算法分析实验报告

数据结构与算法分析实验报告一、实验目的本次实验旨在通过实际操作和分析,深入理解数据结构和算法的基本概念、原理和应用,提高解决实际问题的能力,培养逻辑思维和编程技巧。

二、实验环境本次实验使用的编程语言为 Python,使用的开发工具为 PyCharm。

操作系统为 Windows 10。

三、实验内容(一)线性表的实现与操作1、顺序表的实现使用数组实现顺序表,包括插入、删除、查找等基本操作。

通过实验,理解了顺序表在内存中的存储方式以及其操作的时间复杂度。

2、链表的实现实现了单向链表和双向链表,对链表的节点插入、删除和遍历进行了实践。

体会到链表在动态内存管理和灵活操作方面的优势。

(二)栈和队列的应用1、栈的实现与应用用数组和链表分别实现栈,并通过表达式求值的例子,展示了栈在计算中的作用。

2、队列的实现与应用实现了顺序队列和循环队列,通过模拟银行排队的场景,理解了队列的先进先出特性。

(三)树和二叉树1、二叉树的遍历实现了先序、中序和后序遍历算法,并对不同遍历方式的结果进行了分析和比较。

2、二叉搜索树的操作构建了二叉搜索树,实现了插入、删除和查找操作,了解了其在数据快速查找和排序中的应用。

(四)图的表示与遍历1、邻接矩阵和邻接表表示图分别用邻接矩阵和邻接表来表示图,并比较了它们在存储空间和操作效率上的差异。

2、图的深度优先遍历和广度优先遍历实现了两种遍历算法,并通过对实际图结构的遍历,理解了它们的应用场景和特点。

(五)排序算法的性能比较1、常见排序算法的实现实现了冒泡排序、插入排序、选择排序、快速排序和归并排序等常见的排序算法。

2、算法性能分析通过对不同规模的数据进行排序实验,比较了各种排序算法的时间复杂度和空间复杂度。

四、实验过程及结果(一)线性表1、顺序表在顺序表的插入操作中,如果在表头插入元素,需要将后面的元素依次向后移动一位,时间复杂度为 O(n)。

删除操作同理,在表头删除元素时,时间复杂度也为 O(n)。

数据结构与算法实习_实验指导书

数据结构与算法实习_实验指导书

数据结构与算法实习_实验指导书数据结构与算法课程实习实验指导书目录实验一顺序表的基本操作 (2)实验二链表的基本操作 (3)实验三二叉树的基本操作 (4)实验四综合应用 (5)附录A 实验报告示例 (9)附录B实验报告封面、评语得分表 (12)实验一顺序表的基本操作【实验目的】1、掌握顺序存储的概念,学会对顺序表的基本操作。

2、加深对顺序存储数据结构的理解,逐步培养解决实际问题的能力。

【实验性质】设计型实验【实验内容】1、实现顺序表显示;2、实现顺序表插入;3、实现顺序表查找(显示比较次数);4、实现顺序表删除(显示移动次数);5、实现顺序表排序(分别实现简单选择、快速,显示比较次数、移动次数);6、实现顺序表的折半查找(显示比较次数);7、编程实现一个顺序表的就地逆置,即利用原表的存储空间将顺序表逆置;8顺序表有序插入(显示比较次数、移动次数),屏幕提示后,从键盘输入一个元素值,在经过排序的线性表中插入这个元素;屏幕显示比较次数和移动次数,应有溢出判断和报告;9、要求以较高的效率实现删除顺序表中元素值在x到y(x和y自定)之间的所有元素;10、编程实现将两个非递减的顺序表进行合并,要求同样的数据元素只出现一次;*11、编程实现顺序表的shell排序(步长为5, 3,1);*12、编程实现堆排序算法;*13、利用三元组顺序表存储矩阵,实现矩阵的转置(请独立写程序实现)。

【实验环境】VC++ 6.0【实验要求】将如上文件保存在命名为学号+姓名”勺文件夹中并上传到指定的服务器。

实验二链表的基本操作【实验目的】1、掌握链表的概念,学会对链表进行操作。

2、加深对链式存储结构的理解,逐步培养解决实际问题的编程能力。

【实验性质】设计型实验【实验内容】1、实现单链表的创建;2、实现单链表的显示;3、实现单链表的查找(显示比较次数);4、实现单链表的插入;5、实现单链表的删除(显示比较次数);6、对已创建的链表(数据不限)进行直接插入排序;7、将链接存储线性表逆置,即最后一个结点变成第1个结点,原来倒数第2个结点变成第2个结点,如此等等;8、生成有序的两个单链表A和B (链表的数据和个数自定),其首结点指针分别为a 和b,要求将两个单链表合并为一个有序的单链表C,其首结点指针为c,并且合并后的单链表的数据不重复;9、将一个首结点指针为a的单链表A分解成两个单链表A和B,其首结点指针分别为a和b,使得链表A中含有原链表A中序号为奇数的元素,而链表B中含有原链表A中序号为偶数的元素,且保持原来的相对顺序;10、请编程实现链栈的基本操作函数,并通过调用这些基本函数,实现十进制和八进制转换的功能。

数据结构与算法 图的结构和操作实验报告

数据结构与算法  图的结构和操作实验报告

《数据结构与算法分析》课程实验报告【实验目的】1. 理解图形结构的逻辑和存储特点。

2. 掌握图形结构遍历递归算法。

【实验内容】1. 用邻接矩阵或者邻接表存储一个图形结构。

2. 采用深度或者广度优先搜索算法,遍历一个图,并输出遍历结果。

【实验方式】个人实验。

【实验设备与环境】PC机,Windows XP操作系统,VC++6.0开发环境。

【数据结构及函数定义】(1)类的定义:类的数据成员,成员函数...................(2)主函数main()实现初始化操作,完成对子函数的调用...................(3)子函数...................。

【测试数据与实验结果】(请用截图的方式展示实验结果,并辅以必要的文字说明)【源程序清单】(请附上源程序)#include<iostream>using namespace std;#include<string.h>class Graph{public:c har Vtx[20];d ouble AdjMtx[20][20];i nt CurrentVnum;i nt CurrentEnum;G raph(){CurrentVnum=CurrentEnum=0;} i nt first_adj(int v);i nt next_adj(int v1,int v2);v oid visite(int v);v oid DFS();v oid DFS(int v,int visited[]);~Graph(){}};int Graph::first_adj(int v){f or(int v1=0;v1<CurrentVnum;v1++)if(AdjMtx[v][v1]>0)return v1;return -1;}int Graph::next_adj(int v1,int v2) {f or(int vn=v2+1;vn<CurrentVnum;vn++)if(AdjMtx[v1][vn]>0)return vn;return -1;}void Graph::visite(int v){c out<<Vtx[v]<<" ";}void Graph::DFS(){i nt *visited=new int[CurrentVnum];f or(int i=0;i<CurrentVnum;i++)visited[i]=0;f or(i=0;i<CurrentVnum;i++){if(visited[i]==0)DFS(i,visited);}d elete[] visited;}void Graph::DFS(int v,int visited[]) {v isite(v);v isited[v]=1;i nt w=first_adj(v);w hile(w!=-1){if(!visited[w])DFS(w,visited);w=next_adj(v,w);}}int LocateVex(Graph G,char u){i nt i;f or(i=0;i<G.CurrentVnum;i++)if(u==G.Vtx[i])return i;return -1;}void creat(Graph &G){i nt i,j,k;c har va,vb;c out<<"请输入图的顶点数,弧数:";c in>>G.CurrentVnum>>G.CurrentEnum;c out<<"请输入"<<G.CurrentVnum<<"个顶点的值:";f or(i=0;i<G.CurrentVnum;i++)cin>>G.Vtx[i];f or(i=0;i<G.CurrentVnum;i++)for(j=0;j<G.CurrentVnum;j++)G.AdjMtx[i][j]=0;c out<<"请输入"<<G.CurrentEnum<<"条弧的弧尾,弧头(以空格作为间隔):\n";f or(k=0;k<G.CurrentEnum;k++){cin>>va>>vb;i=LocateVex(G,va);j=LocateVex(G,vb);if(i!=j){G.AdjMtx[i][j]=1;G.AdjMtx[j][i]=1;}else G.AdjMtx[i][j]=1;}}void main(){G raph G;c reat(G);c out<<"深度优先搜索序列:"<<endl;G.DFS();c out<<endl;。

北京理工大学《数据结构与算法设计》实验报告完整版

北京理工大学《数据结构与算法设计》实验报告完整版

《数据结构与算法设计》实验报告——实验一学院:班级:学号:姓名:一、实验目的1.通过实验实践、巩固线性表的相关操作;2.熟悉VC环境,加强编程、调试的练习;3.用C语言编写函数,实现循环链表的建立、插入、删除、取数据等基本操作;4.理论知识与实际问题相结合,利用上述基本操作实现约瑟夫环。

二、实验内容1、采用单向环表实现约瑟夫环。

请按以下要求编程实现:①从键盘输入整数m,通过create函数生成一个具有m个结点的单向环表。

环表中的结点编号依次为1,2,……,m。

②从键盘输入整数s(1<=s<=m)和n,从环表的第s个结点开始计数为1,当计数到第n个结点时,输出该第n结点对应的编号,将该结点从环表中消除,从输出结点的下一个结点开始重新计数到n,这样,不断进行计数,不断进行输出,直到输出了这个环表的全部结点为止。

三、程序设计1、概要设计为实现上述程序功能,应用单向环表寄存编号,为此需要建立一个抽象数据类型:单向环表。

(1)、单向环表的抽象数据类型定义为:ADT Joseph{数据对象:D={ai|ai∈ElemSet,i=1,2,3……,n,n≥0}数据关系:R1={ <ai-1,ai>|ai∈D,i=1,2,……,n}基本操作:create(&L,n)操作结果:构造一个有n个结点的单向环表L。

show(L)初始条件:单向环表L已存在。

操作结果:按顺序在屏幕上输出L的数据元素。

Josephf( L,m,s,n)初始条件:单向环表L已存在, s>0,n>0,s<m。

操作结果:返回约瑟夫环的计算结果。

}ADT Joseph(2)、主程序流程主程序首先调用create(&L,n)函数,创建含有m个节点的单向环表L,然后调用show(L)函数,顺序输出链表中的数据,最后调用Josephf( L,m,s,n)函数,依次输出报的数。

(3)、函数调用关系图2、详细设计(1)、数据类型设计typedef int ElemType; //定义元素类型typedef struct Lnode{ElemType data;struct Lnode *next;}Lnode,*Linklist; //定义节点类型,指针类型(2)、操作算法程序实现:void create(Linklist &L,int m){//生成一个具有m个结点的单向环表,环表中的结点编号依次为1,2,……,m Linklist h,p;L=(Linklist)malloc(sizeof(Lnode));L->data = 1;h=L;for(int i=2;i<=m;i++){p = (Linklist)malloc(sizeof(Lnode));p->data = i; //生成新节点,数据为节点编号h->next = p;h = p; //插入链表}h->next = L; //形成循环链表}void show(Linklist L,int m){//从第一个节点开始依次输出节点编号printf("The numbers of the list are: \n"); //提示用户Linklist h;h=L;for(int i=1;i<=m;i++){printf("%d ",h->data);h = h->next;}printf("\n");}void Josephf(Linklist &L,int m,int s,int n){//实现约瑟夫环Linklist h,q;h = L;q = L;while(h->data != s) //定位开始的节点h = h->next;while(q->next!=h) //定位在开始位置的上一个节点q = q->next;for(int j=1;j<=m;j++){int i=1;while(i<n){q=q->next;i++;}printf("%d ",q->next->data); //依次输出报号为n的节点q->next = q->next->next; //删除已输出节点}printf("\n");}(3)、主程序的代码实现:int main(){int s,m,n;Linklist L;printf("请输入节点数m:\n");scanf("%d",&m);create(L,m); //建立循环链表show(L,m); //输出链表数据printf("请输入起始位置s:\n");scanf("%d",&s);printf("请输入报的数n:\n");scanf("%d",&n);Josephf(L,m,s,n); //输出所报数字return 0;}四、程序调试分析1.引用标识符&不符合C语言语法,应使用C++;2.为了实现循环链表,建立时应该不设头结点且第一个节点就存储编号数据;3.删除节点时要定位到前一个指针,所以在定位开始位置后还要再定位到前一个指针;4.输出时要注意增加“ ”(空格)和“\n”(换行),使输出易于辨识。

《数据结构和算法设计》实验报告

《数据结构和算法设计》实验报告

《数据结构与算法设计》实验报告——实验二一、实验目的按照四则运算加、减、乘、除、幂(^)和括号的优先关系和惯例,编写计算器程序。

二、实验内容简单计算器。

请按照四则运算加、减、乘、除、幂(^)和括号的优先关系和惯例,编写计算器程序。

要求:①从键盘输入一个完整的表达式,以回车作为表达式输入结束的标志。

②输入表达式中的数值均为大于等于零的整数。

中间的计算过程如果出现小数也只取整。

例如,输入:4+2*5= 输出:14输入:(4+2)*(2-10)= 输出:-48三、程序设计概要设计1、宏定义#define TRUE 1#define FALSE 0#define OK 1#define ERROR 02、基本函数:(1)void InitStack_char(SqStack *S) //char型栈初始化(2)void InitStack_int(sqStack *S) //int型栈初始化(3)void Push_char(SqStack *S,char ch) //char型元素进栈(4)void Push_int(sqStack *S,int num) //int型元素进栈(5)char GetTop_char(SqStack *S) //取char型栈顶元素(6)int GetTop_int(sqStack *S) //取int型栈顶元素(7)Status In(char c) //判断是否为运算符,若是运算符则返回,否则返回(8)char Precede(char a,char b) //判断两运算符的先后次序(9)Status Pop_char(SqStack *S,char &x) //char型栈出栈(10)Status Pop_int(sqStack *S,int &x) //int型栈出栈(11)int Operate(int a,char theta,int b) //计算a和b运算结果3、流程图详细设计数据类型typedef struct node //构造char型栈{char ch;struct node *next;}node;typedef struct{struct node *base;struct node *top;}SqStack;typedef struct lnode //构造int型栈{int num;struct lnode *next;}lnode;typedef struct{struct lnode *base;struct lnode *top;}sqStack;操作部分void InitStack_char(SqStack *S){S->base = (node *)malloc(sizeof(node));S->base->next=NULL;S->top = S->base;} //char型栈初始化void InitStack_int(sqStack *S){S->base = (lnode *)malloc(sizeof(lnode));S->base->next=NULL;S->top = S->base;} //int型栈初始化void Push_char(SqStack *S,char ch){node *p;p=(node*)malloc(sizeof(node));p->ch=ch;p->next=S->top;S->top=p;} //char型元素进栈Status Push_int(sqStack *S,int num){lnode *p;p=(lnode*)malloc(sizeof(lnode));p->num=num;p->next=S->top;S->top=p;return OK;} //int型元素进栈char GetTop_char(SqStack *S){return (S->top->ch);} //取char型栈顶元素int GetTop_int(sqStack *S){return (S->top->num);} //取int型栈顶元素Status Pop_char(SqStack *S,char &x){if(S->base == S->top)return ERROR;node *p;p=S->top;x=p->ch;S->top=p->next;free(p);return OK;} //char型栈出栈Status Pop_int(sqStack *S,int &x){if(S->base == S->top)return ERROR;lnode *p;p=S->top;x=p->num;S->top=p->next;free(p);return OK;} //int型栈出栈计算功能int Operate(int a,char theta,int b){int i,z = 1;switch(theta){case '+':z = (a + b);break;case '-':z = (a - b);break;case '*':z = (a * b);break;case '/':z = (a / b);break;case '^':for(i = 1;i<=b;i++)z = z*a;break;}return (z);} //计算a和b运算结果Status In(char c){if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='='||c=='^') return OK;elsereturn ERROR;} //判断是否为运算符char Precede(char a,char b){if(a=='+'||a=='-'){if(b=='+'||b=='-'||b==')'||b=='=')return '>';elsereturn '<';}if(a=='*'||a=='/'){if(b=='('||b=='^')return '<';elsereturn '>';}if(a=='('){if(b==')')return '=';elsereturn '<';}if(a==')'){if(b!='(')return '>';}if(a=='#'){if(b=='=')return '=';elsereturn '<';}if(a=='^')return ('>');} //判断两运算符的先后次序主函数int main() //主函数{char c,x,theta;int a,b,c1; //定义变量SqStack OPTR; //定义字符栈sqStack OPNR; //定义整型栈InitStack_char(&OPTR); //初始化InitStack_int(&OPNR); //初始化Push_char(&OPTR,'#'); //将字符型栈底设为#c = getchar(); //从键盘输入得到字符while(c!='='||GetTop_char(&OPTR)!='#') //判定是否执行循环if(!In(c)){c1 = 0;while(!In(c)){c1 = c1*10+c-'0';c = getchar();}Push_int(&OPNR,c1);} //当扫描字符不是运算符时,转化为整型数存入栈中else{switch(Precede(GetTop_char(&OPTR),c)) //判定运算符的优先关系{case '<':Push_char(&OPTR,c);c = getchar();break; //当前运算符优先级高,存入char栈case '=':Pop_char(&OPTR,c);c = getchar();break; //运算符次序相等,存入char栈case '>': //当前运算符优先级低Pop_char(&OPTR,theta);Pop_int(&OPNR,b);Pop_int(&OPNR,a);Push_int(&OPNR, Operate(a,theta,b));//计算运算结果,并存入int栈break; //继续循环}}printf("%d\n",GetTop_int(&OPNR)); //计算完成,取出int栈顶元素,并输出return 0;}四、程序调试分析编写程序的过程中遇到了很多的问题,最突出的两个问题就是整数和两位数的运算处理,一开始修改了主函数部分之后,原来可以执行一位数运算的程序出现了error,由于没有及时保存,并且之前的代码无法恢复,只得重新编写一次。

数据结构与算法实验报告

数据结构与算法实验报告

数据结构实验报告题目:线性表班级:网络工程1401班学号: 1408020106指导教师:高峰日期: 2016/7/6实验一:线性表一:实验要求掌握数据结构中线性表的基本概念。

熟练掌握线性表的基本操作:创建、插入、删除、查找、输出、求长度及合并并运算在顺序存储结构撒谎能够的实验。

熟练掌握链表的各种操作和应用。

二.实验内容1. 编程实现在顺序存储的有序表中插入一个元素(数据类型为整型)。

2. 编程实现把顺序表中从i个元素开始的k个元素删除(数据类型为整型)。

三:实验过程及步骤源代码:#include<stdio.h>#include<malloc.h>#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef struct{int * elem;int length;int listsize;}SqList;//SqList sq;void InitList_Sq(SqList *sq) //初始化列表{sq->elem=(int *)malloc(LIST_INIT_SIZE*sizeof(int));sq->length=0;sq->listsize=LIST_INIT_SIZE;printf("---申请空间成功---!\n");}void GetElem(SqList *sq,int i)//获取第i位置元素的值{int *p;p=&(sq->elem[i-1]);printf("%d",*p);printf("\n");}int ListInsert_Sq(SqList *sq,int i,int a)//在i位置之前插入a{int *p,*q;if(i<=0||i>sq->length+1){printf("---位置不合法---!\n");return 0;}if(sq->length>=sq->listsize){int* newbase=(int *)realloc(sq->elem,(sq->listsize+LISTINCREMENT)*sizeof(int)); if(!newbase){printf("申请空间溢出\n");return 0;}sq->elem=newbase;sq->listsize+=LISTINCREMENT;}p=&(sq->elem[i-1]);//p指向第i位置的元素q=&(sq->elem[sq->length-1]);//q指向最后一个元素for(;q>=p;--q) *(q+1)=*q;*p=a;++sq->length;return 1;}int ListDelete_Sq(SqList *sq,int i) //删除i位置上的值{int *p,*q;if(i<1||i>sq->length) return 0;p=&(sq->elem[i-1]);//p指向第i位置的元素q=sq->elem+sq->length-1;//q指向最后一个元素for(++p;p<=q;++p){*(p-1)=*p;}--sq->length;return 1;}void visit(SqList *sq)//输出数据{int i=1;for(;i<=sq->length;i++){int *p;p=&sq->elem[i-1];printf("%d",*p);printf(" ");}}void main(){int i=1,a=0,boo=1,number=0;SqList s,*sq;sq=&s;InitList_Sq(sq);printf("初始化空表\n");printf("输入数据个数:\n");scanf("%d",&number);printf("输入%d个数据:",number);printf("\n");for(;i<=number;i++){scanf("%d",&a);if(boo=ListInsert_Sq(sq,i,a)){printf("---插入成功!---\n");}else{printf("---插入不成功,重新插入---!\n"); i=i-1;}}printf("输出所有元素\n");visit(sq);printf("\n");printf("输出删除的位置:");scanf("%d",&a);if(boo=ListDelete_Sq(sq,a)){printf("---数据删除成功!---\n");}else{printf("---没有删除成功---\n");}printf("输出所有元素:\n");visit(sq);printf("\n");printf("输出要显示数据的位置:");scanf("%d",&a);printf("输出%d位置数值\n",a);if(a<0||a>sq->length){printf("---输出位置的数据不存在---\n");}else{GetElem(sq,a);}}步骤:1.初始化空表2.顺序插入数据后输出所有元素3.选择删除位置,删除数据后输出所有元素4.选择查看的数据位置,输出选择查看的数据四:实验结果及分析分析:本程序在实现顺序存储插入以及删除i个元素开始的k个元素删除(数据类型为整型)。

数据结构与算法实验报告

数据结构与算法实验报告

数据结构与算法实验报告实验目的:1.加深对链表的理解,掌握链表的基本操作;2.掌握递归算法的设计思想及应用。

实验内容:本次实验主要包括两个部分的实现与测试,分别为链表的基本操作及递归算法的应用。

一、链表的基本操作1.链表的创建链表的创建主要包括新建链表头结点和逐个插入新结点两个步骤。

首先通过malloc函数新建一个链表头结点,并使链表头结点的指针域为空。

然后通过循环输入新节点的数据值,并将新节点插入到链表的尾部。

2.链表的插入链表的插入操作主要包括在链表头部插入新节点、在链表尾部插入新节点和在链表中间插入新节点。

在插入链表头部时,首先通过malloc函数生成新节点,并将链表头节点指针域的原指向设置为新节点;在插入链表尾部时,首先通过循环找到链表的尾节点,并生成新节点,将尾节点指针域的原指向设置为新节点;在插入链表中间时,首先通过循环找到要插入的位置节点,然后生成新节点,并将新节点指针域的原指向设置为下一个节点,将前一个节点的指针域设置为新节点。

3.链表的删除链表的删除操作主要包括删除头节点、删除尾节点和删除中间节点。

在删除头节点时,首先通过free函数释放头节点的内存空间,然后将链表的头节点指针指向第二个节点;在删除尾节点时,首先通过循环找到倒数第二个节点,并将倒数第二个节点的指针域置空,最后通过free函数释放尾节点的内存空间;在删除中间节点时,首先通过循环找到要删除的节点的前一个节点,然后将前一个节点的指针域指向要删除节点的下一个节点,最后通过free函数释放要删除节点的内存空间。

4.链表的查询链表的查询操作主要包括按位置查询和按值查询。

在按位置查询时,通过循环找到指定位置的节点,然后返回节点的数据值;在按值查询时,通过循环比较节点的数据值与指定值,找到匹配的节点,并返回该节点的位置。

二、递归算法的应用递归算法是一种函数自己调用自己的算法设计思想,具有简洁、清晰的特点。

本次实验主要应用递归算法解决实际问题,包括斐波那契数列的求解和二叉树的遍历。

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

《数据结构与算法设计》
实验报告
——实验一
学院:
班级:
学号:
姓名:
一、实验目的
1.通过实验实践、巩固线性表的相关操作;
2.熟悉VC环境,加强编程、调试的练习;
3.用C语言编写函数,实现循环链表的建立、插入、删除、取数据等基本操作;
4.理论知识与实际问题相结合,利用上述基本操作实现约瑟夫环。

二、实验内容
1、采用单向环表实现约瑟夫环。

请按以下要求编程实现:
①从键盘输入整数m,通过create函数生成一个具有m个结点的单向环表。

环表中的
结点编号依次为1,2,……,m。

②从键盘输入整数s(1<=s<=m)和n,从环表的第s个结点开始计数为1,当计数到
第n个结点时,输出该第n结点对应的编号,将该结点从环表中消除,从输出结点
的下一个结点开始重新计数到n,这样,不断进行计数,不断进行输出,直到输出
了这个环表的全部结点为止。

三、程序设计
1、概要设计
为实现上述程序功能,应用单向环表寄存编号,为此需要建立一个抽象数据类型:单向环表。

(1)、单向环表的抽象数据类型定义为:
ADT Joseph{
数据对象:D={ai|ai∈ElemSet,i=1,2,3……,n,n≥0}
数据关系:R1={ <ai-1,ai>|ai∈D,i=1,2,……,n}
基本操作:
create(&L,n)
操作结果:构造一个有n个结点的单向环表L。

show(L)
初始条件:单向环表L已存在。

操作结果:按顺序在屏幕上输出L的数据元素。

Josephf( L,m,s,n)
初始条件:单向环表L已存在, s>0,n>0,s<m。

操作结果:返回约瑟夫环的计算结果。

}ADT Joseph
(2)、主程序流程
主程序首先调用create(&L,n)函数,创建含有m个节点的单向环表L,然后调用show(L)函数,顺序输出链表中的数据,最后调用Josephf( L,m,s,n)函数,依次输出报的数。

(3)、函数调用关系图
2、详细设计
(1)、数据类型设计
typedef int ElemType; //定义元素类型
typedef struct Lnode{
ElemType data;
struct Lnode *next;
}Lnode,*Linklist; //定义节点类型,指针类型
(2)、操作算法程序实现:
void create(Linklist &L,int m)
{
//生成一个具有m个结点的单向环表,环表中的结点编号依次为1,2,……,m Linklist h,p;
L=(Linklist)malloc(sizeof(Lnode));
L->data = 1;
h=L;
for(int i=2;i<=m;i++)
{
p = (Linklist)malloc(sizeof(Lnode));
p->data = i; //生成新节点,数据为节点编号
h->next = p;
h = p; //插入链表
}
h->next = L; //形成循环链表
}
void show(Linklist L,int m)
{
//从第一个节点开始依次输出节点编号
printf("The numbers of the list are: \n"); //提示用户
Linklist h;
h=L;
for(int i=1;i<=m;i++)
{
printf("%d ",h->data);
h = h->next;
}
printf("\n");
}
void Josephf(Linklist &L,int m,int s,int n)
{
//实现约瑟夫环
Linklist h,q;
h = L;
q = L;
while(h->data != s) //定位开始的节点
h = h->next;
while(q->next!=h) //定位在开始位置的上一个节点q = q->next;
for(int j=1;j<=m;j++)
{
int i=1;
while(i<n)
{
q=q->next;
i++;
}
printf("%d ",q->next->data); //依次输出报号为n的节点
q->next = q->next->next; //删除已输出节点
}
printf("\n");
}
(3)、主程序的代码实现:
int main()
{
int s,m,n;
Linklist L;
printf("请输入节点数m:\n");
scanf("%d",&m);
create(L,m); //建立循环链表
show(L,m); //输出链表数据
printf("请输入起始位置s:\n");
scanf("%d",&s);
printf("请输入报的数n:\n");
scanf("%d",&n);
Josephf(L,m,s,n); //输出所报数字。

相关文档
最新文档