数据结构实验题参考答案
国家开放大学《数据结构》课程实验报告(实验2——线性表)参考答案
{
output(p);
p=p->next;
}
printf("\n");
}
//输出最高分及最低分评委信息,删除最高分及最低分结点并计算参赛者的最后平均分
void calc(NODE *head)
{
NODE *q,*p,*pmin,*pmax;
float sum=0; //总分
导
教
师
评
语
指导教师 日期
printf("\n");
//在链表中删除最高分和最低分结点
for(q=head,p=head->next;p!=NULL;q=p,p=p->next)
{
if(p==pmin) { q->next=p->next; p=q; } //删除最低分结点
if(p==pmax) { q->next=p->next; p=q; } //删除最高分结点
p=p->next;
}
//输出最高分及最低分评委信息
printf("给出最高分的评委姓名:%6s年龄:%d评分:%6.2f\n",pmax->,pmax->data.age,pmax->data.score);
printf("给出最低分的评委姓名:%6s年龄:%d评分:%6.2f\n",pmin->,pmin->data.age,pmin->data.score);
float ave=0; //平均分
//查找最高分和最低分并计算总分
p=head->next;
pmin=pmax=p;
数据结构实验报告答案
数据结构实验报告答案数据结构实验报告答案引言:数据结构是计算机科学中的重要概念,它涉及组织和管理数据的方法和技术。
在本次实验中,我们将研究和实践几种常见的数据结构,包括数组、链表、栈和队列。
通过这些实验,我们将深入理解数据结构的原理和应用。
一、数组数组是一种线性数据结构,它由一系列相同类型的元素组成。
数组的特点是可以通过索引来访问和修改元素,具有随机访问的能力。
在本次实验中,我们将实现一个简单的数组类,并进行一些基本操作,如插入、删除和查找。
首先,我们定义一个数组类,包含以下成员变量和方法:- size:数组的大小- elements:存储元素的数组- insert(index, element):在指定位置插入元素- remove(index):删除指定位置的元素- get(index):获取指定位置的元素- search(element):查找元素在数组中的位置通过实现上述方法,我们可以对数组进行各种操作。
例如,我们可以在数组的末尾插入一个元素,然后在指定位置删除一个元素。
我们还可以通过元素的值来查找其在数组中的位置。
二、链表链表是另一种常见的线性数据结构,它由一系列节点组成,每个节点包含一个数据元素和一个指向下一个节点的指针。
链表的特点是插入和删除操作的效率较高,但随机访问的效率较低。
在本次实验中,我们将实现一个简单的单向链表,并进行一些基本操作。
首先,我们定义一个节点类,包含以下成员变量和方法:- data:节点的数据元素- next:指向下一个节点的指针然后,我们定义一个链表类,包含以下成员变量和方法:- head:链表的头节点- insert(element):在链表的末尾插入一个节点- remove(element):删除链表中指定的节点- search(element):查找链表中指定元素的节点通过实现上述方法,我们可以对链表进行各种操作。
例如,我们可以在链表的末尾插入一个节点,然后删除链表中指定的节点。
数据结构实验报告-答案.doc
数据结构实验报告-答案数据结构(C语言版)实验报告专业班级学号姓名实验1实验题目:单链表的插入和删除实验目的:了解和掌握线性表的逻辑结构和链式存储结构,掌握单链表的基本算法及相关的时间性能分析。
实验要求:建立一个数据域定义为字符串的单链表,在链表中不允许有重复的字符串;根据输入的字符串,先找到相应的结点,后删除之。
实验主要步骤:1、分析、理解给出的示例程序。
2、调试程序,并设计输入数据(如:bat,cat,eat,fat,hat,jat,lat,mat,#),测试程序的如下功能:不允许重复字符串的插入;根据输入的字符串,找到相应的结点并删除。
3、修改程序:(1)增加插入结点的功能。
(2)将建立链表的方法改为头插入法。
程序代码:#include“stdio.h“#include“string.h“#include“stdlib.h“#include“ctype. h“typedefstructnode//定义结点{chardata[10];//结点的数据域为字符串structnode*next;//结点的指针域}ListNode;typedefListNode*LinkList;//自定义LinkList单链表类型LinkListCreatListR1();//函数,用尾插入法建立带头结点的单链表LinkListCreatList(void);//函数,用头插入法建立带头结点的单链表ListNode*LocateNode();//函数,按值查找结点voidDeleteList();//函数,删除指定值的结点voidprintlist();//函数,打印链表中的所有值voidDeleteAll();//函数,删除所有结点,释放内存ListNode*AddNode();//修改程序:增加节点。
用头插法,返回头指针//==========主函数==============voidmain(){charch[10],num[5];LinkListhead;head=C reatList();//用头插入法建立单链表,返回头指针printlist(head);//遍历链表输出其值printf(“Deletenode(y/n):“);//输入“y“或“n“去选择是否删除结点scanf(“%s“,num);if(strcmp(num,“y“)==0||strcmp(num,“Y“)==0){printf(“PleaseinputDelete_data:“);scanf(“%s“,ch);//输入要删除的字符串DeleteList(head,ch);printlist(head);}printf(“Addnode?(y/n):“);//输入“y“或“n“去选择是否增加结点scanf(“%s“,num);if(strcmp(num,“y“)==0||strcmp(num,“Y“)==0){head=A ddNode(head);}printlist(head);DeleteAll(head);//删除所有结点,释放内存}//==========用尾插入法建立带头结点的单链表===========LinkListCreatListR1(void){charch[10];LinkListhead=(Li nkList)malloc(sizeof(ListNode));//生成头结点ListNode*s,*r,*pp;r=head;r->next=NULL;printf(“Input#toend“);//输入“#“代表输入结束printf(“\nPleaseinputN ode_data:“);scanf(“%s“,ch);//输入各结点的字符串while(strcmp(ch,“#“)!=0){pp=LocateNode(head,ch);//按值查找结点,返回结点指针if(pp==NULL){//没有重复的字符串,插入到链表中s=(ListNode*)malloc(sizeof(ListNode));strcpy(s->data,ch);r->next=s;r=s; r->next=NULL;}printf(“Input#toend“);printf(“PleaseinputNode_data:“);scanf(“%s“,ch);}returnhead;//返回头指针}//==========用头插入法建立带头结点的单链表===========LinkListCreatList(void){charch[100];LinkListhead,p;head =(LinkList)malloc(sizeof(ListNode));head->next=NULL;while(1){printf(“Input#toend“);printf(“PleaseinputNode_data:“);scanf(“%s“,ch);if(strcmp (ch,“#“)){if(LocateNode(head,ch)==NULL){strcpy(head->data,ch);p=(Li nkList)malloc(sizeof(ListNode));p->next=head;head=p;}}elsebreak;}retu rnhead;}//==========按值查找结点,找到则返回该结点的位置,否则返回NULL==========ListNode*LocateNode(LinkListhead,char*key){List Node*p=head->next;//从开始结点比较while(p!=NULL//扫描下一个结点returnp;//若p=NULL则查找失败,否则p指向找到的值为key的结点}//==========修改程序:增加节点=======ListNode*AddNode(LinkListhead){charch[10];ListNode*s,*pp ;printf(“\nPleaseinputaNewNode_data:“);scanf(“%s“,ch);//输入各结点的字符串pp=LocateNode(head,ch);//按值查找结点,返回结点指针printf(“ok2\n“);if(pp==NULL){//没有重复的字符串,插入到链表中s=(ListNode*)malloc(sizeof(ListNode));strcpy(s->data,ch);printf(“ok3\n“);s->next=head->next;head->next=s;}returnhead;}//==========删除带头结点的单链表中的指定结点=======voidDeleteList(LinkListhead,char*key){ListNode*p,*r,*q=hea d;p=LocateNode(head,key);//按key值查找结点的if(p==NULL){//若没有找到结点,退出printf(“positionerror”);exit(0);}while(q->next!=p)//p 为要删除的结点,q为p的前结点q=q->next;r=q->next;q->next=r->next;free(r);//释放结点}//===========打印链表=======voidprintlist(LinkListhead){ListNode*p=head->next;//从开始结点打印while(p){printf(“%s,“,p->data);p=p->next;}printf(“\n“);}//==========删除所有结点,释放空间===========voidDeleteAll(LinkListhead){ListNode*p=head,*r;while( p->next){r=p->next;free(p);p=r;}free(p);}实验结果:Input#toendPleaseinputNode_data:batInput#toendPleaseinputNode_data: catInput#toendPleaseinputNode_data:eatInput#toendPleaseinputNode_da ta:fatInput#toendPleaseinputNode_data:hatInput#toendPleaseinputNode_ data:jatInput#toendPleaseinputNode_data:latInput#toendPleaseinputNode _data:matInput#toendPleaseinputNode_data:#mat,lat,jat,hat,fat,eat,cat,bat ,Deletenode(y/n):yPleaseinputDelete_data:hatmat,lat,jat,fat,eat,cat,bat,Ins ertnode(y/n):yPleaseinputInsert_data:putposition:5mat,lat,jat,fat,eat,put,c at,bat,请按任意键继续...示意图:latjathatfateatcatbatmatNULLheadlatjathatfateatcatbatmatheadlatjatfateat putcatbatmatheadNULLNULL心得体会:本次实验使我们对链表的实质了解更加明确了,对链表的一些基本操作也更加熟练了。
数据结构实验答案
# include
# define maxnum 20
typedef int DataType ;
typedef struct
{ DataType data[maxnum] ;
int length ;
}SeqList ;
int MergeQL(SeqList la , SeqList lb , SeqList *lc)
实验一 线性表的顺序存储实验
一,实验目的
1,掌握用Visual C++6.0上机调试顺序表的基本方法
2,掌握顺序表的基本操作,插入,删除,查找,以及有序顺序表的合并等算法的实现
二,实验内容
1,顺序表基本操作的实现
[问题描述] 当我们要在顺序表的第i个位置上插入一个元素时,必须先将顺序表中第i个元素之后的所有元素依次后移一个位置,以便腾空一个位置,再把新元素插入到该位置.若是欲删除第i个元素时,也必须把第i个元素之后的所有元素前移一个位置.
ListNode *s,*r; /*工作指针*/
r=head; /*尾指针初值也指向头结点*/
while((ch=getchar())!='\n')
{
s=(ListNode *)malloc(sizeof(ListNode));
s->data=ch;
r->next=s;
r=s;
}
(*L)->next=NULL;
}
int List_Length(ListNode *L )
{
int n=0;ListNode *p=L->next;
while(p!=NULL)
国家开放大学《数据结构》课程实验报告(实验3 ——栈、队列、递归设计)参考答案
x=Pop(s); /*出栈*/
printf("%d ",x);
InQueue(sq,x); /*入队*/
}
printf("\n");
printf("(10)栈为%s,",(StackEmpty(s)?"空":"非空"));
printf("队列为%s\n",(QueueEmpty(sq)?"空":"非空"));
ElemType Pop(SeqStack *s); /*出栈*/
ElemType GetTop(SeqStack *s); /*取栈顶元素*/
void DispStack(SeqStack *s); /*依次输出从栈顶到栈底的元素*/
void DispBottom(SeqStack *s); /*输出栈底元素*/
} SeqQueue; /*定义顺序队列*/
void InitStack(SeqStack *s); /*初始化栈*/
int StackEmpty(SeqStack *s); /*判栈空*/
int StackFull(SeqStack *s); /*判栈满*/
void Push(SeqStack *s,ElemType x); /*进栈*/
sq=(SeqQueue *)malloc(sizeof(SeqQueue));
InitQueue(sq);
printf("(8)队列为%s\n",(QueueEmpty(sq)?"空":"非空"));
printf("(9)出栈/入队的元素依次为:");
数据结构(第4版)习题及实验参考答案数据结构复习资料完整版(c语言版)
数据结构(第4版)习题及实验参考答案数据结构复习资料完整版(c语言版)数据结构基础及深入及考试习题及实验参考答案见附录结论1、数据的逻辑结构是指数据元素之间的逻辑关系。
即从逻辑关系上描述数据,它与数据的存储无关,是独立于计算机的。
2、数据的物理结构亦称存储结构,是数据的逻辑结构在计算机存储器内的表示(或映像)。
它依赖于计算机。
存储结构可分为4大类:顺序、链式、索引、散列3、抽象数据类型:由用户定义,用以表示应用问题的数据模型。
它由基本的数据类型构成,并包括一组相关的服务(或称操作)。
它与数据类型实质上是一个概念,但其特征是使用与实现分离,实行封装和信息隐蔽(独立于计算机)。
4、算法:是对特定问题求解步骤的一种描述,它是指令的有限序列,是一系列输入转换为输出的计算步骤。
5、在数据结构中,从逻辑上可以把数据结构分成(C)A、动态结构和表态结构B、紧凑结构和非紧凑结构C、线性结构和非线性结构D、内部结构和外部结构6、算法的时间复杂度取决于(A)A、问题的规模B、待处理数据的初态C、问题的规模和待处理数据的初态线性表1、线性表的存储结构包括顺序存储结构和链式存储结构两种。
2、表长为n的顺序存储的线性表,当在任何位置上插入或删除一个元素的概率相等时,插入一个元素所需移动元素的平均次数为(E),删除一个元素需要移动的元素的个数为(A)。
A、(n-1)/2B、nC、n+1D、n-1E、n/2F、(n+1)/2G、(n-2)/23、“线性表的逻辑顺序与存储顺序总是一致的。
”这个结论是(B)A、正确的B、错误的C、不一定,与具体的结构有关4、线性表采用链式存储结构时,要求内存中可用存储单元的地址(D)A、必须是连续的B、部分地址必须是连续的C一定是不连续的D连续或不连续都可以5、带头结点的单链表为空的判定条件是(B)A、head==NULLB、head->ne某t==NULLC、head->ne某t=headD、head!=NULL6、不带头结点的单链表head为空的判定条件是(A)A、head==NULLB、head->ne某t==NULLC、head->ne某t=headD、head!=NULL7、非空的循环单链表head的尾结点P满足(C)A、p->ne某t==NULLB、p==NULLC、p->ne某t==headD、p==head8、在一个具有n个结点的有序单链表中插入一个新结点并仍然有序的时间复杂度是(B)A、O(1)B、O(n)C、O(n2)D、O(nlog2n)数据结构(第4版)习题及实验参考答案9、在一个单链表中,若删除p所指结点的后继结点,则执行(A)A、p->ne某t=p->ne某t->ne某t;B、p=p->ne某t;p->ne某t=p->ne某t->ne某t;C、p->ne某t=p->ne某t;D、p=p->ne某t->ne某t;10、在一个单链表中,若在p所指结点之后插入所指结点,则执行(B)A、->ne某t=p;p->ne某t=;B、->ne某t=p->ne某t;p->ne某t=;C、->ne某t=p->ne某t;p=;D、p->ne某t=;->ne某t=p;11、在一个单链表中,已知q是p的前趋结点,若在q和p之间插入结点,则执行(C)A、->ne某t=p->ne某t;p->ne某t=;B、p->ne某t=->ne某t;->ne某t=p;C、q->ne某t=;->ne某t=p;D、p->ne某t=;->ne某t=q;12、在线性结构中,第一个结点没有前趋结点,其余每个结点有且只有1个前趋结点。
数据结构-结课实验带答案
线性表一、顺序表建立_新1、定义顺序表存储结构2、初始化顺序表为空(InitList_Sq)3、输入顺序表数据(CreateList_Sq)4、遍历(输出)顺序表数据(TraverseList_Sq)5、销毁顺序表数据(DestroyList_Sq)例如:输入元素个数和数据如下:55 3 8 7 9程序输出为:5,3,8,7,9二、单链表的建立-前插法_新1、定义单链表存储结构2、初始化一个空的单链表L(InitList_L)3、用前插法创建单链表数据(CreateList_F)4、遍历(输出)单链表表数据(TraverseList_L)5、销毁单链表表数据(DestroyList_L)例如:输入单链表结点个数和数据如下:59 7 8 3 5程序输出为:5,3,8,7,9三、单链表的建立-后插法_ 新1、定义单链表存储结构2、初始化一个空的单链表L(InitList_L)3、用后插法创建单链表数据(CreateList_L)4、遍历单链表表数据(TraverseList_L)5、销毁单链表表数据(DestroyList_L)例如:输入元素个数和数据如下:55 3 8 7 9程序输出为:5,3,8,7,9四、顺序表的插入_新1、定义插入函数(ListInsert_Sq)2、在主函数中遍历输出插入前线性表中的元素3、在主函数中输入插入元素的位置和数据信息4、显示插入后的顺序表数据信息(TraverseList_Sq)例如:输入元素个数和数据如下:55 3 8 7 9插入元素的位置和值为:26程序输出为:5,3,8,7,9 //在输入插入位置和值之前遍历输出的线性表中的数据元素5,6,3,8,7,9模板如下:#include <iostream>#include<stdlib.h>using namespace std;#define MAXSIZE 100#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef int ElemType;typedef struct {ElemType *elem; //指向数据元素的基地址int length; //线性表的当前长度}SqList;Status InitList_Sq(SqList *L){ //构造一个空的顺序表L}Status CreateList_Sq(SqList &L,int n){}//在此处定义顺序表插入函数ListInsert_Sqvoid TraverseList_Sq(SqList &L){}void DestroyList_Sq(SqList &L){}int main(){SqList L;int i,n,e;InitList_Sq(&L);//提示:输入元素个数:cin>>n;CreateList_Sq(L,n);TraverseList_Sq(L); //遍历输出插入前线性表数据元素//提示:在顺序表中输入新元素插入的位置和数据:cin>>i>>e;//在此处编写ListInsert_Sq函数的调用语句TraverseList_Sq(L);DestroyList_Sq(L);return 0;}五、顺序表的查找—按值进行查找_新1、定义按值查找函数(GetElem_Sq)2、在主函数中遍历输出查找前线性表中的元素3、在主函数中输入待查元素4、显示待查找元素的位置例如:输入顺序表元素个数和数据如下:55 3 8 7 9输入的待查找元素为:3程序输出结果有:5,3,8,7,9 //在查找之前遍历输出线性表中的数据元素2 //待查元素在线性表中的位置六、顺序表的查找—按序号进行查找_新1、定义按序查找函数(GetElem_Sq)2、在主函数中遍历输出查找之前线性表中的元素2、在主函数中输入待查元素在顺序表中的位序3、显示查找后的数据例如:输入顺序表元素个数和数据如下:55 3 8 7 9输入查找元素的位序为:2程序输出结果为:5,3,8,7,9 //在调用查找函数之前遍历输出的线性表中的数据元素3 //输出的待查元素的位序七、单链表的插入_新1、定义插入函数(ListInsert_L)2、在主函数中输出插入新结点之前单链表中的结点信息(TraverseList_L)3、在主函数中输入插入结点的位置和数据信息4、显示插入后的单链表数据信息(TraverseList_L)例如:输入单链表结点个数和数据如下:55 3 8 7 9结点插入的位置和值为:26程序输出为:5,3,8,7,9 // 插入新结点之前输出的单链表中的结点信息5,6,3,8,7,9 //插入新结点之后输出的单链表中的结点信息模板如下:#include <iostream>using namespace std;#define MAXSIZE 100#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef int ElemType;typedef struct LNode {ElemType data; //结点的数据域struct LNode *next; //结点的指针域} LNode, *LinkList; //LinkList为指向结构体LNode的指针类型Status InitList_L(LinkList &L){//构造一个空的单链表L}void CreateList_L(LinkList &L,int n){}//在此处定义单链表的插入函数ListInsert_Lvoid TraverseList_L(LinkList L)//依次输出单链表里的每个元素{}Status DestroyList_L(LinkList &L){}int main(){LinkList L; //用LinkList L;替换,与#include "LinkList.h"配合int n,i;ElemType e;InitList_L(L);//提示:请输入单链表的结点个数:cin>>n;CreateList_L(L,n);TraverseList_L(L);//提示:在单链表中输入结点插入的位置和数据:cin>>i>>e;//在此处调用单链表的插入函数TraverseList_L(L);DestroyList_L(L);return 0;}八、顺序表删除_新1、定义删除函数(ListDelete_Sq)2、在主函数中遍历输出插入前线性表中的元素3、在主函数中输入被删元素的位置4、显示删除后的线性表元素例如:输入顺序表元素个数和数据如下:55 3 8 7 9输入被删元素的位置:2程序输出结果为:5,3,8,7,9 //删除元素之前输出的线性表中的数据元素3 //输出的被删除元素5,8,7,9 //输出删除元素之后线性表中的数据元素九、单链表的查找-按序号查找_新1、定义按序查找函数(GetElem_Sq)2、在主函数中输出插入新结点之前单链表中的结点信息(TraverseList_L)3、在主函数中输入待查元素在单链表中的位序4、显示查找后的数据例如:输入单链表结点个数和数据如下:55 3 8 7 9输入查找结点的位序为:2程序输出结果为:5,3,8,7,9 // 插入新结点之前输出的单链表中的结点信息3 //输出该位置上的结点信息十、单链表结点的删除_ 新1、定义删除函数(ListDelete_L2、在主函数中遍历输出删除前单链表中的结点信息3、在主函数中输入被删结点的位置4、显示删除后的单链表的结点信息例如:输入单链表结点个数和数据如下:55 3 8 7 9输入被删结点的位置:2程序输出结果为:5,3,8,7,9 //删除结点之前遍历输出的单链表中的结点信息3 //输出被删除结点的结点信息5,8,7,9 //删除结点之后遍历输出的单链表中的结点信息十一、线性表的合并_新假设利用两个线性表LA和LB分别表示两个集合A和B,现要求一个新的集合A=A∪B,例如,设LA=(7 5 3 11 ),LB=(2 6 3),合并后LA=(7 5 3 11 2 6)1、定义线性表的顺序存储结构2、初始化线性表(InitList_Sq)3、创建线性表(CreateList_Sq)4、定义线性表的合并函数(unionList_Sq),将存在于线性表LB中而不存在于线性表LA中的数据元素插入到线性表LA中,(在合并函数中,还将包含对函数ListLengtht_Sq、ListInsert_Sq、LocateElem_Sq和GetElem_Sq的调用)5、在主函数中输入两个线性表LA,LB,调用合并函数6、遍历合并后的线性表LA,并输出数据(TraverseList_Sq)例如:输入线性表LA的元素个数和数据如下:47 5 3 11输入有序表LB的元素个数和数据如下:32 6 3输出为:7,5,3,11 //输出线性表LA的数据元素2,6,3 //输出线性表LB的数据元素7,5,3,11,2,6 //输出合并后的线性表LA的数据元素十二、有序表的合并_新已知线性表LA 和LB中的数据元素按值非递减有序排列,现要求将LA和LB归并为一个新的线性表LC,且LC中的数据元素仍按值非递减有序排列.1、定义有序表合并函数(MergeList_Sq),将两个非递减的有序表LA和LB合并为一个新的有序表LC,且LC中的数据元素仍按值非递减有序排列(在合并函数中,还将包含对ListLengtht_Sq、ListInsert_Sq和LocateElem_Sq的调用)2、在主函数中输出LA表的数据元素(TraverseList_Sq)3、在主函数中输出LB表的数据元素(TraverseList_Sq)4、在主函数中输入两个非递减的有序表LA,LB,调用合并函数5、遍历合并后的有序表LC,并输出数据(TraverseList_Sq)例如:输入有序表LA的元素个数和数据如下:42 5 8 9输入有序表LB的元素个数和数据如下:63 4 8 10 12 20输出为:2,5,8,9 //输出LA表的数据元素3,4,8,10,12,20 //输出LB表的数据元素2,3,4,5,8,8,9,10,12,20 //输出合并后的LC表的数据元素十三、有序链表的合并_新已知线性表LA 和LB中的数据元素按值非递减有序排列,现要求将LA和LB归并为一个新的线性表LC,且LC中的数据元素仍按值非递减有序排列.1、用后插法创建单链表数据(CreateList_L)2、定义遍历函数输出单链表数据(TraverseList_L)3、定义有序链表合并函数(MergeList_L),将两个非递减的有序链表LA和LB合并为一个新的有序链表LC,且LC中的结点元素仍按值非递减有序排列4、在主函数中输出LA和LB表的结点信息(TraverseList_L)5、在主函数中调用合并函数(MergeList_L)6、遍历合并后的有序链表LC,并输出结点信息(TraverseList_L)例如:输入有序链表LA的结点个数和数据如下:42 5 8 9输入有序链表LB的结点个数和数据如下:63 4 8 10 12 20输出为:2,5,8,9 //输出LA表的结点信息3,4,8,10,12,20 //输出LB表的结点信息2,3,4,5,8,8,9,10,12,20 //输出合并后的LC表的结点信息栈和队列一、顺序栈的建立1.定义顺序栈的存储结构2.初始化顺序栈为空栈(InitStack_Sq)3.输入要入栈的元素个数n4.向顺序栈中压入n个元素(Push_Sq)5.将顺序栈中的元素从栈顶到栈底依次输出(StackTraverse_Sq)6.销毁顺序栈(DestroyStack_Sq)例如:54 35 10 99 10 5 3 4 //遍历输出时最后一个元素后有一个空格二、顺序栈的入栈1.定义顺序栈入栈函数(Push_Sq)2.输入要入栈的元素个数n3.向顺序栈中压入n个元素4.将顺序栈中的元素从栈顶到栈底依次输出(StackTraverse_Sq)5.销毁顺序栈(DestroyStack_Sq)例如:56 2 8 10 99 10 8 2 6 //遍历输出时最后一个元素后有一个空格模板如下:#include <iostream>#include <stdlib.h>using namespace std;#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef int SElemType;#define MAXSIZE 100typedef struct{SElemType *base;SElemType *top;int stacksize;}SqStack;Status InitStack_Sq(SqStack &S) {}void DestroyStack_Sq(SqStack &S) {}//在此处定义入栈函数Push_Sqvoid StackTraverse_Sq(SqStack S) {}int main(){SqStack S;InitStack_Sq(S);int n;SElemType e;cin>>n;for(int i=1;i<=n;i++){cin>>e;//此处调用入栈函数}StackTraverse_Sq(S);DestroyStack_Sq(S);return 0;}三、顺序栈的出栈1.定义顺序栈出栈函数(Pop_Sq)2.定义求顺序栈栈长函数(StackLength_Sq)3.输入要入栈的元素个数n4.向顺序栈中压入n个元素5.将顺序栈中的元素从栈顶到栈底依次输出(StackTraverse_Sq)6.销毁顺序栈(DestroyStack_Sq)例如:42 4 6 88 6 4 2 //遍历输出时最后一个元素后有一个空格46 4 2 //遍历输出时最后一个元素后有一个空格83四、顺序栈栈顶元素的获取1.定义获取顺序栈栈顶元素函数(GetTop_Sq)2.输入要入栈的元素个数n3.向顺序栈中压入n个元素4.将顺序栈中的元素从栈顶到栈底依次输出(StackTraverse_Sq)5.获取栈顶元素6.输出栈顶元素7.销毁顺序栈(DestroyStack_Sq)例如:42 4 6 88 6 4 2 //遍历输出时最后一个元素后有一个空格8五、链栈的建立1.定义链栈的结点存储结构2.初始化链栈为空栈(InitStack_Link)3.输入要入栈的元素个数n4.向链栈中压入n个元素(Push_Link)5.从栈顶到栈底遍历链栈数据(StackTraverse_Link)6.销毁链栈(DestroyStack_Link)54 35 10 99 10 5 3 4 //遍历输出时最后一个元素后有一个空格六、链栈的入栈1.定义链栈的入栈函数(Push_Link)2.输入要入栈的元素个数n3.向栈中压入n个元素4.将链栈中的元素从栈顶到栈底依次输出(StackTraverse_Link)5.销毁链栈(DestroyStack_Link)例如:51 2 3 4 55 4 3 2 1 //遍历输出时最后一个元素后有一个空格模板如下:#include <iostream>using namespace std;#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef int SElemType;#define MAXSIZE 100typedef struct StackNode{SElemType data;struct StackNode *next;}StackNode,*LinkStack;Status InitStack_Link(LinkStack &S){}void DestroyStack_Link(LinkStack &S){}bool StackEmpty_Link(LinkStack S){}//此处定义入栈函数Push_Linkvoid StackTraverse_Link(LinkStack S){}int main(){LinkStack S;int n;SElemType e;InitStack_Link(S);cin>>n;for(int i=1;i<=n;i++){cin>>e;//此处调用入栈函数}StackTraverse_Link(S);DestroyStack_Link(S);return 0;}七、链栈的出栈1.定义求栈长函数(StackLength_Link)2.定义出栈函数(Pop_Link)3.输入要入栈的元素个数n4.向栈中压入n个元素(Push_Link)5.将栈中的元素从栈顶到栈底依次输出(StackTraverse_Link)6.输出栈长7.执行出栈操作8.将栈中的元素从栈顶到栈底依次输出9.输出出栈元素10.输出栈长11.销毁链栈(DestroyStack_Link)例如:51 2 3 4 55 4 3 2 1 //遍历输出时最后一个元素后有一个空格54 3 2 1 //遍历输出时最后一个元素后有一个空格54八、链栈栈顶元素的获取1.定义获取栈顶元素函数(GetTop_Link)2.输入要入栈的元素个数n3.向栈中压入n个元素(Push_Link)4.将栈中的元素从栈顶到栈底依次输出(StackTraverse_Link)5.获取栈顶元素6.输出栈顶元素7.销毁链栈(DestroyStack_Link)例如:42 4 6 88 6 4 2 //遍历输出时最后一个元素后有一个空格8九、循环队列的建立1.定义循环队列的存储结构2.初始化循环队列为空队列(InitQueue_Sq)3.输入要入队的元素个数n4.向循环队列中输入n个元素(EnQueue_Sq)5.将循环队列中的元素从队头至队尾依次输出(StackQueue_Sq)6.销毁循环队列(DestroyQueue_Sq)例如:51 2 3 4 51 2 3 4 5 //遍历输出时最后一个元素后有一个空格十、循环队列的入队1.定义循环队列入队函数(EnQueue_Sq)2.输入要入队的元素个数n3.向循环队列中输入n个元素4.将循环队列中的元素从队头至队尾依次输出(StackQueue_Sq)5.销毁循环队列(DestroyQueue_Sq)例如:56 2 8 10 96 2 8 10 9 //遍历输出时最后一个元素后有一个空格模板如下:#include <iostream>#include <stdlib.h>using namespace std;#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef int QElemType;#define MAXSIZE 100typedef struct{QElemType *base;int front;int rear;}SqQueue;Status InitQueue_Sq(SqQueue &Q) {}void DestroyQueue_Sq(SqQueue &Q) {}//此处定义入队函数EnQueue_Sqvoid QueueTraverse_Sq(SqQueue Q) {}int main(){SqQueue Q;QElemType e;InitQueue_Sq(Q);int n;cin>>n;for(int i=1;i<=n;i++){cin>>e;//此处调用入队函数}QueueTraverse_Sq(Q);DestroyQueue_Sq(Q);return 0;}十一、循环队列的出队1.定义求循环队列队长函数(QueueLength_Sq)2.定义循环队列的出队函数(DeQueue_Sq)3.输入要入队的元素个数n4.向循环队列中输入n个元素5.将循环队列中的元素从队头至队尾依次输出(StackQueue_Sq)6.输出队长7.执行出队操作8.将循环队列中的元素从队头至队尾依次输出9.输出出队元素10.输出队长11.销毁循环队列(DestroyQueue_Sq)例如:51 2 3 4 51 2 3 4 5 //遍历输出时最后一个元素后有一个空格52 3 4 5 //遍历输出时最后一个元素后有一个空格14十二、循环队列队头元素的获取1.定义获取循环队列队头元素函数(GetHead_Sq)2.输入要入队的元素个数n3.向循环队列中输入n个元素4.将循环队列中的元素从队头至队尾依次输出5.获取栈顶元素6.将循环队列中的元素从队头至队尾依次输出7.销毁循环队列例如:52 4 6 8 102 4 6 8 10 //遍历输出时最后一个元素后有一个空格2十三、链队列的建立1.定义链队列的存储结构2.初始化链队列为空队列(InitQueue_Link)3.输入要入队的元素个数n4.向链队列中输入n个元素(EnQueue_Link)5.将链队列中的元素从队头至队尾依次输出(StackQueue_Link)6.销毁链队列(DestroyQueue_Link)例如:51 2 3 4 51 2 3 4 5 //遍历输出时最后一个元素后有一个空格十四、链队列的入队1.定义链队列入队函数(EnQueue_Link)2.输入要入队的元素个数n3.向链队列中输入n个元素4.将链队列中的元素从队头至队尾依次输出(StackQueue_Link)5.销链队列(DestroyQueue_Link)例如:56 2 8 10 96 2 8 10 9 //遍历输出时最后一个元素后有一个空格模板如下:#include <iostream>#include <stdlib.h>using namespace std;#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef int QElemType;#define MAXSIZE 100typedef struct QNode{QElemType data;struct QNode *next;}QNode,*QueuePtr;typedef struct{QueuePtr front;QueuePtr rear;}LinkQueue;Status InitQueue_Link(LinkQueue &Q){}void DestroyQueue_Link(LinkQueue &Q){}//此处定义入队函数EnQueue_Linkvoid QueueTraverse_Link(LinkQueue Q){}int main(){LinkQueue Q;QElemType e;InitQueue_Link(Q);int n;cin>>n;for(int i=1;i<=n;i++){cin>>e;//此处调用入队函数}QueueTraverse_Link(Q);DestroyQueue_Link(Q);return 0;}十五、链队列的出队1.定义求链队列队长函数(QueueLength_Link)2.定义链队列的出队函数(DeQueue_Link)3.输入要入队的元素个数n4.向链队列中输入n个元素5.将链队列中的元素从队头至队尾依次输出(StackQueue_Link)6.输出队长7.执行出队操作8.将链队列中的元素从队头至队尾依次输出9.输出出队元素10.输出队长11.销毁链队列(DestroyQueue_Link)例如:51 2 3 4 51 2 3 4 5 //遍历输出时最后一个元素后有一个空格52 3 4 5 //遍历输出时最后一个元素后有一个空格14十六、链队列队头元素的获取1.定义获取链队列队头元素函数(GetHead_Link)2.输入要入队的元素个数n3.向链队列中输入n个元素4.将链队列中的元素从队头至队尾依次输出5.获取栈顶元素6.将链队列中的元素从队头至队尾依次输出7.销毁链队列例如:52 4 6 8 102 4 6 8 10 //遍历输出时最后一个元素后有一个空格2十七、栈的应用将十进制数n,转换成八进制。
数据结构实验报告 答案
数据结构实验报告答案一、实验目的本次数据结构实验的主要目的是通过实际编程和操作,深入理解和掌握常见的数据结构,如数组、链表、栈、队列、树和图等,并能够运用这些数据结构解决实际问题,提高编程能力和算法设计能力。
二、实验环境操作系统:Windows 10编程语言:C++开发工具:Visual Studio 2019三、实验内容1、数组操作定义一个整数数组,实现数组元素的输入、输出和查找功能。
对数组进行排序(选择排序、冒泡排序等),并输出排序后的数组。
2、链表操作构建一个单向链表,实现链表节点的插入、删除和遍历操作。
反转链表,并输出反转后的链表。
3、栈和队列操作用数组实现栈和队列的数据结构,实现入栈、出栈、入队、出队等基本操作。
利用栈实现表达式求值(中缀表达式转后缀表达式,然后计算后缀表达式的值)。
4、树的操作构建二叉树(可以采用顺序存储或链式存储),实现二叉树的前序、中序和后序遍历。
实现二叉树的查找、插入和删除节点操作。
5、图的操作用邻接矩阵或邻接表表示图,实现图的深度优先遍历和广度优先遍历。
求解图的最短路径(Dijkstra 算法或 Floyd 算法)。
四、实验步骤及代码实现1、数组操作```cppinclude <iostream>using namespace std;//数组输入函数void inputArray(int arr, int size) {cout <<"请输入"<< size <<"个整数:"<< endl; for (int i = 0; i < size; i++){cin >> arri;}}//数组输出函数void outputArray(int arr, int size) {cout <<"数组元素为:"<< endl;for (int i = 0; i < size; i++){cout << arri <<"";}cout << endl;}//数组查找函数int searchArray(int arr, int size, int target) {for (int i = 0; i < size; i++){if (arri == target) {return i;}}return -1;}//选择排序函数void selectionSort(int arr, int size) {for (int i = 0; i < size 1; i++){int minIndex = i;for (int j = i + 1; j < size; j++){if (arrj < arrminIndex) {minIndex = j;}}if (minIndex!= i) {int temp = arri;arri = arrminIndex;arrminIndex = temp;}}}//冒泡排序函数void bubbleSort(int arr, int size) {for (int i = 0; i < size 1; i++){for (int j = 0; j < size i 1; j++){if (arrj > arrj + 1) {int temp = arrj;arrj = arrj + 1;arrj + 1 = temp;}}}}int main(){int size = 10;inputArray(arr, size);outputArray(arr, size);int target = 5;int result = searchArray(arr, size, target);if (result!=-1) {cout <<"找到目标元素"<< target <<",在数组中的索引为"<< result << endl;} else {cout <<"未找到目标元素"<< target << endl;}selectionSort(arr, size);outputArray(arr, size);bubbleSort(arr, size);outputArray(arr, size);return 0;}2、链表操作```cppinclude <iostream>using namespace std;//链表节点结构体struct ListNode {int data;ListNode next;ListNode(int x) : data(x), next(NULL) {}};//链表插入函数void insertNode(ListNode& head, int val) {ListNode newNode = new ListNode(val);if (head == NULL) {head = newNode;return;}ListNode curr = head;while (curr>next!= NULL) {curr = curr>next;}curr>next = newNode;}//链表删除函数void deleteNode(ListNode& head, int val) {if (head == NULL) {return;}if (head>data == val) {ListNode temp = head;head = head>next;delete temp;return;}ListNode curr = head;while (curr>next!= NULL && curr>next>data!= val) {curr = curr>next;}if (curr>next!= NULL) {ListNode temp = curr>next;curr>next = curr>next>next;delete temp;}}//链表遍历函数void traverseList(ListNode head) {ListNode curr = head;while (curr!= NULL) {cout << curr>data <<"";curr = curr>next;}cout << endl;}//链表反转函数ListNode reverseList(ListNode head) {ListNode prev = NULL;ListNode curr = head;while (curr!= NULL) {ListNode nextTemp = curr>next; curr>next = prev;prev = curr;curr = nextTemp;}return prev;}int main(){ListNode head = NULL;insertNode(head, 1);insertNode(head, 2);insertNode(head, 3);insertNode(head, 4);insertNode(head, 5);traverseList(head);deleteNode(head, 3);traverseList(head);ListNode reversedHead = reverseList(head);traverseList(reversedHead);return 0;}```3、栈和队列操作```cppinclude <iostream>using namespace std;//用数组实现栈const int MAX_SIZE = 100;class Stack {private:int arrMAX_SIZE;int top;public:Stack(){top =-1;}//入栈void push(int val) {if (top == MAX_SIZE 1) {cout <<"栈已满,无法入栈" << endl; return;}arr++top = val;}//出栈int pop(){if (top ==-1) {cout <<"栈为空,无法出栈" << endl; return -1;}int val = arrtop;top;return val;}//查看栈顶元素int peek(){if (top ==-1) {cout <<"栈为空" << endl;return -1;}return arrtop;}//判断栈是否为空bool isEmpty(){return top ==-1;}};//用数组实现队列class Queue {private:int arrMAX_SIZE;int front, rear;public:Queue(){front = rear =-1;}//入队void enqueue(int val) {if ((rear + 1) % MAX_SIZE == front) {cout <<"队列已满,无法入队" << endl; return;}if (front ==-1) {front = 0;}rear =(rear + 1) % MAX_SIZE;arrrear = val;}//出队int dequeue(){if (front ==-1) {cout <<"队列为空,无法出队" << endl; return -1;}int val = arrfront;if (front == rear) {front = rear =-1;} else {front =(front + 1) % MAX_SIZE;}return val;}//查看队头元素int peek(){if (front ==-1) {cout <<"队列为空" << endl;return -1;}return arrfront;}//判断队列是否为空bool isEmpty(){return front ==-1;}};//表达式求值函数int evaluateExpression(string expression) {Stack operandStack;Stack operatorStack;for (int i = 0; i < expressionlength(); i++){char c = expressioni;if (isdigit(c)){int operand = 0;while (i < expressionlength()&& isdigit(expressioni)){operand = operand 10 +(expressioni++'0');}i;operandStackpush(operand);} else if (c =='+'|| c ==''|| c ==''|| c =='/'){while (!operatorStackisEmpty()&&precedence(operatorStackpeek())>= precedence(c)){int operand2 = operandStackpop();int operand1 = operandStackpop();char op = operatorStackpop();int result = performOperation(operand1, operand2, op);operandStackpush(result);}operatorStackpush(c);} else if (c =='('){operatorStackpush(c);} else if (c ==')'){while (operatorStackpeek()!='('){int operand2 = operandStackpop();int operand1 = operandStackpop();char op = operatorStackpop();int result = performOperation(operand1, operand2, op);operandStackpush(result);}operatorStackpop();}}while (!operatorStackisEmpty()){int operand2 = operandStackpop();int operand1 = operandStackpop();char op = operatorStackpop();int result = performOperation(operand1, operand2, op);operandStackpush(result);}return operandStackpop();}//运算符优先级函数int precedence(char op) {if (op =='+'|| op ==''){return 1;} else if (op ==''|| op =='/'){return 2;}return 0;}//运算函数int performOperation(int operand1, int operand2, char op) {switch (op) {case '+':return operand1 + operand2;case '':return operand1 operand2;case '':return operand1 operand2;case '/':if (operand2!= 0) {return operand1 / operand2;} else {cout <<"除数不能为 0" << endl;return -1;}}return -1;}int main(){Stack stack;stackpush(1);stackpush(2);stackpush(3);cout <<"栈顶元素:"<< stackpeek()<< endl;cout <<"出栈元素:"<< stackpop()<< endl;cout <<"栈是否为空:"<<(stackisEmpty()?"是" :"否")<< endl;Queue queue;queueenqueue(1);queueenqueue(2);queueenqueue(3);cout <<"队头元素:"<< queuepeek()<< endl;cout <<"出队元素:"<< queuedequeue()<< endl;cout <<"队列是否为空:"<<(queueisEmpty()?"是" :"否")<< endl;string expression ="2+34";int result = evaluateExpression(expression);cout << expression <<"="<< result << endl; return 0;}```4、树的操作```cppinclude <iostream>using namespace std;//二叉树节点结构体struct TreeNode {int val;TreeNode left;TreeNode right;TreeNode(int x) : val(x), left(NULL), right(NULL) {}};//前序遍历函数void preOrderTraversal(TreeNode root) {return;}cout << root>val <<"";preOrderTraversal(root>left);preOrderTraversal(root>right);}//中序遍历函数void inOrderTraversal(TreeNode root) {if (root == NULL) {return;}inOrderTraversal(root>left);cout << root>val <<"";inOrderTraversal(root>right);}//后序遍历函数void postOrderTraversal(TreeNode root) {return;}postOrderTraversal(root>left);postOrderTraversal(root>right);cout << root>val <<"";}//查找函数TreeNode searchBST(TreeNode root, int val) {if (root == NULL || root>val == val) {return root;}if (val < root>val) {return searchBST(root>left, val);} else {return searchBST(root>right, val);}}//插入函数TreeNode insertBST(TreeNode root, int val) {if (root == NULL) {return new TreeNode(val);}if (val < root>val) {root>left = insertBST(root>left, val);} else if (val > root>val) {root>right = insertBST(root>right, val);}return root;}//删除函数TreeNode deleteNodeBST(TreeNode root, int key) {if (root == NULL) {return root;}if (key < root>val) {root>left = deleteNodeBST(root>left, key);} else if (key > root>val) {root>right = deleteNodeBST(root>right, key);} else {if (root>left == NULL) {TreeNode temp = root>right;delete root;return temp;} else if (root>right == NULL) {TreeNode temp = root>left;delete root;return temp;}TreeNode minNode = root>right;while (minNode>left!= NULL) {minNode = minNode>left;}root>val = minNode>val;root>right = deleteNodeBST(root>right, minNode>val);}return root;}int main(){TreeNode root = new TreeNode(4);root>left = new TreeNode(2);root>right = new TreeNode(6);root>left>left = new TreeNode(1);root>left>right = new TreeNode(3);root>right>left = new TreeNode(5);root>right>right = new TreeNode(7);cout <<"前序遍历:"<< endl; preOrderTraversal(root);cout << endl;cout <<"中序遍历:"<< endl; inOrderTraversal(root);cout << endl;cout <<"后序遍历:"<< endl; postOrderTraversal(root);cout << endl;int target = 3;TreeNode foundNode = searchBST(root, target);if (foundNode!= NULL) {cout <<"找到目标节点"<< target << endl;} else {cout <<"未找到目标节点"<< target << endl;}root = insertBST(root, 8);cout <<"插入节点 8 后的中序遍历:"<< endl; inOrderTraversal(root);cout << endl;root = deleteNodeBST(root, 2);cout <<"删除节点 2 后的中序遍历:。
数据结构完整题目及答案1
数据结构与算法实验报告目录实验一学生成绩分析程序 (4)1.1 上机实验的问题和要求(需求分析): (4)1.2 程序设计的基本思想,原理和算法描述: (4)1.3 调试和运行程序过程中产生的问题及采取的措施: (4)1.4 运行输出结果: (4)1.5 源程序及注释: (5)实验二线性表的基本操作 (8)2.1 上机实验的问题和要求(需求分析): (8)2.2 程序设计的基本思想,原理和算法描述: (8)2.3 调试和运行程序过程中产生的问题及采取的措施: (8)2.4 运行输出结果: (8)2.5 源程序及注释: (8)实验三链表的基本操作 (11)3.1 上机实验的问题和要求(需求分析): (11)3.2 程序设计的基本思想,原理和算法描述: (11)3.3 调试和运行程序过程中产生的问题及采取的措施: (11)3.4 运行输出结果: (11)3.5 源程序及注释: (11)实验四单链表综合实验 (14)4.1 上机实验的问题和要求(需求分析): (14)4.2 程序设计的基本思想,原理和算法描述: (14)4.3 调试和运行程序过程中产生的问题及采取的措施: (14)4.4 运行输出结果: (14)4.5 源程序及注释: (14)实验五串 (19)5.1 上机实验的问题和要求(需求分析): (19)5.2 程序设计的基本思想,原理和算法描述: (19)5.3 调试和运行程序过程中产生的问题及采取的措施: (19)5.4 运行输出结果: (19)5.5 源程序及注释: (21)实验六循环队列的实现与运算 (22)6.1 上机实验的问题和要求(需求分析): (22)6.2 程序设计的基本思想,原理和算法描述: (22)6.3 调试和运行程序过程中产生的问题及采取的措施: (22)6.4 运行输出结果: (22)6.5 源程序及注释: (23)实验七栈子系统 (26)7.1 上机实验的问题和要求(需求分析): (26)7.2 程序设计的基本思想,原理和算法描述: (26)7.3 调试和运行程序过程中产生的问题及采取的措施: (26)7.4 运行输出结果: (26)7.5 源程序及注释: (28)实验八树 (36)8.1 上机实验的问题和要求(需求分析): (36)8.2 程序设计的基本思想,原理和算法描述: (39)8.3 调试和运行程序过程中产生的问题及采取的措施: (39)8.4 运行输出结果: (39)8.5 源程序及注释: (41)实验九建立哈夫曼树与哈夫曼树与码 (50)9.1 上机实验的问题和要求(需求分析): (50)9.2 程序设计的基本思想,原理和算法描述: (50)9.3 调试和运行程序过程中产生的问题及采取的措施: (50)9.4 运行输出结果: (50)9.5 源程序及注释: (50)实验十图 (53)10.1 上机实验的问题和要求(需求分析): (53)10.2 程序设计的基本思想,原理和算法描述: (53)10.3 调试和运行程序过程中产生的问题及采取的措施: (53)10.4 运行输出结果: (53)10.5 源程序及注释: (53)实验一学生成绩分析程序一、上机实验的问题和要求(需求分析):【题目】设一个班有10个学生,每个学生有学号,以及数学、物理、英语、语文、体育 5 门课的成绩信息。
(完整版)数据结构实验答案及解析
《数据结构》实验指导2013 / 2014 学年第 2学期姓名:______________学号:_________班级:______________指导教师:______________潍坊学院计算机工程学院2014预备实验 C语言的函数数组指针结构体知识一、实验目的1、复习C语言中函数、数组、指针和结构体的概念。
2、熟悉利用C语言进行程序设计的一般方法。
二、实验内容和要求1、调试程序:输出100以内所有的素数(用函数实现)。
#include<stdio.h>/*判断一个数是否为素数*/int isprime(int n){for(int m=2;m*m<=n;m++){if(n%m= =0) return 0;return 1;}/*输出100以内所有素数*/int main(){int i;for(i=2;i<100;i++)if(isprime(i)= =1) printf(“%4d”,i);return 0;}运行结果:2、调试程序:对一维数组中的元素进行逆序排列。
#include<stdio.h>#define N 10int main(){int a[N]={0,1,2,3,4,5,6,7,8,9},i,temp;printf(“the original Array is:\n ”);for(i=0;i<N;i++)printf(“%4d”,a[i]);for(i=0;i<N/2;i++){ /*交换数组元素使之逆序*/temp=a[i];a[i]=a[N-i-1];a[N-i-1]=temp;}printf(“\nthe changed Array is:\n”);for(i=0;i<N;i++)printf(“%4d”,a[i]);return 0;}运行结果:3、调试程序:在二维数组中,若某一位置上的元素在该行中最大,而在该列中最小,则该元素即为该二维数组的一个鞍点。
数据结构实验答案1
数据结构实验答案1重庆文理学院软件工程学院实验报告册专业:_____软件工程__ _班级:_____软件工程2班__ _学号:_____201258014054 ___姓名:_____周贵宇___________课程名称:___ 数据结构 _指导教师:_____胡章平__________2013年 06 月 25 日实验序号 1 实验名称实验一线性表基本操作实验地点S-C1303 实验日期2013年04月22日实验内容1.编程实现在顺序存储的有序表中插入一个元素(数据类型为整型)。
2.编程实现把顺序表中从i个元素开始的k个元素删除(数据类型为整型)。
3.编程序实现将单链表的数据逆置,即将原表的数据(a1,a2….an)变成(an,…..a2,a1)。
(单链表的数据域数据类型为一结构体,包括学生的部分信息:学号,姓名,年龄)实验过程及步骤1.#include#include#include#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0#define ElemType int#define MAXSIZE 100 /*此处的宏定义常量表示线性表可能达到的最大长度*/typedef struct{ ElemType elem[MAXSIZE]; /*线性表占用的数组空间*/ int last; /*记录线性表中最后一个元素在数组elem[ ]中的位置(下标值),空表置为-1*/}SeqList;#include "common.h"#include "seqlist.h"void px(SeqList *A,int j);void main(){ SeqList *l;int p,q,r;int i;l=(SeqList*)malloc(sizeof(SeqList));printf("请输入线性表的长度:");scanf("%d",&r);l->last = r-1;printf("请输入线性表的各元素值:\n");for(i=0; i<=l->last; i++){scanf("%d",&l->elem[i]);}px(l,i);printf("请输入要插入的值:\n");scanf("%d",&l->elem[i]);i++;px(l,i);l->last++;for(i=0; i<=l->last; i++){ printf("%d ",l->elem[i]);}printf("\n");}void px(SeqList *A,int j){ int i,temp,k;for(i=0;i<j;i++)< p="">{ for(k=0;k<j-1;k++)< p="">{if(A->elem[i]elem[k]){temp=A->elem[i];A->elem[i]=A->elem[k];A->elem[k]=temp;}}}}2.#include#include#include#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0#define ElemType int#define MAXSIZE 100 /*此处的宏定义常量表示线性表可能达到的最大长度*/typedef struct{ ElemType elem[MAXSIZE]; /*线性表占用的数组空间*/ int last; /*记录线性表中最后一个元素在数组elem[ ]中的位置(下标值),空表置为-1*/}SeqList;#include "common.h"#include "seqlist.h"void px(SeqList *A,int j);int DelList(SeqList *L,int i,SeqList *e,int j)/*在顺序表L中删除第i个数据元素,并用指针参数e返回其值。
数据结构习题参考答案(全)
4.2 设三维数组的维度分别是 m, n, l;每个元素占 k 个存储单元。 Loc(A[i][j][k]) = Loc(A[0][0][0]) + (i * n * l + j * l) * k 4.6
4.7 col num k 0 1 0 1 0 1 2 2 1 3 1 3 4 2 4
5.2 (1)无序树:9 棵 (2)有序树:12 棵 (3)二叉树:30 棵 5.4 (1)2k-1
5 2 0
-1 0
8 3 6 4
3 4 5 6
10
1
1
2
7
7 8
9
9
11
10 11
ASL 成功=1/12(1*1+2*2+3*4+4*5)=37/12 ASL 失败=1/13(3*3+4*10)=49/13
7.1
7.3
7.16 (1)
f b a
7.17 (1) 删除 a
h k r de g ij m sx
B
C K
9 12 1 E 0 F 5 5 0 1 C 2 3 A B
(2)WPL = 91 (3)各字符的编码 A:1010 B:1011 C:100 D:00 E:01 F:11
6.5 template <class T> bool SeqList<T>::Search1(T x)const { return SearchRec(x, 0); } template <class T> bool SeqList<T>::SearchRec(T x, int i)const { if (i >= n) return false; if (elements[i] == x) return true; else return SearchRec(x, i+1); } 6.6 template <class T> bool SingleList<T>::Search1(T x) const { Node<T> *p = first; while (p && p->element < x) { p = p->link; } if (p == NULL || p->element > x) return false; return true; } 6.10
数据结构实验报告答案1
(此文档为word格式,下载后您可任意编辑修改!)《数据结构与算法分析》课程设计内容体系主要内容《数据结构课程设计》课程,可使学生深化理解书本知识,致力于用学过的理论知识和上机取得的实践经验,解决具体、复杂的实际问题,培养软件工作者所需的动手能力、独立解决问题的能力。
该课程设计侧重软件设计的综合训练,包括问题分析、总体结构设计、用户界面设计、程序设计基本技能和技巧、多人合作,以至一整套软件工作规范的训练和科学作风的培养。
一、课程设计要求学生必须仔细阅读《数据结构与算法分析》课程设计方案,认真主动完成课程设计的要求。
有问题及时主动通过各种方式与教师联系沟通。
学生要发挥自主学习的能力,充分利用时间,安排好课程设计的时间计划,并在课程设计过程中不断检测自己的计划完成情况,及时的向教师汇报。
课程设计按照教学要求需要两周时间完成,两周中每天(按每周5天)至少要上3-4小时的机来调试C语言设计的程序,总共至少要上机调试程序30小时。
二、数据结构课程设计的具体内容本次课程设计完成如下模块(共9个模块,学生可以在其中至少挑选6个功能块完成,但有**号的模块是必须要选择的)(1)运动会分数统计**任务:参加运动会有n个学校,学校编号为1……n。
比赛分成m个男子项目,和w个女子项目。
项目编号为男子1……m,女子m+1……m+w。
不同的项目取前五名或前三名积分;取前五名的积分分别为:7、5、3、2、1,前三名的积分分别为:5、3、2;哪些取前五名或前三名由学生自己设定。
(m<=20,n<=20)功能要求:可以输入各个项目的前三名或前五名的成绩;●能统计各学校总分;●可以按学校编号、学校总分、男女团体总分排序输出;●可以按学校编号查询学校某个项目的情况;可以按项目编号查询取得前三或前五名的学校。
规定:输入数据形式和范围:20以内的整数(如果做得更好可以输入学校的名称,运动项目的名称)输出形式:有中文提示,各学校分数为整形界面要求:有合理的提示,每个功能可以设立菜单,根据提示,可以完成相关的功能要求。
太原理工数据结构实验答案
实验一线性表一.目的与要求本次实习的主要目的是为了使学生熟练掌握线性表的基本操作在顺序存储结构和链式存储结构上的实现,提高分析和解决问题的能力。
要求仔细阅读并理解下列例题,上机通过,并观察其结果,然后独立完成后面的实习题。
二.例题问题描述:用链表形式存储一个字符串,插入、删除某个字符,最后按正序、逆序两种方式输出字符串。
输入:初始字符串,插入位置,插入字符,删除字符。
输出:已建立链表(字符串),插入字符后链表,删除字符后链表,逆转后链表。
存储结构:采用链式存储结构算法的基本思想:建立链表当读入字符不是结束符时,给结点分配存储空间,写数据域,将新结点插到表尾;插入字符:根据读入的字符在链表中找插入位置,将新结点插入到该位置之前;删除字符:根据读入的删除字符在链表中找到被删结点后,将其从链表中删除;链表逆转:从链表的第一个结点开始对所有结点处理,将每个结点的前驱变为它的后继;打印链表:从链表的第一个结点开始,依次打印各[运行情况]Input a linktable(a string):abcde↙Build link is :abcdePlease input a char you want to insert after:b↙Please input a char you want to insert:c↙After p insert y,link is:abccdePlease input a char you want to delete:e↙after delete p,link is:abccdOpsite result is :dccba如图显示:实习题:问题描述:设顺序表A中的数据元素递增有序,试写一程序,将x插入到顺序表的适当位置上,使该表仍然有序。
输入:插入前的顺序表,插入的数,插入后的顺序表输出:插入前的顺序表,插入的数,插入后的顺序表存储结构:顺序表存储数据算法基本思想:其实这个题在学C语言时就已经写过了,这里采用顺序表来存储数据。
华南农业大学数据结构上机答案实验
华南农业大学数据结构上机答案实验8583 顺序栈的基本操作时间限制:1000MS 内存限制:1000K提交次数:530 通过次数:212题型: 编程题语言: 无限制Description创建一个空的顺序栈,并实现栈的入栈、出栈、返回栈的长度、返回栈顶元素、栈的遍历等基本算法。
请将下#include<malloc.h>#include<stdio.h>#define OK 1#define ERROR 0#define STACK_INIT_SIZE 100 // 存储空间初始分配量#define STACKINCREMENT 10 // 存储空间分配增量typedef int SElemType; // 定义栈元素类型typedef int Status; // Status是函数的类型,其值是函数结果状态代码,如OK 等struct SqStack{SElemType *base; // 在栈构造之前和销毁之后,base的值为NULL SElemType *top; // 栈顶指针int stacksize; // 当前已分配的存储空间,以元素为单位}; // 顺序栈Status InitStack(SqStack &S){// 构造一个空栈S,该栈预定义大小为STACK_INIT_SIZE// 请补全代码S.base=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));if(!S.base) return ERROR;S.top=S.base;S.stacksize=STACK_INIT_SIZE;return OK;}Status Push(SqStack &S,SElemType e){// 在栈S中插入元素e为新的栈顶元素// 请补全代码if(S.top-S.base>=S.stacksize){S.base=(SElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SEl emType));if(!S.base) return ERROR;S.top=S.base+S.stacksize;S.stacksize+=STACKINCREMENT;}*S.top++=e;return OK;}Status Pop(SqStack &S,SElemType &e){// 若栈不空,则删除S的栈顶元素,用e返回其值,并返回OK;否则返回ERROR// 请补全代码if(S.top==S.base) return ERROR;e=*--S.top;return OK;}Status GetTop(SqStack S,SElemType &e){// 若栈不空,则用e返回S的栈顶元素,并返回OK;否则返回ERROR // 请补全代码if(S.top==S.base) return ERROR;e=*(S.top-1);return OK;}int StackLength(SqStack S){// 返回栈S的元素个数// 请补全代码return S.top-S.base;}Status StackTraverse(SqStack S){// 从栈顶到栈底依次输出栈中的每个元素SElemType *p = (SElemType *)malloc(sizeof(SElemType));p = S.top ; //请填空if(S.top==S.base)printf("The Stack is Empty!"); //请填空else{printf("The Stack is: ");p--;while(p>=S.base) //请填空{printf("%d ", *p);p--; //请填空}}printf("\n");return OK;}int main(){int a;SqStack S;SElemType x, e;if(InitStack(S)) // 判断顺序表是否创建成功,请填空{printf("A Stack Has Created.\n");}while(1){printf("1:Push \n2:Pop \n3:Get the Top \n4:Return the Length of the Stack\n5:Load the Stack\n0:Exit\nPlease choose:\n");scanf("%d",&a);switch(a){case 1: scanf("%d", &x);if(!Push(S,x)) printf("Push Error!\n"); // 判断Push是否合法,请填空else printf("The Element %d is Successfully Pushed!\n", x); break;case 2: if(!Pop(S,e)) printf("Pop Error!\n"); // 判断Pop是否合法,请填空else printf("The Element %d is Successfully Poped!\n", e); break;case 3: if(!GetTop(S,e))printf("Get Top Error!\n"); // 判断Get Top 是否合法,请填空else printf("The Top Element is %d!\n", e);break;case 4: printf("The Length of the Stack is %d!\n",StackLength(S)); //请填空break;case 5: StackTraverse(S); //请填空break;case 0: return 1;}}}8584 循环队列的基本操作时间限制:1000MS 内存限制:1000K提交次数:366 通过次数:157题型: 编程题语言: 无限制Description创建一个空的循环队列,并实现入队、出队、返回队列的长度、返回队头元素、队列的遍历等基本算法。
国家开放大学《数据结构》课程实验报告(实验2——线性表)参考答案
//在链表中删除最高分和最低分结点
for(q=head,p=head->next;p!=NULL;q=p,p=p->next)
{
if(p==pmin) { q->next=p->next; p=q; } //删除最低分结点
};
typedef struct pw PW;
//定义链表结点
struct node
{
PW data;
struct node * next;
};
typedef struct node NODE;
NODE *create(int n); //建立单链表
void input(NODE *s,int i); //输入第i个评委信息
(5)遍历链表,累加求和,计算总分及平均分,并输出相关信息。
完整程序
//实验1.1线性表的链接存储结构
#include
#include
#include
#define PWRS 5 //定义评委人数
//定义评委信息
struct pw
{
char name[8]; //姓名
short age; //年龄
float score; //评分
NODE *create(int n)
{
NODE *head,*p,*q;
inti;
p=(NODE*)malloc(sizeof(NODE));
head=p; q=p; p->next=NULL;
for(i=1; i<=n; i++)
{
p=(NODE*)malloc(sizeof(NODE));
国家开放大学《数据结构》课程实验报告(实验3 ——栈、队列、递归设计)参考答案
/*判队空*/
int QueueEmpty(SeqQueue *sq)
{
if(sq->rear==sq->front)
return 1;
else
return 0;
}
/*循环队列入队*/
void InQueue(SeqQueue *sq,ElemType x)
{
if ((sq->rear+1)%MaxSize==sq->front) /*队满*/
InitStack(s);
printf("(2)栈为%s\n",(StackEmpty(s)?"空":"非空"));
printf("(3)输入要进栈的数据个数:");
scanf("%d",&n);
printf("依次输入进栈的%d个整数:",n);
/*数据依次进栈*/
for(i=0; i<n; i++)
{
printf("循环队列已空,不能进行出队操作!\n");
exit(1);
}
else{
x=sq->data[sq->front];
sq->front=(sq->front+1)%MaxSize;
return x;
}
}
/*取队头元素*/
ElemType GetQueue(SeqQueue *sq)
{
void InitQueue(SeqQueue *sq); /*初始化队列*/
int QueueEmpty(SeqQueue *sq); /*判队空*/
《数据结构》实验报告二及其答案
《数据结构》实验报告二学校:班级:09软工A1学号:09XXXXX 姓名:XXX日期:2010 .04.08 程序名:L2311.CPP一、上机实验的问题和要求:单链表的查找、插入与删除。
设计算法,实现线性结构上的单链表的产生以及元素的查找、插入与删除。
具体实现要求:1.从键盘输入20个整数,产生带表头的单链表,并输入结点值。
2.从键盘输入1个整数,在单链表中查找该结点。
若找到,则显示“找到了”;否则,则显示“找不到”。
3.从键盘输入2个整数,一个表示欲插入的位置i,另一个表示欲插入的数值x,将x插入在对应位置上,输出单链表所有结点值,观察输出结果。
4.从键盘输入1个整数,表示欲删除结点的位置,输出单链表所有结点值,观察输出结果。
5.将单链表中值重复的结点删除,使所得的结果表中个结点值均不相同,输出单链表所有结点值,观察输出结果。
6.删除其中所有数据值为偶数的结点,输出单链表所有结点值,观察输出结果。
7.把单链表变成带表头结点的循环链表,输出循环单链表所有结点值,观察输出结果。
8.(★)将单链表分解成两个单链表A和B,使A链表中含有原链表中序号为奇数的元素,而B链表中含有原链表中序号为偶数的元素,且保持原来的相对顺序,分别输出单链表A和单链表B的所有结点值,观察输出结果。
二、程序设计的基本思想,原理和算法描述:(包括程序的结构,数据结构,输入/输出设计,符号名说明等)三、源程序及注释:#include <iostream.h>//单链表的定义:typedef int DataType; //DataType可以是任何相应的数据类型如int, float或char typedef struct node //结点类型定义{ DataType data; //结点的数据域struct node *next; //结点的指针域}ListNode,*LinkList;//typedef ListNode *LinkList;void main(){int i;DataType key,x;LinkList head;//ListNode *p;LinkList p;LinkList CreateList(void);void PrintList(LinkList head);LinkList LocateNode(LinkList head,DataType key);LinkList GetNode(LinkList head,int i);void InsertList(LinkList head,DataType x,int i);void DeleteList(LinkList head,int i);void DeleteManyList(LinkList head);void DeleteEvenList(LinkList head);void ChangeCircList(LinkList head);void PrintCircList(LinkList head);head=CreateList(); //建立单链表PrintList(head); //打印单链表cout<<"输入要查找的值:";cin>>key;p=LocateNode(head,key); //单链表查找cout<<"输入要查找的位置:";cin>>i;p=GetNode(head, i);cout<<"请输入欲插入元素的位置:";cin>>i;cout<<"请输入欲插入的元素(整数):";cin>>x;InsertList(head,x,i); //单链表插入PrintList(head); //打印单链表cout<<"请输入欲删除结点的位置:";cin>>i;DeleteList(head,i); //单链表删除PrintList(head); //打印单链表DeleteManyList(head); //删除重复值PrintList(head); //打印单链表DeleteEvenList(head); //删除偶数值PrintList(head); //打印单链表ChangeCircList(head); //修改为循环单链表PrintCircList(head); //打印循环单链表/*void DivideList(LinkList head,LinkList *A,LinkList *B);//分割成两个单链表DivideList(head, &A, &B);PrintList(A);PrintList(B);*/}//单链表的建立:LinkList CreateList(void){LinkList head,p,q;head=new ListNode;head->next=NULL;q=head;cout<<"输入20个整数(以空格分隔):";for(int i=0;i<20;i++){p=new ListNode;cin>>p->data;q->next=p;q=q->next;}q->next=NULL;return head;//在此插入必要的语句}//单链表的打印:void PrintList(LinkList head){LinkList L=head;cout<<"单链表打印:";while(L->next!=NULL){cout<<L->next->data<<" ";L=L->next;}cout<<endl;//在此插入必要的语句}//单链表的查找1:LinkList LocateNode(LinkList head,DataType key) {LinkList L=head;while(L->next!=NULL){{cout<<"找到了!\n";return L;}L=L->next;}cout<<"没找到!\n";return L;//在此插入必要的语句}//*单链表的查找2:LinkList GetNode(LinkList head,int i){LinkList L=head;for(int j=1;j<=i;j++){L=L->next;if(L->next==NULL){cout<<"<警告!您输入的节点位置不存在!>\n查找失败!\n";return L;}}if(i<=0){cout<<"<警告!您输入的节点位置不存在!>\n查找失败!\n";return L;}cout<<L->data;cout<<"找到了!\n";return L;}//单链表的插入:void InsertList(LinkList head,DataType x,int i){LinkList L=head,p;for(int j=1;j<i;j++){//if(L->next->next==NULL){cout<<"<警告!您输入的元素位置不存在,程序自动将数插到链表尾部!>\n";break;}L=L->next;}if(i<=0){cout<<"<警告!您输入的元素位置不存在,程序自动将数插到链表的头结的后面!>\n";}//L=L->next;p=new ListNode;p->data=x;p->next=L->next;L->next=p;//在此插入必要的语句}//单链表的删除:void DeleteList(LinkList head,int i){LinkList L=head;for(int j=1;j<i;j++){L=L->next;if(L->next==NULL){cout<<"<警告!您输入的节点位置不存在!>\n删除失败!\n";return;}}if(i<=0){cout<<"<警告!您输入的节点位置不存在!>\n删除失败!\n";return;}L->next=L->next->next;cout<<"删除成功!\n";//在此插入必要的语句}//删除单链表中重复值:void DeleteManyList(LinkList head){LinkList L=head,p;cout<<"删除链表中重复的元素\n";while(L->next!=NULL){p=L->next;while(p->next!=NULL){if(L->next->data==p->next->data)L->next=L->next->next;p=p->next;}L=L->next;}//在此插入必要的语句}//删除单链表中偶数值:void DeleteEvenList(LinkList head){LinkList L=head;cout<<"删除链表中的偶数值\n";do{if(L->next->data%2==0){if(L->next->next!=NULL)L->next=L->next->next;else{L->next=NULL;break;}}L=L->next;}while(L->next!=NULL);//在此插入必要的语句}//修改为循环单链表:void ChangeCircList(LinkList head){LinkList L=head;cout<<"修改为循环单链表\n";while(L->next!=NULL){L=L->next;}L->next=head;//在此插入必要的语句}//循环单链表的打印:void PrintCircList(LinkList head){LinkList L=head;cout<<"循环单链表打印:";while(L->next!=head){cout<<L->next->data<<" ";L=L->next;}cout<<endl;//在此插入必要的语句}/*//分割成两个单链表void DivideList(LinkList head,LinkList *A,LinkList *B); {//在此插入必要的语句}*/四、运行输出结果:五、调试和运行程序过程中产生的问题及采取的措施:当需要插入和删除的数值超过20时,如果不写:if(L->next==NULL){cout<<"<警告!您输入的节点位置不存在!>\n删除失败!\n";return;}那么就会不产生效果.六、对算法的程序的讨论、分析,改进设想,其它经验教训:七、对实验方式、组织、设备、题目的意见和建议:。
数据结构实验答案
实验一:以单链表表示集合,设计算法建立先后输入的两个集合的差。
说明:已知两个集合A和B,集合A-B中包含所有属于集合A而不属于集合B 的元素。
步骤:1.首先建立A和B的单链表2.然后对集合B中的每个元素x,在A中查找,若存在和x相同的元素,则从该链表中删除。
3.打印A-B,进行验证。
实验二:建立一个二叉树,并进行先序和中序遍历。
(递归和非递归算法)步骤1.补充元素0建立一个满二叉树,存储到一维数组2.利用递归算法建立二叉树,注意零的元素处置3.进行递归、非递归的中序和先序遍历。
打印结果。
实验三:先从键盘输入26个字母生成无序数组,对数组排序后,再从键盘输入一个字符进行折半查找。
实验四:为一个图(maxnode=20)建立一个邻接表、编写深度遍历和广度遍历算法并给出遍历结果。
实验一答案:#include<stdio.h>typedef struct linknode{int data;struct linknode *next;} node;node *creatlist(){node *head,*r,*s;int x;head=(node*)malloc(sizeof(node));r=head;printf("input int and end with \n");scanf("%d",&x);while(x!=0){s=(node*)malloc(sizeof(node));s->data=x;r->next=s;s->next=NULL;r=s;scanf("%d",&x);}r->next=NULL;s=head;head=head->next;free(s);return(head);}void subs(){node *p,*p1,*p2,*q,*heada,*headb;heada=creatlist();headb=creatlist();p=heada;p1=p;while(p!=NULL){q=headb;while(q->data!=p->data && q!=NULL) q=q->next; if(q!=NULL){if(p==heada){heada=heada->next;p1=heada;}else if(p->next==NULL) p1->next=NULL;else p1->next=p->next;p2=p->next;p->next=NULL;free(p);p=p2;}else{p1=p;p=p->next;}}p=heada;if(p==NULL)printf("kong\n");elseprintf(" A - B \n");while(p!=NULL){printf("%d\n",p->data);p=p->next;}}main(){subs();}实验二答案://程序目的建立二叉树,同时对他进行先序排列。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
【实验题】1.狐狸逮兔子围绕着山顶有10个圆形排列的洞,狐狸要吃兔子,兔子说:“可以,但必须找到我,我就藏身于这十个洞中,你先到1号洞找,第二次隔1个洞(即3号洞)找,第三次隔2个洞(即6号洞)找,以后如此类推,次数不限。
”但狐狸从早到晚进进出出了1000次,仍没有找到兔子。
问兔子究竟藏在哪个洞里?(提示:这实际上是一个反复查找线性表的过程。
)【数据描述】定义一个顺序表,用具有10个元素顺序表来表示这10个洞。
每个元素分别表示围着山顶的一个洞,下标为洞的编号。
#define LIST_INIT_SIZE 10 //线性表存储空间的初始分配量typedef struct {ElemType *elem; //存储空间基址int length; //当前长度int listsize; //当前分配的存储容量(以sizeof(ElemType)为单位)}SqList;【算法描述】status InitList_Sq(SqList &L) {//构造一个线性表LL.elem=(ElemType )malloc(LIST_INIT_SIZE*sizeof(ElemType));If(!L.elem) return OVERFLOW; //存储分配失败L.length=0; //空表长度为0L.listsize=LIST_INIT_SIZE; //初始存储容量return OK;} //InitList_Sqstatus Rabbit(SqList &L){ //构造狐狸逮兔子函数int current=0; //定义一个当前洞口号的记数器,初始位置为第一个洞口for(i=0;i<LIST_INIT_SIZE;i++)L.elem[i]=1; //给每个洞作标记为1,表示狐狸未进之洞L.elem[LIST_INIT_SIZE-1]=L.elem[0]=0;//首先进入第一个洞,标记进过的洞为0。
for(i=2;i<=1000;i++){ current=(current+i)%LIST_INIT_SIZE;//实现顺序表的循环引用L.elem[i]=0; // 标记进过的洞为0}//第二次隔1个洞找,第三次隔2个洞找,以后如此类推,经过一千次printf("兔子可能藏在如下的洞中:")for(i=0;i<LIST_INIT_SIZE;i++)if(L.elem[i]==1)printf(“第%d个洞\n ”,i+1);//输出未进过的洞号return OK;}//end【C源程序】#include <stdio.h>#include <stdlib.h>#define OK 1#define OVERFLOW -2typedef int status;typedef int ElemType;#define LIST_INIT_SIZE 10 /*线性表存储空间的初始分配量*/typedef struct {ElemType *elem; /* 存储空间基址*/int length; /* 当前长度*/int listsize; /*当前分配的存储容量(以sizeof(ElemType)为单位)*/}SqList;status InitList_Sq(SqList *L){/*构造一个线性表L */(*L).elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!((*L).elem)) return OVERFLOW; /* 存储分配失败*/(*L).length=0; /*空表长度为0 */(*L).listsize=LIST_INIT_SIZE; /*初始存储容量*/return OK;} /*InitList_Sq */status Rabbit(SqList *L){/*构造狐狸逮兔子函数*/int i,current=0; /*定义一个当前洞口号的记数器,初始位置为第一个洞口*/ for(i=0;i<LIST_INIT_SIZE;i++)(*L).elem[i]=1; /*给每个洞作标记为1,表示狐狸未进之洞*/ (*L).elem[LIST_INIT_SIZE-1]=0;(*L).elem[0]=0; /*第一次进入第一个洞,标记进过的洞为0 */for(i=2;i<=1000;i++){ current=(current+i)%LIST_INIT_SIZE;/*实现顺序表的循环引用*/ (*L).elem[current]=0; /* 标记进过的洞为0 */}/*第二次隔1个洞找,第三次隔2个洞找,以后如此类推,经过一千次*/ printf("\n兔子可能藏在如下的洞中:") ;for(i=0;i<LIST_INIT_SIZE;i++)if((*L).elem[i]==1)printf(" \n此洞是第%d号洞",i+1);/*输出未进过的洞号*/return OK;}void main(){SqList *L;InitList_Sq(L);Rabbit(L);getch();}【测试数据】最后的输出结果为:2 4 7 9【说明】本算法思路比较简单,采用了顺序表表示围着山顶的10个洞,首先对所有洞设置标志为1,然后通过1000次循环,对每次所进之洞修改标志为0,最后输出标志为1的洞。
2.银行客户某银行有一个客户办理业务站,在单位时间内随机地有客户到达,设每位客户的业务办理时间是某个范围内的随机值。
设只有一个窗口,一位业务人员,要求程序模拟统计在设定时间内,业务人员的总空闲时间和客户的平均等待时间。
假定模拟数据已按客户到达的先后顺序依次存于某个正文数据文件中。
对应每位客户有两个数据,到达时间和需要办理业务的时间。
复习概念:与栈相对应,队列是一种先进先出的线性表。
它只允许在表的一端进行插入,而在另一端进行删除元素。
允许插入的一端称队尾,允许删除的一端称队头。
插入与删除分别称为入队与出队。
队列示意图见图3-2:出队←a1a2 ……an-1 ←an进队队头队尾【数据描述】typedef struct{int arrive;int treat;//客户的信息结构}QNODE;typedef struct node{QNODE data;Struct node *next;//队列中的元素信息}LNODELNODE *front,*rear;// 队头指针和队尾指针【算法描述】{ 设置统计初值;设置当前时钟时间为0;打开数据文件,准备读;读入第一位客户信息于暂存变量中;do{ //约定每轮循环,处理完一位客户if(等待队列为空,并且还有客户){ //等待队列为空时累计业务员总等待时间;时钟推进到暂存变量中的客户的到达时间;暂存变量中的客户信息进队;读取下一位客户信息于暂存变量;}累计客户人数;从等待队列出队一位客户;将该客户的等待时间累计到客户的总等待时间;设定当前客户的业务办理结束时间;while(下一位客户的到达时间在当前客户处理结束之前){暂存变量中的客户信息进队;读取下一位客户信息于暂存变量;}时钟推进到当前客户办理结束时间;}while(还有未处理的客户);计算统计结果,并输出;【C源程序】#include<stdio.h>#include<stdlib.h>#define OVERFLOW -2typedef struct{int arrive;int treat; /*客户的信息结构*/}QNODE;typedef struct node{QNODE data;struct node *next; /*队列中的元素信息*/}LNODE;LNODE *front,*rear;/* 队头指针和队尾指针*/QNODE curr,temp;char Fname[120];FILE *fp;void EnQueue(LNODE **hpt,LNODE **tpt,QNODE e){/*队列进队*/LNODE *p=(LNODE *)malloc(sizeof(LNODE));if(!p) exit(OVERFLOW); /*存储分配失败*/p->data=e;p->next=NULL;if(*hpt==NULL) *tpt=*hpt=p;else *tpt=(*tpt)->next=p;}int DeQueue(LNODE **hpt,LNODE **tpt,QNODE *cp){/*链接队列出队*/LNODE *p=*hpt;if(*hpt==NULL) return 1;/*队空*/*cp=(*hpt)->data;*hpt=(*hpt)->next;if(*hpt==NULL) *tpt=NULL;free(p);return 0;}void main(){ int dwait=0,clock=0,wait=0,count=0,have=0,finish;printf("\n enter file name:");scanf("%s",Fname);/*输入装客户模拟数据的文件的文件名*/if((fp=fopen(Fname, "r"))==NULL){ /*打开数据文件*/printf("cannot open file %s",Fname);return;}front=NULL;rear=NULL;have=fscanf(fp, "%d%s",&temp.arrive,&temp.treat);do{ /*约定每轮循环,处理一位客户*/if(front==NULL && have==2){ /*等待队列为空,但还有客户*/dwait+=temp.arrive-clock; /*累计业务员总等待时间*/clock=temp.arrive; /*时钟推进到暂存变量中的客户的到达时间*/ EnQueue(&front,&rear,temp); /* 暂存变量中的客户信息进队*/have=fscanf(fp, "%d%d",&temp.arrive,&temp.treat);}count++; /*累计客户人数*/ DeQueue(&front,&rear,&curr);/*出队一位客户信息*/wait+=clock-curr.arrive; /*累计到客户的总等待时间*/finish=clock+curr.treat;/*设定业务办理结束时间;*/while(have==2 && temp.arrive<=finish){/*下一位客户的到达时间在当前客户处理结束之前*/EnQueue(&front,&rear,temp);/* 暂存变量中的客户信息进队*/have=fscanf(fp, "%d%d",&temp.arrive,&temp.treat);}clock=finish; /* 时钟推进到当前客户办理结束时间*/}while(have==2 || front!=NULL);printf("结果:业务员等待时间%d\n客户平均等待时间%f\n",dwait,(double)wait/count);printf("模拟总时间:%d,\n客户人数:%d,\n总等待时间:%d\n",clock, count,wait);getch();}/*main_end*/’【测试数据】设数据装在一个数据文件data.dat中,内容为:10 6 13 8显示结果为:enter file name:data.datenter file name:data.dat结果:业务员等待时间10客户平均等待时间25.500000模拟总时间:72,客户人数:2,总等待时间:51【说明】在计算程序中,程序按模拟环境中的事件出同顺序逐一处理事件:当一个事件结束时,下一个事件隔一段时间才发生,则程序逻辑的模拟时钟立即推进到下一事件的发生时间;如一个事件还未处理结束之前,另有其他事件等待处理,则这些事件就应依次排队等候处理。