线性链表实验报告
数据结构线性表试验报告(最终定稿)
![数据结构线性表试验报告(最终定稿)](https://img.taocdn.com/s3/m/75e7a0f748649b6648d7c1c708a1284ac85005d8.png)
数据结构线性表试验报告(最终定稿)第一篇:数据结构线性表试验报告线性表上机实习1、实验目的(1)熟悉将算法转换为程序代码的过程。
(2)了解顺序表的逻辑结构特性,熟练掌握顺序表存储结构的C 语言描述方法。
(3)熟练掌握顺序表的基本运算:查找、插入、删除等,掌握顺序表的随机存取特性。
(4)了解线性表的链式存储结构,熟练掌握线性表的链式存储结构的C语言描述方法。
(5)熟练掌握线性链表(单链表)的基本运算:查找、插入、删除等,能在实际应用中灵活选择适当的链表结构。
2、实验要求(1)熟悉顺序表的插入、删除和查找。
(2)熟悉单链表的插入、删除和查找。
3、实验内容: ① 顺序表(1)抽象数据类型定义typedef struct {TypeData data[maxsize];//容量为maxsize的静态顺手表int n;//顺序表中的实际元素个数}SeqList;//静态顺序表的定义在本次实验中,首先建立一个空的静态顺序表,然后键盘输入数据存入表中,然后进入菜单选择界面,通过不同的数字输入,实现对顺序表,删除,插入,查找,显示等操作。
(2)存储结构定义及算法思想在顺序表结构体的定义中,typedef int TypeData 为整型,存储结构如下:for(n=0;ncout<<“请输入线性表数据”<cin>>L.data[n];//顺序将数据存入顺序表}//其他存储与此类似,都是直接赋值与数组的某一位插入版块子函数:void insert(SeqList &L)//插入数据 {int a,b,c,k;cout<<“请输入插入的数及其插入的位置”<cin>>a>>b;if(b<=0||b>(L.n+1)){cout<<“不能在该位置插入”<k=L.data[b-1];L.data[b-1]=a;c=L.n;L.n=L.n+1;while(c>b){L.data[c]=L.data[c-1];c--;//通过循环,实现插入位置后的数据挨个往后移动一位}L.data[b]=k;} 顺序表的插入与删除操作类似,在插入与删除后,都要循环调整后面数组的每一位元素,同时记录数据元素的长度的标示符也要跟着改变。
线性表的链式存储结构实验报告
![线性表的链式存储结构实验报告](https://img.taocdn.com/s3/m/623ab34b03d8ce2f006623f8.png)
实验报告课程名称:数据结构与算法分析实验名称:链表的实现与应用实验日期:班级:数媒1401 姓名:范业嘉学号一、实验目的掌握线性表的链式存储结构设计与基本操作的实现。
二、实验内容与要求⑴定义线性表的链式存储表示;⑵基于所设计的存储结构实现线性表的基本操作;⑶编写一个主程序对所实现的线性表进行测试;⑷线性表的应用:①设线性表L1和L2分别代表集合A和B,试设计算法求A和B的并集C,并用线性表L3代表集合C;②(选做)设线性表L1和L2中的数据元素为整数,且均已按值非递减有序排列,试设计算法对L1和L2进行合并,用线性表L3保存合并结果,要求L3中的数据元素也按值非递减有序排列。
⑸设计一个一元多项式计算器,要求能够:①输入并建立多项式;②输出多项式;③执行两个多项式相加;④执行两个多项式相减;⑤(选做)执行两个多项式相乘。
三、数据结构设计1.按所用指针的类型、个数、方法等的不同,又可分为:线性链表(单链表)静态链表循环链表双向链表双向循环链表2.用一组任意的存储单元存储线性表中数据元素,用指针来表示数据元素间的逻辑关系。
四、算法设计1.定义一个链表void creatlist(Linklist &L,int n){int i;Linklist p,s;L=(Linklist)malloc(sizeof(Lnode));p=L;L->next=NULL;for(i=0;i<n;i++){s=(Linklist)malloc(sizeof(Lnode));scanf("%d",&s->data);s->next=NULL;p->next=s; p=s;}}2.(1)两个链表的合并void Mergelist(Linklist &La,Linklist &Lb,Linklist &Lc) {Linklist pa,pb,pc;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;free(Lb);}(2)两个链表的并集Linklist unionlist(Linklist &La,Linklist &Lb){Linklist p1,p2,head,q,s;int flag;head=q=(Linklist)malloc(sizeof(Lnode));p1=La->next;while(p1){flag=0;p2=Lb->next;while(p2){if(p1->data==p2->data){flag=1;break;}p2=p2->next;}if(flag==0){s=(Linklist)malloc(sizeof(Lnode));s->data=p1->data;q->next=s;q=s;}p1=p1->next;}q->next=Lb->next;return head;}3.(1)一元多项式的加法List addpoly(List pa,List pb) //一元多项式的加法{int n;List pc,s,p;pa=pa->next;pb=pb->next;pc=(List)malloc(sizeof(struct Linklist));pc->next=NULL;p=pc;while(pa!=NULL&&pb!=NULL){if(pa->expn>pb->expn){s=(List)malloc(sizeof(struct Linklist));s->expn=pa->expn;s->coef=pa->coef;s->next=NULL;p->next=s;p=s;pa=pa->next;}else if(pa->expn<pb->expn){s=(List)malloc(sizeof(struct Linklist));s->expn=pb->expn;s->coef=pb->coef;s->next=NULL;p->next=s;p=s;pb=pb->next;}else{n=pa->coef+pb->coef;if(n!=0){s=(List)malloc(sizeof(struct Linklist));s->expn=pa->expn;s->coef=n;s->next=NULL;p->next=s;p=s;}pb=pb->next;pa=pa->next;}}while(pa!=NULL){s=(List)malloc(sizeof(struct Linklist));s->expn=pa->expn;s->coef=pa->coef;s->next=NULL;p->next=s;p=s;pa=pa->next;}while(pb!=NULL){s=(List)malloc(sizeof(struct Linklist));s->expn=pb->expn;s->coef=pb->coef;s->next=NULL;p->next=s;p=s;pb=pb->next;}return pc;}(2)一元多项式的减法List subpoly(List pa,List pb) //一元多项式的减法{int n;List pc,s,p;pa=pa->next;pb=pb->next;pc=(List)malloc(sizeof(struct Linklist));pc->next=NULL;p=pc;while(pa!=NULL&&pb!=NULL){if(pa->expn>pb->expn){s=(List)malloc(sizeof(struct Linklist));s->expn=pa->expn;s->coef=pa->coef;s->next=NULL;p->next=s;p=s;pa=pa->next;}else if(pa->expn<pb->expn){s=(List)malloc(sizeof(struct Linklist));s->expn=pb->expn;s->coef=-pb->coef;s->next=NULL;p->next=s;p=s;pb=pb->next;}else{n=pa->coef-pb->coef;if(n!=0){s=(List)malloc(sizeof(struct Linklist));s->expn=pa->expn;s->coef=n;s->next=NULL;p->next=s;p=s;}pb=pb->next;pa=pa->next;}}while(pa!=NULL){s=(List)malloc(sizeof(struct Linklist));s->expn=pa->expn;s->coef=pa->coef;s->next=NULL;p->next=s;p=s;pa=pa->next;}while(pb!=NULL){s=(List)malloc(sizeof(struct Linklist));s->expn=pb->expn;s->coef=-pb->coef;s->next=NULL;p->next=s;p=s;pb=pb->next;}return pc;}(3)一元多项式的乘法void mulpolyn(polynomail pa,polynomail pb,polynomail &pc) {LNode *p,*q,*s,*hc;p=pa->next;q=pb->next;hc=pc;while(p!=NULL){while(q!=NULL){s=(polynomail)malloc(sizeof(LNode));hc->next=s;hc=hc->next;hc->coef=q->coef*p->coef;hc->expn=q->expn+p->expn;q=q->next;}p=p->next;q=pb->next;}hc->next=NULL;}五、测试结果2.3.六、心得体会(包括对于本次实验的小结,实验过程中碰到的问题等)1.首先书上给的链表输入是倒序的,写的时候想都没想就抄上去了,结果运行时发现问题,可是上网百度依然没有把问题解决,导致最后输出链表倒序的,并且链表的合并并集依旧是倒序的。
(完整版)数据结构线性表的应用实验报告
![(完整版)数据结构线性表的应用实验报告](https://img.taocdn.com/s3/m/6fbe509102020740bf1e9b29.png)
实验报告课程名称____数据结构上机实验__________ 实验项目______线性表的应用 ____________实验仪器________PC机___________________系别_____电子信息与通信学院___专业________ ___班级/学号______ __学生姓名______ ___________实验日期_______________________成绩_______________________指导教师_______________________实验一.线性表的应用1.实验目的:掌握线性链表的存储、运算及应用。
利用链表实现一元多项式计算。
2.实验内容:1)编写函数,实现用链表结构建立多项式;2)编写函数,实现多项式的加法运算;3)编写函数,实现多项式的显示;4)测试:编写主函数,它定义并建立两个多项式,显示两个多项式,然后将它们相加并显示结果。
变换测试用的多项式,检查程序的执行结果。
选做内容:修改程序,选择实现以下功能:5)多项式求值:编写一个函数,根据给定的x值计算并返回多项式f(x)的值。
测试该函数(从终端输入一个x的值,调用该函数并显示返回结果)。
6)多项式相减:编写一个函数,求两个多项式相减的多项式。
7)多项式相乘:编写一个函数,求两个多项式的乘积多项式。
3.算法说明:1)多项式的建立、显示和相加算法见讲义。
可修改显示函数,使输出的多项式更符合表达规范。
2)多项式减法:同次项的系数相减(缺项的系数是0)。
例如a(x)=-5x2+2x+3,b(x)= -4x3+3x,则a(x)-b(x)=4x3-5x2-x+3。
提示:a(x)-b(x) = a(x)+(-b(x))。
3)多项式乘法:两个多项式的相乘是“系数相乘,指数相加”。
算法思想是用一个多项式中的各项分别与另一个多项式相乘,形成多个多项式,再将它们累加在一起。
例如,a(x)=-5x2+2x+3,b(x)=-4x3+3x,则a(x)*b(x) = (-4x3)*(-5x2+2x+3)+(3x)*(-5x2+2x+3)= (20x5-8x4-12x3) + (-15x3+6x2+9x) =20x5-8x4-27x3+6x2+9x。
数据结构实验报告实验一线性表链式存储运算的算法实现
![数据结构实验报告实验一线性表链式存储运算的算法实现](https://img.taocdn.com/s3/m/c68c87c3b90d6c85ed3ac695.png)
昆明理工大学信息工程与自动化学院学生实验报告(201 —201学年第一学期)
课程名称:数据构造开课实验室:
年级、专业、班学号姓名
实验项目名称线性表链式储存运算的算法实现指导教师
年
成绩
月日
教
师
评教师署名:
语年月日一. 实验内容:
线性表链式储存运算的算法实现,实现链表的成立、链表的数据插入、链表的数据删除、链表的数据输出。
二.实验目的:
1.掌握线性表链式储存构造的 C语言描绘及运算算法的实现;
2.剖析算法的空间复杂度和插入和删除的时间复杂度;
3.总结比较线性表次序储存藏储与链式储存的各自特色。
三. 主要程序代码剖析:
LinkList creatListR1()序运转结果:
五. 实验总结:
经过线性表链式储存运算的算法实现的上机实验,我认识了链式的基来源理和方法,能编程对数据进行链式储存。
因为次序储藏是用物理地点上的毗邻关系来表示结点间的逻
辑关系,其插入或删除运算不方便,并且当表长变化较大时,难以确立适合的储存规模,
为认识决这些问题,我们采纳链接方式储存线性表。
因此,当线性表的长度变化较大,难
以预计其储存规模时,以采纳动向链表作为储存构造为好;假如关于屡次进行插入删除的
线性表,以采纳链表做储存构造。
链接储存是最常用的储存方法之一,它不单能够表示线
性表,还能够用来表示各样非线性的数据构造。
链表实验报告1
![链表实验报告1](https://img.taocdn.com/s3/m/fd00ea4bdcccda38376baf1ffc4ffe473368fd1e.png)
1、熟练掌握线性表的基本操作在两种存储结构上的实现。
2、会用线性链表解决简单的实际问题。
该程序的功能是实现单链表的定义和操作。
该程序包括单链表结构类型以及对单链表操作的具体的函数定义和主函数。
其中,程序中的单链表(带头结点)结点为结构类型,结点值为整型。
单链表操作的选择以菜单形式浮现,如下所示:please input the operation:1.初始化2.清空3.求链表长度4.检查链表是否为空5.检查链表是否为满 6.遍历链表(设为输出元素) 7.从链表中查找元素 8.从链表中查找与给定元素值相同的元素在表中的位置9.向链表中插入元素 10. 从链表中删除元素其他键退出。
设编号为 1,2,3,……, n 的 n(n>0)个人按顺时针方向围坐一圈,每一个人持有一个正整数密码。
开始时任选一个正整数做为报数上限 m,从第一个人开始顺时针方向自 1 起顺序报数,报到 m 时住手报数,报 m 的人出列,将他的密码作为新的m 值,从他的下一个人开始重新从 1 报数。
如此下去,直到所有人全部出列为止。
令n 最大值取 30。
要求设计一个程序摹拟此过程,求出出列编号序列。
struct node //结点结构{int number; /* 人的序号*/int cipher; /* 密码*/struct node *next; /* 指向下一个节点的指针*/};/* 定义 DataType 为 int 类型 */typedef int DataType;/* 单链表的结点类型 */typedef struct LNode{ DataType data;struct LNode *next;}LNode,*LinkedList;LinkedList LinkedListInit(){ //函数功能:对链表进行初始化参数:链表(linklist L) 成功初始化返回 1, 否则返回 0 }void LinkedListClear(LinkedList &L){//函数功能:把链表清空参数:链表(linklist L) 成功清空链表返回 1 }int LinkedListEmpty(LinkedList L){ //函数功能:判断链表是否为空参数:链表(linklist L) 链表为空时返回 0, 不为空返回 1 }void LinkedListTraverse(LinkedList L){ //函数功能:遍历链表,输出每一个节点的 elem 值参数:链表(linklist L) 通过循环逐个输出节点的 elem 值 }int LinkedListLength(LinkedList L){ //函数功能:返回链表的长度参数:链表(linklistL) 函数返回链表的长度 }LinkedList LinkedListGet(LinkedList L,int i){ //函数功能: 从链表中查找有无给定元素参数;链表(linklist L),给定元素 (int i) 如果链表中有给定元素(i)则返回 1,否则返回 0 }LinkedList LinkedListLocate(LinkedList L, DataType x){//函数功能: 从链表中查找给定元素的位置参数;链表(linklist L),给定元素(int i) 如果链表中有给定元素 i 则返回元素的位置, 没有则返回 0 }void LinkedListInsert(LinkedList &L,int i,DataType x)}void LinkedListDel(LinkedList &L,DataType x)i 个结点 }(二)、zhujiemian();cin>>a;do{switch(a){case 1:if(init(L)==1)cout<<"成功初始化! "<<endl;elsecout<<"初始化失败! "<<endl;break;case 2:if(makeempty(L)==1)cout<<"链表已清空! "<<endl;elsecout<<"链表清空失败! "<<endl;break;case 3:b=getlength(L);cout<<"链表的长度为: "<<b<<endl;break;case 4:if(isempty(L)==1)cout<<"链表不为空! "<<endl;elsecout<<"链表为空! "<<endl;break;case 5:if(isfull(L)==1)cout<<"链表不满! "<<endl;elsecout<<"链表已满! "<<endl;break;case 6:show(L);break;case 7:cout<<"输入您要查找的元素: ";cin>>b;if(find(L,b)==1)cout<<"链表中有该元素"<<b<<endl;elsecout<<"链表中没有您要查找的元素"<<b<<endl;break;case 8:cout<<"您要查找的元素为: "<<endl;cin>>b;if(location(L,b)==0)cout<<"没有您要查找的元素"<<b<<endl;elsecout<<"您查找的元素 "<<b<<"在第"<<location(L,b)<<"个位置。
实验五__线性表的链式表示和实现
![实验五__线性表的链式表示和实现](https://img.taocdn.com/s3/m/124fda84cc22bcd126ff0cb5.png)
浙江大学城市学院实验报告课程名称数据结构基础实验项目名称实验五线性表的链式表示和实现学生姓名专业班级学号实验成绩指导老师(签名)日期一.实验目的和要求1、了解线性表的链式存储结构,学会定义线性表的链式存储结构。
2、掌握单链表、循环单链表的一些基本操作实现函数。
二.实验内容1、设线性表采用带表头附加结点的单链表存储结构,请编写线性表抽象数据类型各基本操作的实现函数,并存放在头文件LinkList.h中(注:教材上为不带表头附加结点)。
同时建立一个验证操作实现的主函数文件test5.cpp,编译并调试程序,直到正确运行。
提示:⑴单向链表的存储结构可定义如下:struct LNode { // 定义单链表节点类型ElemType data; // 存放结点中的数据信息LNode *next; // 指示下一个结点地址的指针}⑵线性表基本操作可包括如下一些:①void InitList (LNode *&H) //初始化单链表②void ClearList(LNode *&H) //清除单链表③int LengthList (LNode *H) //求单链表长度④bool EmptyList (LNode *H) //判断单链表是否为空表⑤ElemType GetList (LNode *H, int pos)//取单链表第pos 位置上的元素⑥void TraverseList(LNode *H) //遍历单链表⑦bool InsertList ( LNode *&H, ElemType item, int pos)//向单链表插入一个元素⑧bool DeleteList ( LNode *&H, ElemType &item, int pos)//从单链表中删除一个元素⑶带表头附加结点的单链表初始化操作的实现可参考如下:void InitList(LNode *&H){ //构造一个空的线性链表H,即为链表设置一个头结点,//头结点的data数据域不赋任何值,头结点的指针域next则为空H=(LNode *)malloc(sizeof(LNode)); // 产生头结点Hif (!H) exit(0); // 存储分配失败,退出系统H->next=NULL; // 指针域为空}2、选做部分:编写一个函数void MergeList(LNode *&La, LNode *&Lb, LNode *&Lc),实现将两个有序单链表La和Lb合并成一个新的有序单链表Lc,同时销毁原有单链表La和Lb。
线性表实验报告
![线性表实验报告](https://img.taocdn.com/s3/m/27821d43c4da50e2524de518964bcf84b8d52d60.png)
XX学院计算机科学与技术系实验报告本课程名称数据结构(c语言版)指导教师XXX班级2011级计科XX班学号******XXXX姓名XXX开课学期2012 学年第一学期撰写及拟改实验报告注意事项一、填写信息1.填写信息齐全、字迹清晰、日期真实;2.每次实验信息应填写完整, 如: 实验序号及实验项目;3、每次实验时间应如实填写完整, 如:第周星期第节;4、实验报告撰写认真细致, 图例完整, 有大量源代码的可以附页。
二、批改实验报告1.一律采用等级制;2、批改时应对错分明, 错误之处应有文字说明或指出错误的标记;3.批改后的签名和日期应完整。
计算机专业实验课程考试与考核为推动实验教学改革, 规范实验课程考试与考核, 提高学生实践动手能力。
计算机专业实验部对实验课程考试与考核方法如下规定。
1.考核以实验课程的教学大纲为准。
➢2、根据课程性质, 采用考核制, 总成绩采用等级制计分。
➢以本实验课程完成的实验内容为依托, 独立完成老师布置的验证性、综合性、设计性、创新性实验项目。
重点考查学生实验态度, 在实验过程中能否及时发现问题, 解决问题, 是否有创新性设计思想。
➢实验过程考核●学生在实验过程中能否独立、及时完成实验任务, 态度是否端正, 对工具、仪器能否正确使用等;●实验操作是否规范、代码编写是否正确;●实验报告撰写是否规范、工整。
➢实验成绩评分标准●独立完成实验项目, 实验结果正确, 实验报告撰写规范, 并有创新性设计思想;优;●独立完成实验项目, 实验结果正确, 实验报告撰写规范。
良;●独立完成实验项目, 实验结果基本正确, 实验报告撰写规范。
中;●在老师的指导下, 基本完成实验项目, 实验结果基本正确, 实验报告撰写规范。
及格;●不能完成实验项目, 实验结果不正确, 实验报告撰写不规范。
不及格。
实验项目名称线性链表的实现与应用实验项目评分实验序号1 实验时间 2 周星期第节4.实验结果与分析:5、源代码:#include<stdio.h>#include<iostream>#include<string>struct node *createlist(int n); //创建链表void print(struct node *p);//输出链表void listinsert(struct node *head,int m);//插入元素void listdelete(struct node *head,int a);//删除元素void search(struct node *head,int X);//查找元素void PDlist(struct node *head);//判断链表是否为空void getelem(struct node *head,int b);//返回元素的值void listlen();//链表的长度int length;指导教师签名批改报告时间2012 年9 月日。
线性链表及堆栈实验报告
![线性链表及堆栈实验报告](https://img.taocdn.com/s3/m/72f38340336c1eb91a375d87.png)
实验一顺序存储线性表的基本运算一、实验目的1、掌握线性表的定义、顺序存储的方法及基本操作。
2、掌握将算法在VC++6.0语言环境下实现的过程。
二、实验仪器和设备1、PC微机2、Microsoft VC++6.0三、实验内容1、利用线性表的顺序存储结构完成一个班级的一个学期的所有课程成绩的管理,要求实现增加、删除学生的成绩记录等运算。
2、分析题意,确定算法。
线性表的长度设为全班人数(为方便起见设为3人),一个学期的课程设为三门。
画出程序框图如下:是四、实验步骤1、分析题意,确定算法。
线性表的长度设为全班人数(3人),一个学期的课程设为三门,定义如下:#define Max_length 3typedef struct{int xh; /*学号*/char name[10]; /*姓名*/int c1,c2,c3; /*三门课程成绩*/} Element;1、编辑C语言源程序。
(1)分别编写插入、删除、修改、查找的算法。
Element s[3];/*在第i个记录的后面插入一个学生的记录算法,n_pointer存放已输入的最大记录数*/ int Insert_list (int i,Element s[],int *n_pointer){/*n_pointer存放已输入的最大记录数*/int j,n;n=*n_pointer;if((n== Max_length)||(i<0)||(i>n)){return (0);}for(j=n;j>=i;j--){s[j+1]=s[j]; /*从j开始往后移动*/}printf("Input Data for inserting (学号姓名成绩成绩成绩) \n");scanf("%d%s%d%d%d",&s[i].xh,&s[i].name,&s[i].c1,&s[i].c2,&s[i].c3);n++;*n_pointer=n; //记录数加return (1);}/*删除第i个学生的记录算法*/int Delete_list(int i,Element s[] ,int *n_pointer){int j,n;n=*n_pointer;if((i<0)||(i>n)){return(0);}for (j=i+1;j<=n;j++){/*移动*/s[j-1].xh=s[j].xh;strcpy(s[j-1].name,s[j].name);s[j-1].c1=s[j].c1;s[j-1].c2=s[j].c2;s[j-1].c3=s[j].c3;}n--;*n_pointer=n;return (1);}/*查找学号为x的算法*//*接口定义:x为要查找的学号,Element s[ ],n为已存储的记录数返回位置i*/int Locate_list (Element s[], int n, int x){int i;for(i=0;i<n;i++){if (s[i].xh==x)return (i);}return (0);}/*修改第i的学生的记录函数*/int Change_list (int i, Element s[] ){if( (i<0)||(i>Max_length ) ) return (0);printf ("Input data for updating :\n");scanf ("%d%s%d%d%d",s[i].xh,s[i].name,s[i].c1,s[i].c2,s[i].c3);return (1);}/*打印已建立的数据记录,n是记录总数*/void Printf_list (Element s[],int n){int i;// if(n>Max_length)// return (0);printf ("学号姓名成绩成绩成绩 \n");printf("--------------------------------------------\n");for(i=0;i<n;i++){printf ("%4d%10s%7d%7d%7d\n",s[i].xh,s[i].name,s[i].c1,s[i].c2,s[i].c3);}}(2)编写主函数调用上述各函数。
实验一线性表操作实验报告
![实验一线性表操作实验报告](https://img.taocdn.com/s3/m/2cf90cbc05a1b0717fd5360cba1aa81144318f09.png)
实验一_线性表操作_实验报告实验一:线性表操作一、实验目的1.理解线性表的基本概念和特点。
2.掌握线性表的基本操作,包括插入、删除、查找等。
3.通过实验,提高动手能力和解决问题的能力。
二、实验原理线性表是一种较为常见的数据结构,它包含零个或多个数据元素,相邻元素之间有前后关系。
线性表具有以下特点:1.元素之间一对一的顺序关系。
2.除第一个元素外,每个元素都有一个直接前驱。
3.除最后一个元素外,每个元素都有一个直接后继。
常见的线性表有数组、链表等。
本实验主要针对链表进行操作。
三、实验步骤1.创建链表:首先创建一个链表,并给链表添加若干个节点。
节点包括数据域和指针域,数据域存储数据,指针域指向下一个节点。
2.插入节点:在链表中插入一个新的节点,可以选择在链表的头部、尾部或中间插入。
3.删除节点:删除链表中的一个指定节点。
4.查找节点:在链表中查找一个指定数据的节点,并返回该节点的位置。
5.遍历链表:从头节点开始,依次访问每个节点的数据。
四、实验结果与分析1.创建链表结果:我们成功地创建了一个链表,每个节点都有数据域和指针域,数据域存储数据,指针域指向下一个节点。
2.插入节点结果:我们成功地在链表的头部、尾部和中间插入了新的节点。
插入操作的时间复杂度为O(1),因为我们只需要修改指针域即可。
3.删除节点结果:我们成功地删除了链表中的一个指定节点。
删除操作的时间复杂度为O(n),因为我们可能需要遍历整个链表才能找到要删除的节点。
4.查找节点结果:我们成功地在链表中查找了一个指定数据的节点,并返回了该节点的位置。
查找操作的时间复杂度为O(n),因为我们可能需要遍历整个链表才能找到要查找的节点。
5.遍历链表结果:我们成功地遍历了整个链表,并访问了每个节点的数据。
遍历操作的时间复杂度为O(n),因为我们可能需要遍历整个链表。
通过本次实验,我们更加深入地理解了线性表的基本概念和特点,掌握了线性表的基本操作,包括插入、删除、查找等。
线性表的链式存储结构实验报告
![线性表的链式存储结构实验报告](https://img.taocdn.com/s3/m/73e729f8db38376baf1ffc4ffe4733687e21fced.png)
线性表的链式存储结构实验报告实验一:线性表的链式存储结构【问题描述】某项比赛中,评委们给某参赛者的评分信息存储在一个带头结点的单向链表中,编写程序:(1)显示在评分中给出最高分和最低分的评委的有关信息(姓名、年龄、所给分数等)。
(2)在链表中删除一个最高分和一个最低分的结点。
(3)计算该参赛者去掉一个最高分和一个最低分后的平均成绩。
【基本要求】(1)建立一个评委打分的单向链表;(2)显示删除相关结点后的链表信息。
(3)显示要求的结果。
【实验步骤;】(1)运行PC中的Microsoft Visual C++ 6.0程序,(2)点击“文件”→“新建”→对话窗口中“文件”→“c++ Source File”→在“文件名”中输入“X1.cpp”→在“位置”中选择储存路径为“桌面”→“确定”,(3)输入程序代码,程序代码如下:head=create(PWRS);printf("所有评委打分信息如下:\n");print(head);//显示当前评委打分calc(head);//计算成绩printf("该选手去掉 1 最高分和 1 最低分后的有效评委成绩:\n");print(head);//显示去掉极限分后的评委打分}void input(NODE *s) #include#include#include#include#include#define NULL 0#define PWRS 5 //定义评委人数struct pw //定义评委信息{ char name[6];float score;int age;};typedef struct pw PW;struct node //定义链表结点{struct pw data;struct node * next;};typedef struct node NODE;//自定义函数的声明NODE *create(int m); //创建单链表int calc(NODE *h); //计算、数据处理void print(NODE *h); //输出所有评委打分数据void input(NODE *s);//输入评委打分数据void output(NODE *s);//输出评委打分数据void main(){NODE *head;float ave=0;float sum=0;{printf("请输入评委的姓名: ");scanf("%S",&s->/doc/433085523.html,); printf("年龄: ");scanf("%d",&s->data.age);printf("打分: ");scanf("%f",&s->data.score);printf("\n");}void output(NODE *s){printf("评委姓名: %8s ,年龄: %d,打分: %2.2f\n",s->/doc/433085523.html,,s->data. age,s->data.score);}NODE *create(int m){NODE *head,*p,*q;int i;p=(NODE*)malloc(sizeof(NODE));head=p;q=p;p->next=NULL;for(i=1;i<=m;i++){p=(NODE*)malloc(sizeof(NODE));input(p);p->next=NULL;q->next=p;q=p;}return (head);}void print(NODE *h){ for(int i=1;((i<=PWRS)&&(h->next!=NULL));i++){h=h->next;output(h); }printf("\n");}int calc(NODE *h){NODE *q,*p,*pmin,*pmax;float sum=0;float ave=0;p=h->next; //指向首元结点pmin=pmax=p; //设置初始值sum+=p->data.score;p=p->next;for(;p!=NULL;p=p->next){if(p->data.score>pmax->data.score) pmax=p;if(p->data.scoredata.score) pmin=p;sum+=p->data.score;}cout<<"给出最高分的评委姓名:"</doc/433085523.html,<<"年龄:"<data.age<<"分值:"<data.score<<endl;< bdsfid="172" p=""></endl;<>cout<<"给出最低分的评委姓名:"</doc/433085523.html,<<"年龄:"<data.age<<"分值:"<data.score<<endl;< bdsfid="177" p=""></endl;<>printf("\n");sum-=pmin->data.score;sum-=pmax->data.score;for (q=h,p=h->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;}//删除最高分结点}ave=sum/(PWRS-2);cout<<"该选手的最后得分是:"<<ave<<endl;< bdsfid="188" p=""></ave<<endl;<>return 1;}实验结束。
数据结构之线性链表基本操作实训报告书
![数据结构之线性链表基本操作实训报告书](https://img.taocdn.com/s3/m/bad48d0d6c85ec3a87c2c5e3.png)
实训报告书实训名称:数据结构之线性链表基本操作系(部):信息工程系专业班级:计算机高本08—1班学生姓名:何文晶学号:0823010113指导教师:亓静完成日期:2010—06—05课程实训报告书目 录目 录 ......................................................................................................... 1 1 实训总结 ................................................................................................. 2 2 线性链表的功能描述 .......................................................................... 3 2.1 线性链表基本功能实现的目标 ................................................ 3 2.2 概要设计各模块 ......................................................................... 3 2.3 各模块详细设计 ........................................................................ 3 3 主要功能实现原理及代码 .................................................................. 5 4 附录 .................................................................... 错误!未定义书签。
数据结构线性表实验报告五篇
![数据结构线性表实验报告五篇](https://img.taocdn.com/s3/m/07a89be85122aaea998fcc22bcd126fff7055d1c.png)
数据结构线性表实验报告五篇第一篇:数据结构线性表实验报告实验报告课程名:数据结构实验名:线性表及其操作姓名:班级:学号:撰写时间:2014.09.24一实验目的与要求1.掌握线性表的实现2.掌握线性表的基本操作的实现二实验内容• 分别完成线性表的顺序表示及链式表示• 在两种表示上, 分别实现一些线性表的操作, 至少应该包括–在第i个位置插入一个元素–删除第i个元素–返回线性表长–返回第i个元素的值三实验结果与分析#include #include //---------线性表链式表示-----------struct V//声明一个结构体类型struct V { int value;struct V * next;//定义结构体变量};void PrintLink(struct V*p)//定义一个结构体指针{ while(p!=NULL)//只要指针指向的变量不为NULL;就会一直循环链表指向下一个结构体{printf(“%d, ”,(*p).value);p=(*p).next;//指针指向下一个结构体} printf(“n”);} void Link(){struct V*head;head=(struct V*)malloc(sizeof(struct V));//开辟一个长度为size的内存(*head).value=-100;//表头为-100(*head).next=NULL;printf(“------------线性表链式表示------------n”);int i,n=10;struct V*p=head;printf(“10个数据:n”);for(i=0;i(*p).next=(struct V*)malloc(sizeof(struct V));p=(*p).next;(*p).value=2*i;(*p).next=NULL;} PrintLink(head);//调用PrintLink函数printf(“删除第四个数据:n”);int k=4;p=head;for(i=1;ip=(*p).next;} struct V*temp=(*p).next;//k表示插入和删除的位置(*p).next=(*temp).next;free(temp);PrintLink(head);printf(“插入第十个数据:n”);k=10;p=head;for(i=1;ip=(*p).next;} temp=(*p).next;(*p).next=(struct V*)malloc(sizeof(struct V));(*(*p).next).value=-99;(*(*p).next).next=temp;PrintLink(head);}//---------线性表顺序表示-----------void seq1(){ int i,n=10,k=4;int a[10];//---------输出数组元素------------printf(“-------------线性表顺序表示---------n”);for(i=0;ia[i]=i;} printf(“数组元素为:n”);for(i=0;iprintf(“%3d”,a[i]);} printf(“n”);//--------插入一个数组元素---------int m=n+1,j=12;//插入元素12 int b[20];for(i=0;i if(i{b[i]=a[i];}else if(i==k){b[i]=j;}else{b[i]=a[i-1];} } printf(“输出插入一个元素的数组:n”);for(i=0;i{if(i{c[i]=a[i];}else{c[i]=a[i+1];} } printf(“输出删除一个元素的数组:n”);for(i=0;i printf(“数组元素为:n”);for(i=1;i<=a[0];i++){a[i]=i;} for(i=0;i<2*a[0];i++){printf(“%d,”,a[i]);} printf(“n”);//-----在k 位置插入一个元素------------for(i=a[0];i>=k;i--){a[i+1]=a[i];} a[k]=-100;++a[0];for(i=0;i<2*a[0];i++){printf(“%d,”,a[i]);} printf(“n”);//-------在k---------------for(i=0;i>k;i++){a[i]=a[i+1];} a[k]=-1;a[0]=n;--a[0];for(i=0;i<2*a[0];i++){printf(“%d,”,a[i]);} printf(“n”);} int main(int argc,char *argv[]){ seq1();seq2();Link();return 0;} 图1:实验结果截图实验分析:已在程序中按规定格式标注。
线性表的链式存储结构实验报告
![线性表的链式存储结构实验报告](https://img.taocdn.com/s3/m/c0d4a70d1a37f111f0855b68.png)
线性表的链式存储结构实验报告文件编码(008-TTIG-UTITD-GKBTT-PUUTI-WYTUI-8256)实验报告课程名称:数据结构与算法分析实验名称:链表的实现与应用实验日期:班级:数媒1401 姓名:范业嘉学号 08一、实验目的掌握线性表的链式存储结构设计与基本操作的实现。
二、实验内容与要求⑴定义线性表的链式存储表示;⑵基于所设计的存储结构实现线性表的基本操作;⑶编写一个主程序对所实现的线性表进行测试;⑷线性表的应用:①设线性表L1和L2分别代表集合A和B,试设计算法求A和B的并集C,并用线性表L3代表集合C;②(选做)设线性表L1和L2中的数据元素为整数,且均已按值非递减有序排列,试设计算法对L1和L2进行合并,用线性表L3保存合并结果,要求L3中的数据元素也按值非递减有序排列。
⑸设计一个一元多项式计算器,要求能够:①输入并建立多项式;②输出多项式;③执行两个多项式相加;④执行两个多项式相减;⑤(选做)执行两个多项式相乘。
三、数据结构设计1.按所用指针的类型、个数、方法等的不同,又可分为:线性链表(单链表)静态链表循环链表双向链表双向循环链表2.用一组任意的存储单元存储线性表中数据元素,用指针来表示数据元素间的逻辑关系。
四、算法设计1.定义一个链表void creatlist(Linklist &L,int n){int i;Linklist p,s;L=(Linklist)malloc(sizeof(Lnode));p=L;L->next=NULL;for(i=0;i<n;i++){s=(Linklist)malloc(sizeof(Lnode));scanf("%d",&s->data);s->next=NULL;p->next=s; p=s;}}2.(1)两个链表的合并void Mergelist(Linklist &La,Linklist &Lb,Linklist &Lc) {Linklist pa,pb,pc;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=papa:pb;free(Lb);}(2)两个链表的并集Linklist unionlist(Linklist &La,Linklist &Lb){Linklist p1,p2,head,q,s;int flag;head=q=(Linklist)malloc(sizeof(Lnode));p1=La->next;while(p1){flag=0;p2=Lb->next;while(p2){if(p1->data==p2->data){flag=1;break;}p2=p2->next;}if(flag==0){s=(Linklist)malloc(sizeof(Lnode));s->data=p1->data;q->next=s;q=s;}p1=p1->next;}q->next=Lb->next;return head;}3.(1)一元多项式的加法List addpoly(List pa,List pb)3.六、心得体会(包括对于本次实验的小结,实验过程中碰到的问题等)1.首先书上给的链表输入是倒序的,写的时候想都没想就抄上去了,结果运行时发现问题,可是上网百度依然没有把问题解决,导致最后输出链表倒序的,并且链表的合并并集依旧是倒序的。
链式存储的实验报告
![链式存储的实验报告](https://img.taocdn.com/s3/m/63482b3c0a1c59eef8c75fbfc77da26925c59694.png)
实验名称:线性表的链式存储结构实验日期:2022年X月X日班级:XX班姓名:XXX学号:XXXXXXX指导教师:XXX一、实验目的1. 理解线性表的链式存储结构及其特点。
2. 掌握链表的基本操作,如创建、插入、删除、查找和遍历等。
3. 通过实际编程实现链表,加深对链式存储结构概念的理解。
二、实验内容与要求1. 定义线性表的链式存储表示,包括节点结构和链表结构。
2. 实现链表的基本操作,如创建链表、插入节点、删除节点、查找节点和遍历链表等。
3. 编写测试代码,验证链表操作的正确性。
三、实验步骤1. 定义链表节点结构体,包含数据和指向下一个节点的指针。
2. 创建链表结构体,包含指向头节点的指针和节点数量。
3. 实现链表创建操作,初始化链表。
4. 实现链表插入操作,包括在链表头部、尾部和指定位置插入节点。
5. 实现链表删除操作,包括删除链表头部、尾部和指定位置的节点。
6. 实现链表查找操作,根据节点数据查找节点在链表中的位置。
7. 实现链表遍历操作,打印链表中的所有节点数据。
8. 编写测试代码,验证链表操作的正确性。
四、实验代码```c#include <stdio.h>#include <stdlib.h>// 定义链表节点结构体typedef struct Node {int data;struct Node next;} Node;// 创建链表Node createList() {Node head = (Node)malloc(sizeof(Node));if (head == NULL) {printf("Memory allocation failed!\n"); return NULL;}head->next = NULL;return head;}// 在链表头部插入节点void insertAtHead(Node head, int data) {Node newNode = (Node)malloc(sizeof(Node)); if (newNode == NULL) {printf("Memory allocation failed!\n"); return;}newNode->data = data;newNode->next = head->next;head->next = newNode;}// 在链表尾部插入节点void insertAtTail(Node head, int data) {Node newNode = (Node)malloc(sizeof(Node)); if (newNode == NULL) {printf("Memory allocation failed!\n"); return;}newNode->data = data;newNode->next = NULL;Node current = head;while (current->next != NULL) {current = current->next;}current->next = newNode;}// 删除链表头部节点void deleteAtHead(Node head) {if (head->next == NULL) {printf("List is empty!\n");return;}Node temp = head->next;head->next = temp->next;free(temp);}// 删除链表尾部节点void deleteAtTail(Node head) {if (head->next == NULL) {printf("List is empty!\n");return;}Node current = head;while (current->next->next != NULL) { current = current->next;}Node temp = current->next;current->next = NULL;free(temp);}// 删除指定位置的节点void deleteAtPosition(Node head, int position) {if (head->next == NULL || position < 0) {printf("Invalid position!\n");return;}Node current = head;int index = 0;while (current->next != NULL && index < position - 1) { current = current->next;index++;}if (current->next == NULL) {printf("Invalid position!\n");return;}Node temp = current->next;current->next = temp->next;free(temp);}// 查找节点Node findNode(Node head, int data) {Node current = head->next;while (current != NULL) {if (current->data == data) { return current;}current = current->next;}return NULL;}// 遍历链表void traverseList(Node head) {Node current = head->next;while (current != NULL) {printf("%d ", current->data); current = current->next;}printf("\n");}// 释放链表内存void freeList(Node head) {Node current = head;while (current != NULL) {Node temp = current;current = current->next;free(temp);}}int main() {Node head = createList();insertAtHead(head, 3);insertAtHead(head, 2);insertAtHead(head, 1);insertAtTail(head, 4);insertAtTail(head, 5);printf("Original list: ");traverseList(head);deleteAtHead(head);deleteAtTail(head);printf("List after deleting head and tail: ");traverseList(head);deleteAtPosition(head, 1);printf("List after deleting node at position 1: ");traverseList(head);Node node = findNode(head, 3);if (node != NULL) {printf("Node with data 3 found at position: %d\n", (head->next == node ? 1 : (head->next != NULL ? 2 : 3)));} else {printf("Node with data 3 not found.\n");}freeList(head);return 0;}```五、实验结果与分析1. 通过实验,成功实现了线性表的链式存储结构,包括创建、插入、删除、查找和遍历等基本操作。
1101080125链式线性表实验报告
![1101080125链式线性表实验报告](https://img.taocdn.com/s3/m/c4c31721af45b307e87197a9.png)
return p;}
else return NULL;
}
void printlist(LinkList L) /*遍历整个线性表*/
{L=L->next;
while((L->next)!=NULL)
{printf("%d ",L->data);
有了第一次实程的实实所以实次的实程不吃了因实有了思想了在上次的基实上加以修改就好了
实验3:线性表的链式存储结构基本操作的实现
实验
目的
给出实验的目的:设计一个带头结点的有序单链表类型LList并实现以下功能
1.初始化线性链表
2.创建线性表
3.插入数据
4查找指定元素
5.遍历
0.退出
实验
内容
给出实验的内容:把每个功能分块分别编制实现以下功能的子程序
k=k+1;
}
if(!pre)
{
printf("插入位置不合理");
return 0;
}s=(Node *) malloc(sizeof(Node));
s->data=e;
s->next=pre->next;
pre->next=s;
return 1;
}
Node *get(LinkList L) /*在带头节点的单链表L中查找第i个结点*/
1.初始化线性链表
2.创建线性表
3.插入数据
4查找指定元素
5.遍历
0.退出
然后再主程序中调用。
实验
步骤
数据结构实验报告三线性表的链式存储
![数据结构实验报告三线性表的链式存储](https://img.taocdn.com/s3/m/4cb29d215bcfa1c7aa00b52acfc789eb162d9e0a.png)
实验报告三线性表的链式存储班级: 2010XXX 姓名: HoogLe 学号: 2010XXXX 专业: XXXX*****************(1)实验目的:(2)掌握单链表的基本操作的实现方法。
(3)掌握循环单链表的基本操作实现。
(4)掌握两有序链表的归并操作算法。
实验内容: (请采用模板类及模板函数实现)1.线性表链式存储结构及基本操作算法实现[实现提示] (同时可参见教材p64-p73页的ADT描述及算法实现及ppt)函数、类名称等可自定义, 部分变量请加上学号后3位。
也可自行对类中所定义的操作进行扩展。
所加载的库函数或常量定义:#include <iostream>using namespace std;(1)单链表存储结构类的定义:template<class T>class LinkList{public:LinkList(); //初始化带头结点空单链表构造函数实现LinkList(T a[],int n);//利用数组初始化带头结点的单链表构造函数实现~LinkList();int length(); //求单链表表长算法T get(int i); //获得单链表中第i个结点的值算法int locate(T temp);void insert(int i,T temp); //在带头结点单链表的第i个位置前插入元素e算法T Delete(int i); //在带头结点单链表中删除第i个元素算法void print(); //遍历单链表元素算法bool isEmpty(); //判单链表表空算法void deleleAll(); //删除链表中所有结点算法(这里不是析构函数, 但功能相同)private:Node<T> *head;};(2)初始化带头结点空单链表构造函数实现输入:无前置条件: 无动作: 初始化一个带头结点的空链表输出:无后置条件: 头指针指向头结点。
数据结构线性表实验报告
![数据结构线性表实验报告](https://img.taocdn.com/s3/m/7b3633645627a5e9856a561252d380eb62942384.png)
数据结构线性表实验报告一、实验目的本次实验的主要目的是深入理解和掌握数据结构中线性表的基本概念、存储结构和操作算法,并通过实际编程实现来提高对线性表的应用能力和编程技能。
二、实验环境本次实验使用的编程语言为C++,开发工具为Visual Studio 2019。
三、实验内容(一)线性表的顺序存储结构顺序表是用一组地址连续的存储单元依次存储线性表的数据元素。
其特点是逻辑上相邻的元素在物理位置上也相邻,便于随机存取,但插入和删除操作需要移动大量元素,效率较低。
(二)线性表的链式存储结构链表是通过指针将一组零散的存储单元链接成一个线性序列。
常见的链表有单链表、双向链表和循环链表。
链表的插入和删除操作只需修改指针,无需移动元素,但随机存取效率较低。
(三)线性表的基本操作实现1、初始化线性表2、销毁线性表3、清空线性表4、判断线性表是否为空5、获取线性表的长度6、获取指定位置的元素7、查找指定元素在线性表中的位置8、在线性表指定位置插入元素9、删除线性表指定位置的元素四、实验步骤(一)顺序表的实现1、定义顺序表的结构体,包括数据存储数组和表的长度。
2、实现顺序表的初始化函数,分配初始存储空间并设置表长度为0。
3、销毁顺序表函数,释放存储空间。
4、清空顺序表函数,将表长度置为 0。
5、判断顺序表是否为空,根据表长度判断。
6、获取顺序表长度,直接返回表长度。
7、获取指定位置元素,检查位置合法性后返回对应元素。
8、查找指定元素位置,遍历表进行比较。
9、插入元素函数,检查插入位置合法性,若合法则移动后续元素,插入新元素并更新表长度。
10、删除元素函数,检查删除位置合法性,若合法则移动后续元素,更新表长度。
(二)链表的实现1、定义链表节点结构体,包含数据域和指针域。
2、实现链表的初始化函数,创建头节点。
3、销毁链表函数,遍历链表释放节点内存。
4、清空链表函数,遍历链表删除节点但保留头节点。
5、判断链表是否为空,检查头节点的指针域是否为空。
线性表与链表实验报告
![线性表与链表实验报告](https://img.taocdn.com/s3/m/ec72f8cba1c7aa00b52acb17.png)
数据结构实验报告实验0:顺序表与链表专业:班级:姓名:学号:指导教师:日期:一、实验目的(1)掌握顺序表的存储结构形式及其描述和基本运算的实。
(2)熟练掌握动态链表结构及有关算法的设计。
(3)掌握用链表表示特定形式的数据的方法,并能编写出有关运算的算法。
(4)理解单循环链表及双循环链表的特点。
二、实验内容(1)顺序表的应用(2)链表的应用三、需求分析1.输入的形式和输入值的范围2.建立链表时输入的都是整数,输入0代表输入的结束,插入元素时需要输入插入的位置和元素的值,删除元素时输入删除元素的值。
3.输出形式4.所有操作在出现错误时都会有提示,并且在任意一个操作结束后都会输出操作后的链表。
5.程序所能达到的功能6.完成链表的生成,任意位置插入元素、删除,实现链表数据的排序,删除链表中相同的元素,并且比较两个链表是否相等以及将两链表合成一个有序的链表。
7. 4.测试数据:见第八部分。
四、概要设计实验一:(1) 本程序包含的函数如下:其中main函数负责操作其他的函数。
(2)各函数的功能设计为:Creat(student & L):建立一个链表L(尾部插入建立的链表),并且返回这个链表的头指针。
find(student L,int e):在链表L中寻找一样元素e。
print(student L):依次输出链表 L 的内容。
insert(student & L):插入元素。
spilt(student & L):从后向前寻找奇数在偶数前的情况,如果一个奇数或偶数之后还是一个奇数和偶数,就让代表奇数和偶数的变量自增,在每次所有符合连续情况的奇偶数交换完成后,偶数要从新计数。
symmetry(student L):判断是否是对称的链表。
unite(student L1, student L2, Student & L3):将链表A和B合成一个非递减的链表,返回新链表的头指针.五、详细设计(1)结点类型和指针类型:typedef struct{int *elem;//数组指针elem指示线性表的基地址。
数据结构实验报告线性链表
![数据结构实验报告线性链表](https://img.taocdn.com/s3/m/b17cefb433687e21ae45a923.png)
}
int ListInsert_L(LinkList &L,int i,ElemType e){
int j=0;
LinkList p=L,s;
while(p&&j<i—1)
{p=p—〉next;
++j;}
if(!p||j>i—1)
return ERROR;
s=(LinkList)malloc(sizeof(LNode));
scanf(”%d”,&i);
GetElem_L(L,i,e);
printf(”e=%d\n",e);
printf(”插入元素的位置:");
scanf("%d",&x);
printf(”插入的元素为: ");
scanf(”%d”,&a);
printf("在顺序表第%d个位置插入%d\n”,x,a);
设线性链表lalb中的数据元素为整数且均已按值非递减有序排列要求lc中的数据元素也按值非递减有序排列
课程名称_数据结构__ 实验名称_线性链表的实现和应用_ 实验日期_2015。1.16___
班级__ 姓 名____ 学号__ 仪器编号______
实验报告要求 1.实验目的 2.实验要求 3.实验步骤 4。程序清单 5.运行情况 6.流程图 7。实验体会
OutputList_L(L);
}
2.
#include<malloc。h>
#include〈stdio。h>
#define ERROR 0
#define NULL 0
#define OK 1
typedef int ElemType;
[线性表 链表实验报告]链表线性表
![[线性表 链表实验报告]链表线性表](https://img.taocdn.com/s3/m/991839261ed9ad51f01df26a.png)
[线性表链表实验报告]链表线性表实验一:线性表运算的实现班级姓名学号一、实验预备知识1 复习C++中编写函数的相关内容。
2 复习如何用主函数将多个函数连在一起构成一个C++完整程序。
二、实验目的1 掌握线性表的顺序和链式存储结构2 熟练运用线性表在顺序存储方式下的初始化、创建、输出、插入和删除运算3 熟练运用线性表在链式存储方式下的创建、输出、插入和删除运算三、实验要求1 编写初始化并创建线性表和输出线性表的算法。
2 编写对线性表插入和删除运算算法,要判断位置的合法性和溢出问题。
3 编写一个主函数,将上面函数连在一起,构成一个完整的程序。
4将实验源程序调试并运行,写出输入、输出结果,并对结果进行分析。
四、实验步骤◇顺序表实验内容:1.给定的线性表为L=(12,25,7,42,19,38),元素由键盘输入。
2.初始化并建立顺序表。
3.编写顺序表输出算法。
(内存中开辟的单元数为8)4.依次插入3,21,15三个数,分别插入在第4,6和2位置,每插入一次都要输出一次顺序表。
5.删除第5,第3和第12个位置上的元素,每删除一个元素都要输出一次顺序表。
◇单链表实验内容:1.给定的线性表为L=(12,25,7,42,19,38),元素由键盘输入。
2.建立一个带表头结点的单链表(前插入法和尾插入法都可以)。
3.编写单链表输出算法。
4.依次插入3,21,15三个数,分别插入在第4,6和12位置,每插入一次都要输出一次单链表。
5.删除第5,第3和第12个位置上的元素,每删除一个元素都要输出一次单链表。
五、实验程序◇顺序表实验//LinkList.h#define MAXSIZE 8typedef int DataType;typedef struct{DataType data[MAXSIZE];int last;}Seqlist;void creat_seqlist(Seqlist &s);void display_seqlist(Seqlist &s);int insert_seqlist(Seqlist &s, int i, DataType x); int delet_seqlist(Seqlist &s, int i);//LinkList.cpp#include#include”Seqlist.h”void creat_seqlist(Seqlist &s){int x, i = 0;coutcin>>x;while(x != -1){s.data[i] = x;cin>>x;i ++;}st = i-1;}void display_seqlist(Seqlist &s){int i;coutfor(i = 0; icoutcout}int insert_seqlist(Seqlist &s, int i, DataType x) {int j;if(st == MAXSIZE-1){}cout st + 2){ cout= i-1;j --) s.data[j+1] = s.data[j]; s.data[i-1] =x ; st ++; return 1;int delet_seqlist(Seqlist &s, int i){int j;if(i st+1){coutreturn -1;}for(j = i; js.data[j-1] = s.data[j];st --;return 1;}//main.cpp#include#include”Seqlist.h”int main(){int x,d,s;Seqlist s_list;creat_seqlist(s_list);cout>d; cout>x; s=insert_seqlist(s_list ,d,x); if(s==1){ cout>d; s=delet_seqlist(s_list,d);}if(s==1){ cout运行结果:请输入数据(以输入-1结束)12 25 7 42 19 38 -1顺序表为:12 25 7 42 19 38插入操作请输入插入的位置:4请输入要插入的数据:3插入后的顺序表为:12 25 7 3 42 19 38请输入插入的位置:6请输入要插入的数据:21插入后的顺序表为:12 25 7 3 42 21 19 38请输入插入的位置:2请输入要插入的数据:15表满!删除操作请输入删除元素的位置:5删除后的顺序表为:12 25 7 3 21 19 38请输入删除元素的位置:3删除后的顺序表为:12 25 3 21 19 38请输入删除元素的位置:12不存在该元素!Press any key to continue◇单链表实验//LinkList.htypedef int DataType;typedef struct Node{DataType data;struct Node *next;}LNode,*LinkList;void Creat_LinkList(LinkList &L); //创建链表void Show_LinkList(LinkList &L); //显示数据LNode * Get_LinkList(LinkList &L, int i); //获得第i个结点的地址int Insert_linklist(LinkList &L,int i,DataType x); //插入结点int Delete_LinkList(LinkList &L,int i); //删除结点//LinkList.cpp#include#include”LinkList.h”void Creat_LinkList(LinkList &L){LNode *s;L = NULL;s = new LNode;s->next = L;L = s;int x;}//头插法创建带头结点的链表 cout>x; while(x != -1){ s = new LNode; s->next = L; L->data = x; L = s; cin>>x; } void Show_LinkList(LinkList &L){LNode *p;p = L->next;while(p!=NULL){coutdatap = p->next; //显示数据cout}LNode * Get_LinkList(LinkList &L, int i){int j = 1;LNode *q;q = L->next;while(q != NULL && jq = q->next;j++;}return q;}//获得第i个结点的地址int Insert_LinkList(LinkList &L, int i, DataType x)//插入结点 {LNode *p, *s;p = Get_LinkList(L,i-1);if(p == NULL){}coutdata = x; s->next = p->next; p->next = s; return 1; }int Delete_LinkList(LinkList &L,int i)LNode *p, *s;p = Get_LinkList(L,i-1);if(p == NULL){//删除结点 coutnext == NULL){ coutreturn 0;}else{s = p->next;p->next = s->next; delete s;return 1;}}//main.cpp#include #include”LinkList.h”int main(){int x,d,s;LinkList H;Creat_LinkList(H); Show_LinkList(H);} cout>d; cout>x; s = Insert_LinkList(H,d,x); if(s == 1){ cout>d; s = Delete_LinkList(H,d); if(s == 1){ cout 运行结果:请输入数据(以输入-1结束) 12 25 7 42 19 38 -1 单链表为:38 19 42 7 25 12插入操作请输入插入的位置:4 请输入要插入的数据:3 插入后的单链表为: 38 19 42 3 7 25 12 请输入插入的位置:6 请输入要插入的数据:21 插入后的单链表为:38 19 42 3 7 21 25 12 请输入插入的位置:12 请输入要插入的数据:15 插入位置错误!删除操作请输入删除元素的位置:5 删除后的单链表为:38 19 42 3 21 25 12 请输入删除元素的位置:3 删除后的单链表为: 38 19 3 21 25 12请输入删除元素的位置:12 插入位置的前驱结点不存在!。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验报告2012 ——2013 学年第 1 学期实验课程数据结构与算法学生姓名实验项目线性表的顺序存储学院计算机科学技术实验性质班级学号实验地点同组人数第组实验日期第周星期第节成绩环境参数一、实验目的及要求二、实验原理、实验内容三、实验仪器设备及材料四、操作方法与实验步骤五、实验数据记录及处理六、实验结果分析及讨论一、实验目的1.掌握用Visual C++6.0上机调试单链表的基本方法2.掌握单链表的插入、删除、查找、求表长以及有序单链表的逆序算法的实现二、实现内容1、单链表基本操作的实现[问题描述]要在带头结点的单链表h中第i个数据元素之前插入一个数据元素x ,首先需要在单链表中寻找到第i-1个结点并用指针p指示,然后申请一个由指针s 指示的结点空间,并置x为其数据域值,最后修改第i-1个结点,并使x结点的指针指向第i个结点,要在带头结点的单链表h中删除第i个结点,首先要计数寻找到第i个结点并使指针p指向其前驱第i-1个结点,然后删除第i个结点并释放被删除结点空间。
[基本要求]用链式存储结构实现存储[实现提示]链式存储结构不是随机存储结构,即不能直接取到单链表中某个结点,而要从单链表的头结点开始一个一个地计数寻找。
三、实验步骤1、定义节点类型2、进行单链表的初始化3、查看初始化的单链表4、使用switch-case结构进行选择操作5、采用递归,使选择操作可以持续进行四、实验代码#include<iostream>using namespace std;typedef int ElemType;typedef struct Lnode{ElemType data;struct Lnode *next;}Lnode,*LinkList;LinkList LinkListInit(){Lnode *L;L=(Lnode *)malloc(sizeof(Lnode));if(L == NULL){printf("申请内存空间失败\n");}L->next = NULL;return L;}LinkList CreateList(){Lnode *L;ElemType x;L=(Lnode *)malloc(sizeof(Lnode));L->next = NULL;// scanf("%d " ,&x);cin>>x;while(x != -1){Lnode *p;p=(Lnode *)malloc(sizeof(Lnode));p->data=x;p->next=L->next;L->next=p;// scanf("%d " ,&x);cin>>x;}return L;}LinkList CreateListNormal(){Lnode *L,*Last;ElemType x;L=(Lnode *)malloc(sizeof(Lnode));L->next = NULL;Last = L;cin>>x;while(x != -1){Lnode *p;p=(Lnode *)malloc(sizeof(Lnode));p->data=x;Last ->next = p;Last=p;cin>>x;}Last->next = NULL;return L;}int GetLocate(LinkList L,ElemType e) {LinkList p;int i=1;p = L->next;while(p){if(p->data == e){return i;}else{p = p->next;}++i;}return -1;}LinkList InsertElemType(LinkList L,int mIndex,ElemType e) {Lnode *pre, *p;int j=0;pre = L;for(j=1;j<mIndex;j++){pre = pre->next;}p=(Lnode *)malloc(sizeof(Lnode));p->data = e;p->next = pre->next;pre->next = p;return L;}LinkList DeleteElemType(LinkList L, int mIndex,ElemType e) {Lnode *p , *s, *q;int j=0 , k=0;q=L;while(q){q=q->next;k++;}if(mIndex<1 || mIndex>k){return NULL;}for(p=L;j<mIndex-1 && p->next != NULL;j++){p=p->next;}s=p->next;p->next = s->next;e = s->data;free(s);return L;}void PrintLinkListTranfer(LinkList L){LinkList p,s,print;p = L->next;L->next = NULL;while(p){s = p;p = p->next;s->next = L->next;L->next = s;}for(print = L->next;print !=NULL;print = print->next) {printf("%d ",print->data);}cout<<endl;}void PrintLinkList(LinkList L){LinkList p;for(p = L->next;p !=NULL;p = p->next){printf("%d ",p->data);}cout<<endl;}void LengthLinkList(LinkList L){int length=0;Lnode *Len;Len = L;while(Len->next != NULL){length++;Len = Len->next;}cout<<"单链表的长度是:"<<length<<endl;}int main(){LinkList L ;int k,m,choice;ElemType x;cout<<"初始化单链表,输入-1结束"<<endl;//L = CreateList();L = CreateListNormal();PrintLinkList(L);printf("\n");cout<<"1.查找元素"<<endl;cout<<"2.插入元素"<<endl;cout<<"3.删除元素"<<endl;cout<<"4.倒序输出"<<endl;cout<<"5.单链表长度:"<<endl;cout<<"0.退出"<<endl;cin>>choice;while(choice != 0){switch(choice){case 1:cout<<"输入要查找的元素"<<endl;scanf("%d", &x);m = GetLocate(L,x);if(m == -1){cout<<"输入位置不正确"<<endl;}else{cout<<"元素的位置是:"<<m<<endl;}break;case 2:cout<<"输入插入的位置:";cin>>k;cout<<"输入插入的值"<<endl;scanf("%d", &x);InsertElemType(L,k,x);cout<<"插入后的元素是:"<<endl;PrintLinkList(L);break;case 3:cout<<"输入删除的元素位置"<<endl;//scanf("%d ",&x);cin>>x;DeleteElemType(L,x,k);cout<<"删除后的元素是:"<<endl;PrintLinkList(L);break;case 4:PrintLinkListTranfer(L);break;case 5:LengthLinkList(L);break;default:cout<<"重新输入"<<endl;break;}cin>>choice;}return 0;}五、实验结果仪器设备损坏、非正常损耗材料(试剂)及处理情况:教师对报告的最终评价及处理意见:教师签字:年月。