线性表的链式存储结构实验报告
线性表的链式存储,实验报告
线性表的链式存储,实验报告线性表的链式存储结构实验报告实验报告课程名称:数据结构与算法分析实验名称:链表的实现与应用实验日期:2015.01.30 班级:数媒1401 姓名:范业嘉学号1030514108一、实验目的掌握线性表的链式存储结构设计与基本操作的实现。
二、实验内容与要求⑴定义线性表的链式存储表示;⑵基于所设计的存储结构实现线性表的基本操作;⑶编写一个主程序对所实现的线性表进行测试;⑷线性表的应用:①设线性表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;in;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-expnpb-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-expnpb-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=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-expnpb-expn){s=(List)malloc(sizeof(struct Linklist));s-expn=pa-expn;s-coef=pa-coef;s-next=NULL;p=s;pa=pa-next;}else if(pa-expnpb-expn){s=(List)malloc(sizeof(struct L(转载于: 写论文网:线性表的链式存储,实验报告)inklist));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=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;}篇二:《线性表的链式存储》实验报告《线性表的链式存储》实验报告1.需解决的的问题利用线性表的链式存储结构,设计一组输入数据。
实验二 线性表的链式存储
实验二线性表的链式存储
一、实验目的
1.掌握线性表的链式存储结构。
2.能熟练地利用链式存储结构实现线性表的基本操作。
3.能熟练地掌握链式存储结构中算法的实现。
二、实验内容
1.分别用头插法和尾插法建立带头结点的单链表。
2.实现单链表上的插入、删除、修改、查找、计数、输出等基本操作。
3.解决约瑟夫问题:假设有n个人按1、2、3、…、n的顺序围成一圈,现在,从第s个人开始按1、2、3、…、m的顺序报数,数到m的人出圈,接着从出圈的下一个人开始重复此过程,直到所有人出圈为止。
试用循环链表解决这个问题。
三、算法描述
1.第1题、第2题的算法提示
先定义单链表的数据类型,然后将头插法和尾插法、插入、删除、修改、查找、计数、输出等基本操作都定义成单独的子函数形式,最后在主函数中调用,并将每一种操作前后的结果输出,以查看每一种操作的效果。
2.第3题的算法提示
首先将n个人的信息建立成一个单循环链表,链表中的每个结点信息就是每个人的编号(1~n)。
然后利用循环找到出圈人位置的结
点,输出该结点的信息,再在链表中删除该结点,接着从删除的结点的后面重复此步骤,直到链表中剩下一个结点时停止循环,再把链表中的最后一个结点删除。
实验报告的要求与实验一相同。
实验三+线性表的链式存储.doc
实验三线性表的链式存储【实验目的】1.掌握基本线性链式存储的类型定义及C语言实现;2.掌握基本线性表在链式存储结构中的各种基本操作。
【实验要求】1.学会定义一个链式存储结构体LNode;2.学会链式存储结构的初始化、清空、求线性表的长度、遍历、改值、插入(头插、尾插、固定位置插入)、删除(删头、删尾、固定位置删除);3.学会用main函数调用定义的各个函数;【实验环境】VC++运行的环境【实验步骤及代码】一、创建VC工程环境二、编写、调试程序//一、包含库文件和类型定义#include <stdio.h>#include <stdlib.h>typedef char ElemType;//二、定义结构typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkList;//三、基本操作函数的定义//(1)创建一个带头结点的链表LinkList CreateList_L(int n){//逆序输入如n个元素的值,建立一个带表头结点的单链表LinkList L=(LinkList)malloc(sizeof(LNode));L->next=NULL;char ch;for(int i=n;i>0;--i){scanf("%c",&ch);p->data=ch;p->next=L->next;L->next=p;}return L;}//(2)链表的遍历函数void travel_L(LinkList s){LinkList p=s->next;while(p){printf("%c",p->data);p=p->next;}printf("\n");}//(3)返回链表L的第i个元素的值ElemType GetElem_L(LinkList L,int i){ LNode *p=L->next;int j=1;while (p&&j<i) {p=p->next;++j;}if (!p||j>i) {printf("i越界!");exit(1);}elsereturn p->data;}//(4)链表的i个位置插入一个值为e的节点void ListInsert_L(LinkList L,int i,ElemType e){ LinkList p=L;int j=0;while (p&&j<i-1) {p=p->next;++j;}if (!p||j>i-1) exit(1);else{s->data=e;s->next=p->next;p->next=s;}return;}//(5)链表中删除第i个元素void ListDelete_L(LinkList L,int i){LNode *p=L;int j=0;while (p->next&&j<i-1) {p=p->next;++j;}if(!(p->next)||j>i-1) exit(1);LNode *q=p->next;p->next=q->next;free(q);return;}//(6)删除链表的第一个节点void ListDeleteFist_L(LinkList L){ListDelete_L(L,1);}//(7)求一个链表的长度int ListLength_L(LinkList L){LNode *p=L;int j=0;while (p->next) {p=p->next;++j;}return j;}//(8)在一个链表的尾部查入一个值为e的节点void ListInsertLast_L(LinkList L,ElemType e){ ListInsert_L(L,ListLength_L(L)+1,e);}//(9)删除链表的尾节点void ListDeleteLast_L(LinkList L){ListDelete_L(L,ListLength_L(L));}//(10)把链表的第i个值改为evoid Listchange(LinkList L,int i,ElemType e){LNode *p=L;int j=0;while (p->next&&j<i) {p=p->next;++j;}if(!(p->next)||j>i) exit(1);p->data=e;return;}//(11)链表中找值为e的节点的位置int ListFind(LinkList L,ElemType e){LNode *p=L;int j=0;while (p->next&&(p->data!=e)) {p=p->next;++j;}if(!(p->next)||j>ListLength_L(L)) exit(1);elsereturn j;}//(12)清空一个链表void ListClear_L(LinkList L){while (L->next) {ListDeleteLast_L(L);}}//四、主调函数void main(){LinkList L=CreateList_L(6);travel_L(L);printf("链表的第2个元素是:");printf("%c\n",GetElem_L(L,2));printf("链表的第2个位置插入值为w后的链表:");ListInsert_L(L,2,'w');travel_L(L);printf("删除链表的第2个位置上的节点后的链表:");ListDelete_L(L,2);travel_L(L);printf("删除链表的头节点后的链表:");ListDeleteFist_L(L);travel_L(L);printf("\n");printf("当前链表的长度为:");printf("%d",ListLength_L(L));printf("\n");printf("链表的尾部插入z后:");ListInsertLast_L(L,'z');travel_L(L);printf("\n");printf("删除链表的尾节点后:");ListDeleteLast_L(L);travel_L(L);printf("\n");printf("把第二个节点的值改为Y后:");Listchange(L,2,'Y');travel_L(L);printf("\n");printf("找链表中值为Y的位置:");printf("%d",ListFind(L,'Y'));printf("\n");printf("清空链表:");ListClear_L(L);travel_L(L);printf("\n");}【实验结果】输入abcdef六个元素时的运行结果:。
实验一 线性表的链式存储
实验一线性表的链式存储【实验时间】【实验地点】【实验目的和要求】1.掌握线性表的结构特点和表示方法;2.掌握线性表链式存储结构特性和基本操作算法;3.掌握用指针实现单链表的建立、输出、插入和删除的算法。
【实验类型】验证性【实验时数】2学时【实验设备】计算机【参考资料】1.数据结构题解2.C程序设计【实验内容】熟练掌握线性表的链式表示和实现方法,利用其定义具体的链表结点;利用链表的结构特点,建立单链表;利用链表结点间的指针关系,实现链表的插入和删除。
[具体要求](1) 建立单链表时,要首先输入链表长度,根据输入值来确定所建链表的结点个数;(2) 在单链表中插入新结点时,要给出结点的插入位置和数据域的值;(3) 在单链表中删除某个结点时,要给出要删结点的位置;(4) 要编写单链表的输出函数,以便能验证程序的执行结果。
【实验分析】1、实验的第一步应该建立单链表结点类型和程序所需的宏或数据类型,例如:#define NULL 0 //宏定义NULL的值为0#define LEN sizeof(struct node) //宏定义LEN,为申请结点空间时做准备typedef struct{ int a;float b;} elemtype; //定义elemtype类型,这里同学们可以根据自己的情况来自行定义。
typedef struct node{elemtype data; //data域为elemtype类型的,它应该包含两个子域:a和bstruct node *next;}NODE , *NODEPTR; //定义了单链表结点类型和单链表结点指针类型2、对单链表的四种操作进行实现。
(1) NODEPTR creatlink() 建立单链表的函数很明显这个函数的返回值时结点指针类型的,所以这个函数应该返回的时建立的单链表的头指针。
同学们可以根据自己的构思,从前往后或从后往前建立单链表。
此外,提醒同学们最好建立带有附加头结点的单链表。
链式存储实验报告
线性表的链式存储
一、目的:
1.顺序表链式存储结构的运算;
2.顺序表空间分配好后的各个运算的执行;
3.顺序表中的打印、输入、置空表、长度、插入、删除的运算等
二、功能层次图:
三、运行结果:
主菜单:
建立链表:
打印 线性表的链式存储
输入 置空表 长度 插入 删除
打印链表:
链表查询:
四、小结:
1.线性表的线性存储是将线性表中的结点采用连接的方式存储;
2.链式存储是用任意的存储单元来存储数据的,这个单元可以使连续的也可以是不连续的,所以链表的结点的逻辑次序和物理次序不一定相同;
3.链表中每个结点的的存储地址是放在前一个前驱的next,而第一个结点无前驱则头指针是head;
4.链表在查找运算中耗时较多,在查找是链表必须从头指针开始扫描才能获得;
5.链表在进行插入和输出运算,都只用修改指针的存放地址的单元。
存储结构描述实验报告
一、实验目的通过本次实验,使学生掌握数据结构中存储结构的基本概念,了解不同存储结构的特点和适用场景,能够根据具体问题选择合适的存储结构,提高编程能力和问题解决能力。
二、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发环境:Visual Studio 2019三、实验内容1. 线性表的存储结构描述(1)顺序存储结构:使用数组实现线性表的存储结构,通过数组的索引来访问元素。
顺序存储结构具有以下特点:优点:存储密度高,空间利用率高;随机访问速度快。
缺点:插入和删除操作需要移动大量元素,效率较低。
(2)链式存储结构:使用链表实现线性表的存储结构,每个节点包含数据和指向下一个节点的指针。
链式存储结构具有以下特点:优点:插入和删除操作效率高,只需修改指针;支持动态内存分配。
缺点:存储密度低,空间利用率较低;随机访问速度慢。
2. 栈的存储结构描述(1)顺序存储结构:使用数组实现栈的存储结构,栈顶元素位于数组的最后一个位置。
顺序存储结构具有以下特点:优点:存储密度高,空间利用率高;随机访问速度快。
缺点:插入和删除操作需要移动大量元素,效率较低。
(2)链式存储结构:使用链表实现栈的存储结构,每个节点包含数据和指向下一个节点的指针。
链式存储结构具有以下特点:优点:插入和删除操作效率高,只需修改指针;支持动态内存分配。
缺点:存储密度低,空间利用率较低;随机访问速度慢。
3. 队列的存储结构描述(1)顺序存储结构:使用数组实现队列的存储结构,队首元素位于数组的第一个位置,队尾元素位于数组的最后一个位置。
顺序存储结构具有以下特点:优点:存储密度高,空间利用率高;随机访问速度快。
缺点:插入和删除操作需要移动大量元素,效率较低。
(2)链式存储结构:使用链表实现队列的存储结构,队首元素位于链表的第一个节点,队尾元素位于链表的最后一个节点。
链式存储结构具有以下特点:优点:插入和删除操作效率高,只需修改指针;支持动态内存分配。
实验报告
2.将实验材料(附件)中的c1.h和linklist.cpp文件复制到同一个文件夹中。
其中,c1.h中包含程序中常用的头文件及宏定义,以后每次都要记得将该文件包括到你的源程序中。
linklist.cpp中包含线性表顺序存储结构的定义和部分基本操作的实现。
实验报告
课程名称
数据结构
实验名称
线性表的链式存储结构
实验间
11月4日星期二下午
实验地点
数学院楼504
班级
信息1班
学号
姓名
一、实验目的与要求
实验目的:了解和掌握线性表的逻辑结构和链式存储结构,掌握单链表的基本算法。
实验要求:1,根据实验内容编程,上机调试,得出正确的运行程序。
2,编译运行程序,观察运行情况和输出结果。
3,写出实验报告。
二、实验内容与步骤
一.实验内容
1.利用基本操作实现两个有序表合并(教材算法2.2)
2.补充未完成的基本操作:InitList,DestroyList,ListLength,ListTraverse,GetElem,ListInsert
3.记录实验过程并总结实验经验,完成实验报告。
二.实验步骤
{
pc->next=pb;
pc=pb;
pb=pb->next;
}
}
pc->next=pa?pa:pb;
free(Lb);
}
2,调用基本操作的好处:调用基本操作的过程中没有破坏链表的原始结构。更容易理解程序每一步操作的含义,结构条理清楚,增加程序的可读性。
指导老师
评分情况
void MergeList(LinkList La,LinkList Lb,LinkList &Lc) //算法2.2
线性表的链式存储结构
石家庄经济学院实验报告学院: 信息工程学院专业: 计算机信息工程学院计算机实验中心制一 实验内容1.进一步熟悉C 语言的上机环境,掌握C 语言的基本结构。
2.会定义线性表的链式存储结构。
3.熟悉对单链表的一些基本操作(建表、插入、删除等)和具体的函数定义。
二 实验目的掌握链式存储结构的特点,了解、掌握并实现单链表的常用的基本算法。
三 需求设计线性表抽象数据类型的描述及实现ADT List{数据对象: {|,,,,,0}i i D a a ElemSet i 12n n =∈=≥数据关系: {,|,,,,}i 1i i 1i R a a a a D i 2n --=<>∈=基本操作:构造一个空的线性表L InitList();销毁线性表L DestroyList();将L 重置为空表 ClearList();判断L 是否为空 ListEmpty();求表长 ListLength();查找元素 LocateElem();求前驱 PriorElem();求后继 NextElem();插入元素ListInsert();删除元素ListDelete();元素调用visit()函数ListTraverse(L,visit())}ADT List;程序具体实现要求:1.创建一个线性表2.能输出所有数据元素3.能求线性表长度4.能插入删除元素5.能查找元素6.能求元素的前驱和后继7.用户操作界面如下:*********************************** 1. 构造线性表* 2. 插入元素* 3. 删除元素* 4. 查找元素* 5. 显示表长* 6. 求后继* 7. 求前驱* 8. 输出所有元素* 0. 结束程序运行*********************************** 请输入您的选择(0,1,...,8):四详细设计步骤4:上机编程与调试主程序如下:#include "stdafx.h"#include "stdio.h"#include "LinkList0515.h"#include "user.h"#include "Fun.h"int main(int argc, char* argv[]){CLinkList0515 L;LinkList l;int flag,flag1=0,loc,e,next_e,pre_e;printf("\n**************************************"); printf("\n* 1. 构造单链表");printf("\n* 2. 插入元素");printf("\n* 3. 删除元素");printf("\n* 4. 查找元素");printf("\n* 5. 显示表长");printf("\n* 6. 求后继");printf("\n* 7. 求前驱");printf("\n* 8. 输出所有元素");printf("\n* 0. 结束程序运行");printf("\n**************************************");while(1){printf("\n请输入您的选择(0,1,...,8): ");scanf("%d",&flag);switch(flag){case 0:++flag1;break;case 1:if(OK==L.InitList_L(l))printf("\n成功完成单链表初始化操作!\n");elseprintf("\n操作失败,内存溢出!\n");break;case 2:printf("\n 请输入插入元素的位序,值(空格隔开): ");scanf("%d %d",&loc,&e);if(ERROR==L.ListInsert_L(l,loc,e))printf("\n操作失败,可能是插入位序不合理!\n");elseprintf("\n成功完成操作!\n");L.ListTraverse_L(l,DisplayData);break;case 3:printf("\n 请输入被删除元素的位序: ");scanf("%d",&loc);if(ERROR==L.ListDelete_L(l,loc,e))printf("\n操作失败,可能是位序不合理!\n");else{ printf("\n元素 %d 成功被删除!\n",e);L.ListTraverse_L(l,DisplayData);}break;case 4:printf("\n 请输入待查找的元素的值: ");scanf("%d",&e);loc=L.LocateElem_L(l,e,compare);if(!loc)printf("\n表中不存在元素 %d !\n",e);elseprintf("\n找到了,元素 %d 在表中的位置是: %d \n",e,loc);break;case 5:printf("\n表长为: %d \n",L.ListLength_L(l));break;case 6:printf("\n 请输入元素的值: ");scanf("%d",&e);if(ERROR==L.NextElem_L(l,e,next_e))printf("\n表中元素 %d 没有后继!\n",e);elseprintf("\n表中元素%d 的后继是: %d\n",e,next_e);break;case 7:printf("\n 请输入元素的值: ");scanf("%d",&e);if(ERROR==L.PriorElem_L(l,e,pre_e))printf("\n表中元素 %d 没有前驱!\n",e);elseprintf("\n表中元素%d 的前驱是: %d \n",e,pre_e);break;case 8:L.ListTraverse_L(l,DisplayData);break;default:break;} //switchif(flag1==1) break;}//whileprintf("\n结束!\n\n\n");return 0;}运行结果如下:图3.1五实验总结1. 基本掌握线性表链式存储结构的特点;2. 基本掌握单链表的常用的基本操作算法;3. 通过线性表的抽象数据类型的学习,进一步掌握抽象数据类型的定义方法;4. 对于同一个线性表,用顺序结构和链式存储结构实现,算法也不同;从而可知,逻辑结构依赖于物理结构;。
线性表的链式存储结构实验报告
贵州大学实验报告学院:计算机科学与信息学院专业:信息安全班级:chaintable *Buildtable(int x[],int y) {chaintable *p,*head;p=new chaintable;head=p;p->data=x[0];for(int i=1;i<y;i++){p->next=new chaintable;p=p->next;p->data=x[i];}p->next=NULL;return head;}bool Deltable(chaintable *&head,int x) {if(x<1)return false;chaintable *relief,*p=head;for(int i=0;i<x-2;i++){if(p->next==NULL)return false;p=p->next;}if(x==1){relief=head;head=head->next;delete relief;if(head!=NULL)return true;elsereturn false;}else{if(p->next!= NULL){relief=p->next;p->next=p->next->next;delete relief;return true;}elsereturn false;}}bool Inserttable(chaintable *&head,int x,int y) {if(y<0)return false;chaintable *p=head,*t=new chaintable;t->data=x;t->next=NULL;if(y==0){t->next=head;head=t;return true;}else{for(int i=0;i<y-1;i++){if(p->next==NULL)return false;p=p->next;}t->next=p->next;p->next=t;return true;}}void Disptable(chaintable *p){while(p!=NULL){cout<<p->data<<' ';p=p->next;}cout<<endl;}bool Searchtable(chaintable *p,int &y,int x) {if(x>=1){for(int i=0;i<x-1;i++){if(p->next==NULL)return false;p=p->next;}y=p->data;return true;}elsereturn false;}int Location(chaintable *p,int x){int i=1;while(p!=NULL){if(p->data==x)return i;i++;p=p->next;}return 0;}void main(){int x,*temp,result;chaintable *head;cin>>x;temp=new int[x];for(int i=0;i<x;i++)cin>>temp[i];head=Buildtable(temp,x);if(Deltable(head,2)){cout<<"删除操作结果:";Disptable(head);}elsecout<<"操作失败!"<<endl;if(Inserttable(head,23,5)){cout<<"将23插入到第五个数字后面的操作结果:";Disptable(head);}elsecout<<"操作失败!"<<endl;if(Searchtable(head,result,4)){cout<<"链表的第四个数是:";cout<<"Search result:"<<result<<endl;}elsecout<<"操作失败!"<<endl;cout<<"Please input your integer:";cin>>x;cout<<"Location:"<<Location(head,x)<<endl;}实验结果:实验总结结果说明:1、第一行的8表示链表初始有8个数2、第二行的8个数是链表初始化的8个数3、第三行的结果是从链表删除了第二个数后的结果4、第五行的结果是搜索链表第四个数5、第六行是输入一个数要搜索的数(图中为25),第七行得出了搜索的结果。
线性表的链式存储结构实验报告
线性表的链式存储结构实验报告实验一:线性表的链式存储结构【问题描述】某项比赛中,评委们给某参赛者的评分信息存储在一个带头结点的单向链表中,编写程序:(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;}实验结束。
线性表的链式存储结构实验报告
线性表的链式存储结构实验报告文件编码(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.首先书上给的链表输入是倒序的,写的时候想都没想就抄上去了,结果运行时发现问题,可是上网百度依然没有把问题解决,导致最后输出链表倒序的,并且链表的合并并集依旧是倒序的。
链式存储的实验报告
实验名称:线性表的链式存储结构实验日期: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. 通过实验,成功实现了线性表的链式存储结构,包括创建、插入、删除、查找和遍历等基本操作。
数据结构实验报告2线性表的 链式存储结构
原
序。
理
方 2. 编译运行程序,观察运行情况和输出结果。
法 3. 写出实验报告(包括源程序和运行结果)。
和
手
段
#include <stdio.h> #include <iostream.h> #include <stdlib.h> typedef int ElemType; struct list {
5.编写一个主函数,调试上述算法。
实 验 数 据
此次试验不是成功的,问题有很多,由于对从C++编程和单 实 验 向链表的操作不是很熟练,导致实验有很多困难。希望以后能更 总 结 加熟练地进行实验,并从实验中收获更多的知识经验。
指 导 教 师 意
见
数据结构实验报告(2)
专业: 实验组
实验时 2011-11-11
间
指导教 师
成绩
实验项 目名称
线性表的链式存储结构
实
验
了解和掌握线性表的逻辑结构和链式存储结构,掌握单链表 的基本算法。
目
的
实 验
运行Visual c++的微机一台 条 件
实 1. 根据实验内容编程,上机调试、得出正确的运行程
{int i;
printf("删除操作\n");
if((pos<0)||(pos>l.size+1))
{ printf("位置无效");
return false;}
if(l.size ==0)
{ cout<<"线性表为空";
return false;} for(i=pos;i<l.size ;i++) l.elem [i-1]=l.elem [i]; l.size --; if(float(l.size )/l.maxsize <0.4&&l.maxsize >10){
数据结构实验报告三线性表的链式存储
实验报告三线性表的链式存储班级: 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)初始化带头结点空单链表构造函数实现输入:无前置条件: 无动作: 初始化一个带头结点的空链表输出:无后置条件: 头指针指向头结点。
实验一线性表[链式存储结构]
实验一线性表一.目的与要求本次实习的主要目的是为了使学生熟练掌握线性表的基本操作在顺序存储结构和链式存储结构上的实现,提高分析和解决问题的能力。
要求仔细阅读并理解下列例题,上机通过,并观察其结果,然后独立完成后面的实习题。
二.例题[问题描述]用链表形式存储一个字符串,插入、删除某个字符,最后按正序、逆序两种方式输出字符串。
[输入]初始字符串,插入位置,插入字符,删除字符。
[输出]已建立链表(字符串),插入字符后链表,删除字符后链表,逆转后链表。
[存储结构]采用链式存储结构[算法的基本思想]建立链表:当读入字符不是结束符时,给结点分配存储空间,写数据域,将新结点插到表尾;插入字符:根据读入的字符在链表中找插入位置,将新结点插入到该位置之前;删除字符:根据读入的删除字符在链表中找到被删结点后,将其从链表中删除;链表逆转:从链表的第一个结点开始对所有结点处理,将每个结点的前驱变为它的后继;打印链表:从链表的第一个结点开始,依次打印各个结点的数据域。
[参考源程序]#define NULL 0typedef struct node{char a;struct node *link;}node,*nodelink;void readlink(nodelink head){nodelink p,q;char c;p=head;printf("Input a linktable(a string):");scanf("%c",&c);if (c=='\n') printf("This string is empty。
");while(c!='\n'){q=(nodelink)malloc(sizeof(node));q->a=c;p->link=q;p=q;scanf("%c",&c);}p->link=NULL;}void writelink(nodelink head){nodelink q;if (head->link==NULL) printf(" This link is empty。
数据结构实验线性表的链式存储结构
南昌航空大学实验报告课程名称:数据结构实验名称:实验一线性表的链式存储结构班级:080611 学生姓名:冯武明学号:16 指导教师评定:XXX 签名: XXX题目:设计并实现以下算法:给出用单链表存储多项式的结构,利用后接法生成多项式的单链表结构,实现两个多项式相加的运算,并就地逆置相加后的多项式链式。
一、需求分析⒈先构造两个多项式链表,实现两个多项式的和及删除和值为零元素的操作,不同用户输入的多项式不同。
⒉在演示过程序中,用户需敲击键盘输入多项式,即可观看结果。
⒊程序执行的命令包括:(1)构造多项式链表pa (2)构造多项式链表pb (3)求两张链表的和(4)删除和值为零元素,即不创建链表结点。
二、概要设计⒈为实现上述算法,需要线性表的抽象数据类型:ADT Stack {数据对象:D={a i:|a i∈ElemSet,i=1…n,n≥0}数据关系:R1={<a i-1,a i>|a i-1,a i∈D,i=2,…n≥0}基本操作:init(list *L)操作结果:构造一个空的线性表L。
ListLength(List *L)初始条件:线性表L已经存在操作结果:返回L中数据元素的个数。
GetElem(List L, int i, ElemType *e)初始条件:线性表L已经存在,1≤i≤ListLength(&L)操作结果:用e返回L中第i个数据元素的值。
EqualList(ElemType *e1,ElemType *e2)初始条件:数据元素e1,e2存在操作结果:以e1,e2中的姓名项作为判定e1,e2是否相等的依据。
Less_EquaList(ElemType *e1,ElemType *e2)初始条件:数据元素e1,e2存在操作结果:以e1,e2中的姓名项(为字符串)的≤来判定e1,e2是否有≤的关系。
LocateElem(List *La,ElemType e,int type)初始条件:线性表La已经存在操作结果:判断La中是否有与e相同的元素。
数据结构实验报告实验一线性表链式存储运算的算法实现
昆明理工大学信息工程与自动化学院学生实验报告
( 201 —201 学年第一学期)
一.实验内容:
线性表链式存储运算的算法实现,实现链表的建立、链表的数据插入、链表的数据删除、链表的数据输出。
二.实验目的:
1.掌握线性表链式存储结构的C语言描述及运算算法的实现;
2.分析算法的空间复杂度和插入和删除的时间复杂度;
3.总结比较线性表顺序存储存储与链式存储的各自特点。
三.主要程序代码分析:
LinkList creatListR1() 序运行结果:
五.实验总结:
通过线性表链式存储运算的算法实现的上机实验,我了解了链式的基本原理和方法,能编程对数据进行链式存储。
由于顺序储存是用物理位置上的邻接关系来表示结点间的逻辑关系,其插入或删除运算不方便,而且当表长变化较大时,难以确定合适的存储规模,为了解决这些问题,我们采用链接方式存储线性表。
所以,当线性表的长度变化较大,难以估计其存储规模时,以采用动态链表作为存储结构为好;如果对于频繁进行插入删除的线性表,以采用链表做存储结构。
链接存储是最常用的存储方法之一,它不仅可以表示线性表,还可以用来表示各种非线性的数据结构。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验报告
课程名称:数据结构与算法分析
实验名称:链表的实现与应用
实验日期:班级:数媒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=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)
3.
六、心得体会(包括对于本次实验的小结,实验过程中碰到的问题等)
1.首先书上给的链表输入是倒序的,写的时候想都没想就抄上去了,结果运行时发现问题,可是上网百度依然没有把问题解决,导致最后输出链表倒序的,并且链表的合并并集依旧是倒序的。
2.当写一元多项式的加减时,前提是弄清楚各种情况,系数相同时就相加减,系数不同就保留原有多项式;当系数相加减为0时,就free这个节点。
在做减法时,我考虑到了减数与被减数之间的关系。
3.在做多项式时,我准备按照书上的算法一个一个写小函数,结果到最后发现写不下去了,就去问问同学和上网看看,结果感觉写这个数据结构的程序其实不必想麻烦了,只是指针,数组的高级运用。