实验3 线性表的链式存储
线性表的链式存储结构
22
2.3.4 双向循环链表
在循环链表中，访问结点的特点： 访问后继结点，只需要向后走一步，而访问前驱 结点，就需要转一圈。 结论：循环链表并不适用于经常访问前驱结点的 情况。 解决方法：在需要频繁地同时访问前驱和后继结 点的时候，使用双向链表。所谓双向链表。 双向链表就是每个结点有两个指针域。一个指向 后继结点，另一个指向前驱结点。
//寻找第i-1个结点
s=p->next;
//用s指向将要删除的结点
*e=s->data;
p->next=s->next; //删除s指针所指向的结点
free(s);
return OK;
}//P26图2-10。
18
2.3.3 循环链表 若将链表中最后一个结点的next域指向头结点，如下图：
head
带头结点的单链表结构示意图
5
链式存储结构的特点 （1）线性表中的数据元素在存储单元中的存放顺 序与逻辑顺序不一定一致； （2）在对线性表操作时，只能通过头指针进入链 表，并通过每个结点的指针域向后扫描其余结点，这 样就会造成寻找第一个结点和寻找最后一个结点所花 费的时间不等，具有这种特点的存取方式被称为顺序 存取方式。
27
p
s
图 2-9
28
完整的算法：
int DuListInsert(DuLinkList *L,int i,EntryType e)
25
（1）初始化双向循环链表DL int InitDuList(DuLinkList *DL) { DL->head=(DuLNode*)malloc(sizeof(DuLNode));
线性表的链式存储,实验报告
线性表的链式存储,实验报告线性表的链式存储结构实验报告实验报告课程名称：数据结构与算法分析实验名称：链表的实现与应用实验日期：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.需解决的的问题利用线性表的链式存储结构，设计一组输入数据。
第3章线性表的链式存储
(a) 空循环链表
L
a1
a2
...
an
(b) 非空循环链表
3.1.3 双向链表
在单链表结点中只有一个指向其后继结点的next 指针域，而找其前驱则只能从该链表的头指针开始，顺 着各结点的next指针域进行查找，也就是说找后继的时 间复杂度是O(1)，找前驱的时间复杂度是O(n)。如果也 希望找前驱像后继那样快，则只能付出空间的代价：每 个结点再加一个指向前驱的指针域prior，结点的结构修 改为下图，这样链表中有两个方向不同的链，用这种结 点组成的链表称为双向链表。
1．带头结点的单链表 2．不带头结点的单链表
3.3.3 单链表插入操作的实现
单链表的插入操作是指在表的第i个位置结点处插入 一个值为data的新结点。插入操作需要从单链表的第一个结 点开始遍历，直到找到第i个位置的结点。插入操作分为在 结点之前插入的前插操作和在结点之后插入的后插操作。
1．前插操作 2．后插操作
2．整数型单链表算法
3．不带头结点的单链表算法
3.2.2 尾插法单链表的创建实现
用头插法实现单链表的创建，比较简单，但读入的 数据元素的顺序与生成的链表中元素的顺序是相反的。若希 望两者次序一致，则用尾插法创建单链表。为了快速找到新 结点插入到链表的尾部位置，所以需加入一个尾指针r用来 始终指向链表中的尾结点。初始状态：头指针L和尾指针r均 为空，把各数据元素按顺序依次读入，申请结点，将新结点 插入到r所指结点的后面，然后r指向新结点，直到读入结束 标志为止。
3.2.2 尾插法单链表的创建实现
L
插入P前的尾指针 插入P后的尾指针
r
3
4
P1
x^
2
3.3 单链表运算的实现
线性表的链式存储实现
结点 数据域 指针域
链式存储
h
1345
存储地址 1345 1346 ……. 1400 ……. 1536
存储内容 元素1 元素4 …….. 元素2 …….. 元素3
指针 1400 ∧ ……. 1536 ……. 1346
h
元素1 1400
元素2 1536
元素3 1346
元素4
特点：
•存储空间不一定连续 •逻辑关系是由指针来体现的； •逻辑上相邻，物理上不一定相邻 •非随机存取（顺序存取），即访问任何一个元素的 时间不同
p ai-1
u ai ai+1
单链表的基本算法描述
P
ai-1
6、删除
×
ai
ai+1
分析：
A、搜索位置； while (p!=NULL&& k!=i-1){p=p->next;k++;}
if (!p ||p->next==NULL) return ERROR;
//在带头结点的单链线性表L中删除第i个位置之 前元素 void List_delete(node *L,int i) { LinkList p=L,u; int k=0; node s; //k计数
2.3线性表的链式存储实现
一、单链表基本结构
二、单链表的实现
三、单链表的基本算法描述
2.3.1 线性表的链式存储结构 存储方式
•用一组地址任意的存储单元存储线性表的数 据元素 •利用指针实现了用不相邻的存储单元存放逻 辑上相邻的元素 •每个数据元素a ，除存储本身信息外，还需 存储其直接后继的信息 其中：元素(数据元素的映象) + 指针(指示后继元素存储位置) = 结点(表示数据元素及其映象)
第3章 线性表的链式存储-实训例题
2.6 实训例题
void Create(Slink f) { Slink p; int i; for(i=N;i>=1;i--) { p=(DataNode *)malloc(sizeof(DataNode)); p->number=i; p->next=f->next; f->next=p; } }
实训例题
实训例题 航班定票系统 【问题描述】 假设某航班(NF_B969N/2007.9.20 17:30:00) 有N个座位，座位号依次为：1,2,3,…,n，要求算法能够实 现订票、退票，乘客登记表按照乘客姓名的字母顺序排列。 【基本要求】 由于每一航班座位有未订与已订两种状态，所以需设置两个 顺序表（或两条链表），用以表示未订座位（链）表与已订 座位（链）表。订票过程就是对未订座位（链）表删除一元 素，对已订座位（链）表插入从未订座位（链）表中删除的 元素。退票过程则相反，对已订座位（链）表的删除一元素， 对未订座位（链）表插入从已订座位（链）表中删除的元素。 由于频繁的插入与删除操作，所以存储结构选择链表，同时 考虑到无其它特rstfp指向未定座位链表中 void Reserve(Slink fp,Slink op) 具有最小座位号的结点 { Slink p,afterp,firstfp; firstfp=fp->next; fp->next=firstfp->next; /*删除具有最小座位号的结点*/ printf("Please enter name: "); scanf("%s",firstfp->); printf("Please enter id: "); scanf("%s",firstfp->passenger.id); p=op->next; /* p指向已定座位链表中的第一个结点*/ afterp=op; /* afterp指向p的前驱结点*/ afterp p */ printf("Your seat number is: %d", firstfp->number); while( p && strcmp(firstfp->, p->)>0 ) 查找firstfp在已定座 { afterp=p; p=p->next; } 位链表中的插入位置 if(strcmp(firstfp->,p->)<0) { afterp->next=firstfp; firstfp->next=p; } else /* firstfp作为最后一个结点插入*/ { firstfp->next=p; afterp->next=firstfp;} }
实验三 链式存储
实验三链式存储一、实验目的和要求掌握线性表链式存储结构的描述，学会针对链式存储线性表的基本操作。
二、实验内容和原理C语言结构化程序设计思想，结构体及指针的应用。
三、主要仪器设备装有Visual C++/Turbo C++等C程序编译软件的计算机。
四、实验中程序的源码1. 设计一个算法，利用单链表原来的结点空间将一个单链表就地逆转。
程序代码如下：#include “linklist.h”V oid verge(linklist head ){ Linklist p,q;P->next=null;Head->next=null;While(p){q=p;P=p->next;q->next=head->next;Head->next=q;}}Int main(){Linklist head;Head=creatlinklist();Print(head);Verge()head;Print(head);}1.建立两个指针struct* p，q，p=head,q=p->next,即最开始p指向链表的第1项，q指向第2项2.if q->next !=NULL,p=p->next,q=q->next 3.endif q->next ==NULL,即q指向最后一项，p 指向倒数第二项新建一个指针，保存原表尾的地址struct*t=q4.q->next=p,q=p //倒数第一项指向倒数第二项，将q指向倒数第二项5.p=head //p重新重表头开始遍历6.if p->next !=q,p=p->next //如果p 指向的不是q指向的前一项，则p继续向后遍历7.endif p->next ==q //q指向p的前一项8. q->next =p,q=p //重复第4步9.p=head //重复第5步。
N. until q=p=head 至此，原链表已经完全逆转，然后让头指针指向原链表的表尾，即指向新链表的表头head=t，这样就搞定了这里写出程序源代码2. 设计一个算法，将一个结点值为自然数的单链表拆分成两个单链表，原表中保留值为偶数的结点，而值为奇数的结点按它们在原表中的相对次序组成一个新的单链表。
线性表的链式存储结构实验报告
贵州大学实验报告学院：计算机科学与信息学院专业：信息安全班级：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），第七行得出了搜索的结果。
线性表的链式存储,多项式的加减乘除四则运算报告
多项式实验报告2011-4-9实验题目：一元多项式的表示及四则运算实验目的：1.了解线性表的链式存储结构，熟悉掌握链表2.了解作为链表的多项式存储方式3.熟悉掌握多项式加减乘除四则运算的算法实验内容:一、抽象数学模型：ADT Polynomial{数据对象：D={ai|ai∈TermSet,i=1,2,···，m, m>=0TermSet中的每个元素包含一个表示系数的实数和表示指数的整数} 数据关系：R1={<ai-1,ai>|ai-1,ai∈D,且ai-1中的指数值<ai中的指数值，i=2,···，n}基本操作：Insert(p,h);初始条件：多项式p与h已存在操作结果：合并指数相同的项CreatePolyn(& head, m)操作结果：建立一个头指针为head、项数为m的一元多项式DestroyPolyn(& p)初始条件：一元多项式P已存在操作结果：销毁多项式pPrintPolyn( P)初始条件：一元多项式P已存在操作结果：打印输出一元多项式PAddPolyn(&pa,& pb)初始条件：一元多项式Pa和Pb已存在操作结果：求解并建立多项式Pa=Pa+Pb, 返回其头指针SubtractPolyn(& pa，& pb)初始条件：一元多项式Pa和Pb已存在操作结果：求解并建立多项式Pa=Pa-Pb，返回其头指针MultiplyPolyn(& pa,& pb)初始条件：一元多项式Pa和Pb已存在操作结果：求解并建立多项式Pa=Pa*Pb，返回其头指针DevicePolyn(& pa,& pb)初始条件：一元多项式Pa和Pb已存在操作结果：求解并建立多项式Pa=Pa/Pb，返回其头指针}ADT Polynomial二、算法描述：为了实现上述程序功能，根据一元多项式的特点，可以构造链式存储的线性表存放一元多项式各式的信息。
线性表的链式存储结构实验报告
线性表的链式存储结构实验报告文件编码（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. 通过实验，成功实现了线性表的链式存储结构，包括创建、插入、删除、查找和遍历等基本操作。
实验三+线性表的链式存储.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六个元素时的运行结果：。
线性表的链式存储
if(j<i && temp->next = =L) /*无合适的插入位置,*/ return FALSE;
node=( LinkList *)malloc(sizeof(LinkList)); if(node==NULL) /*申请结点不成功*/ return FALSE; node->next=temp->next;
数据结构
线性表的链式存储
为了提高增加、删除元素的效率，介绍线性表 的另一种存储方式——链式存储。在链式存储方 式中，能够方便地增加和删除线性表中的元素， 但是同时也使随机存取、获取直接前趋和直接后 继变得较为复杂。
链表：以链式结构存储的线性表称之为
链表（Linked List）。链式存储结构
是用一组任意的存储单元来存储线性表 的结点。也就是说，链式存储结构中， 存储单元可以是相邻的，也可以是不相 邻的；同时，相邻的存储单元中的数据， 不一定是相邻的结点。
DL=(DNode *)malloc(sizeof(DNode));
if(DL= =NULL) return FALSE;/*申请失败*/
DL->prior=DL->next=NULL;
return TRUE;
}
本算法时间复杂度为O(1)。
双向链表的操作
双向链表为空表的判断 从图中可以看出，双向链表是否为空表，要看
return TRUE;
return FALSE;
}
node->next=temp->next;
else/*插入位置不合理*/ temp->next=node;
return FALSE;} return TRUE; }
线性表的链式存储
线性表的链式存储
链式存储是一种重要的线性表存储结构。
它将存储节点链接在一起，它的实现方式是利用链表中的每个结点的指针指向下一个节点。
它可以节约空间，内存占用更少，能够提高存取效率。
首先，讨论一下链式存储的优势：和其它存储技术相比，链式存储可以更有效地实现存储结构。
它可以将链表中的节点按照顺序优先级进行存储，这样可以使得存储空间的利用率更高，要么就可以摆脱固定的存储空间结构，而可以根据实际情况来调整存放的数据顺序，从而达到了更高的存储效率。
其次，也要讨论一下链式存储的实现方式：链式存储的实现方式是通过把结点按照一定顺序进行链接。
每个节点都有一个指针指向下一个节点，这样就可以实现链表中的元素按照顺序进行存放，从而可以节约内存空间，使得数据分配更有灵活性。
同时，还要讨论一下链式存储的缺点：由于链表存储结构的特殊性，对于寻址来说具有一定的弊端。
由于链表中的每一个节点都是依赖于前一个节点的，所以如果要访问链表的某一节点，就必须从前一个节点一直遍历到该节点，这就需要额外的存取时间，从而影响了系统的性能。
总的来说，链式存储的实现方式对线性表的存储具有重要的意义，它可以在更小的存储空间内提供更低的存储量，使得数据分配更有灵活性，使得系统的空间利用率更高。
然而，它也会因为寻址的弊端而降低存储和检索数据的效率，所以在使用的时候要根据实际情况来权衡它的优势和劣势的。
参考文献
1.船井,贺一.(2018).《数据结构与算法》.西南财经大学出版社
2.王晓阳.《数据结构与算法设计》.清华大学出版社。
数据结构-线性表链式存储结构
04 线性表链式存储结构的实 现
C语言实现
创建链表
通过动态内存分配，创建链表节 点并逐个连接起来，形成链表。
插入节点
在链表指定位置插入节点，需要 更新插入位置节点的指针域，使 其指向新插入的节点。
删除节点
删除链表中的指定节点，需要更新被 删除节点前一个节点的指针域，使其 指向被删除节点的下一个节点。
01
遍历链表
从头节点开始，依次访问链表中的每 个节点，输出节点的数据值。
05
03
插入节点
在链表指定位置插入节点，需要更新 插入位置节点的引用，使其指向新插 入的节点。
04
删除节点
删除链表中的指定节点，需要更新被 删除节点前一个节点的引用，使其指 向被删除节点的下一个节点。
Python语言实现
在Python中，可以使
THANKS FOR WATCHING
感谢您的观看
适用场景
链式存储结构适用于需要频繁进行插入、删除等操作的数据结构，如动态数组、队列、链表等。
展望
01 02 03
未来发展方向
随着大数据和云计算的普及，数据结构的应用场景越来越 广泛，链式存储结构作为其中的一种重要形式，未来将有 更多的应用场景和优化空间。例如，针对大数据场景下的 链式存储结构优化、新型的链式数据结构等都是值得研究 的方向。
06 总结与展望
总结
定义与特点
链式存储结构是线性表的另一种存储方式，它通过在数据元素之间建立指针链接，实现了数据元素的逻辑顺序与物理 顺序的分离。相比于顺序存储结构，链式存储结构具有更好的动态性，能够方便地插入、删除等操作。
基本操作
链式存储结构支持的主要操作包括插入、删除、查找等，这些操作的时间复杂度通常为O(1)、O(n)、O(n)，其中n为链表 长度。
线性表的链式存储结构
石家庄经济学院实验报告学院: 信息工程学院专业: 计算机信息工程学院计算机实验中心制一 实验内容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. 对于同一个线性表，用顺序结构和链式存储结构实现，算法也不同；从而可知，逻辑结构依赖于物理结构；。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验报告三线性表的链式存储班级： 2010251 姓名：李鑫学号： 20103277 专业：信息安全一、实验目的：（1）掌握单链表的基本操作的实现方法。
（2）掌握循环单链表的基本操作实现。
（3）掌握两有序链表的归并操作算法。
二、实验内容：（请采用模板类及模板函数实现）1、线性表链式存储结构及基本操作算法实现[实现提示] （同时可参见教材p64-p73页的ADT描述及算法实现及ppt）函数、类名称等可自定义，部分变量请加上学号后3位。
也可自行对类中所定义的操作进行扩展。
所加载的库函数或常量定义：（1）单链表存储结构类的定义：//文件包含在LinList.h中template <class datatype>class LinkList;template <class datatype>class Node{friend class LinkList<datatype>;private:Node<datatype> *next;datatype data;};template <class datatype>class LinkList{public:LinkList();//建立只有头结点的空链表LinkList(datatype a[],int n);//建立有n个元素的单链表~LinkList(){};//析构函数,释放整个链表空间int Length();//求单链表的长度datatype Get(int i);//取单链表中第i个结点的元素值int Location(datatype x);//求单链表中值为x的元素序号void Insert(int i,datatype x);//在单链表中第i个位置插入元素值为x的结点datatype Delete(int i);//在单链表中删除第i个结点void PrintList();//遍历单链表，按序号依次输出各元素bool IsEmpty();//是否为空，空返回1，否则返回0void DeleteAll();//删除所有的元素private:Node<datatype> *head;//单链表的头指针};（2）初始化带头结点空单链表构造函数实现输入：无前置条件：无动作：初始化一个带头结点的空链表输出：无后置条件：头指针指向头结点。
template <class datatype>LinkList<datatype>::LinkList(){head=new Node<datatype>;head->next=NULL;}（３）利用数组初始化带头结点的单链表构造函数实现输入：已存储数据的数组及数组中元素的个数前置条件：无动作：利用头插或尾插法创建带头结点的单链表输出：无后置条件：头指针指向头结点，且数组中的元素为链表中各结点的数据成员。
template <class datatype>LinkList<datatype>::LinkList(datatype a[],int n){head=new Node<datatype>;head->next=NULL;Node<datatype> *s;for (int i=0;i<n;i++){s=new Node<datatype>;s->data=a[i];s->next=head->next;head->next=s;}}（４）在带头结点单链表的第i个位置前插入元素e算法输入：插入位置i，待插入元素e前置条件：i的值要合法动作：在带头结点的单链表中第i个位置之前插入元素e输出：无后置条件：单链表中增加了一个结点template <class datatype>void LinkList<datatype>::Insert(int i,datatype x){Node<datatype> *p=head;int j=0;while(p&&j<i){p=p->next;j++;}if(!p) throw "i不合法";else{Node<datatype> *s=new Node<datatype>;s->data=x;s->next=p->next;p->next=s;}}（５）在带头结点单链表中删除第i个元素算法输入：删除第i个结点，待存放删除结点值变量e前置条件：单链表不空，i的值要合法动作：在带头结点的单链表中删除第i个结点，并返回该结点的值（由e传出）。
输出：无后置条件：单链表中减少了一个结点template <class datatype>datatype LinkList<datatype>::Delete(int i){Node<datatype> *p;p=head;int j=0;while(p&&j<i-1){p=p->next;j++;}if (!p||!p->next){throw "i不合法";}else{Node<datatype> *q;datatype x;q=p->next;x=q->data;p->next=q->next;delete q;return x;}}（６）遍历单链表元素算法输入：无前置条件：单链表不空动作：遍历输出单链表中的各元素。
输出：无后置条件：无template <class datatype>void LinkList<datatype>::PrintList() {Node<datatype> *p;p=head;if (!p->next)cout<<"表为空";else{while(p->next){p=p->next;cout<<p->data<<" ";}}/* Node<datatype> *p=head->next;while(p){cout<<p->data<<" ";p=p->next;}*/}（７）求单链表表长算法。
输入：无前置条件：无动作：求单链表中元素个数。
输出：返回元素个数后置条件：无template <class datatype>int LinkList<datatype>::Length() {Node<datatype> *p;int i=0;p=head->next;while(p){i++;p=p->next;}return i;}（８）判单链表表空算法输入：无前置条件：无动作：判表是否为空。
输出：为空时返回１，不为空时返回0后置条件：无template <class datatype>bool LinkList<datatype>::IsEmpty(){if (head->next==NULL) return 1;//if(!head->next) return 1;return 0;/* if(this->Length()==0){return 1;}*/}（９）获得单链表中第i个结点的值算法输入：无前置条件：i不空，i合法动作：找到第i个结点。
输出：返回第i个结点的元素值。
后置条件：无template <class datatype>datatype LinkList<datatype>::Get(int i){Node<datatype> *p=head->next;int j=1;while(p&&j<i)//为i{p=p->next;j++;}if(!p) throw "i不合法";else return p->data; // p->next->data;错误}(10)删除链表中所有结点算法（这里不是析构函数，但功能相同）输入：无前置条件：单链表存在动作：清除单链表中所有的结点。
输出：无后置条件：头指针指向空template <class datatype>void LinkList<datatype>::DeleteAll(){/* Node<datatype> *p;while(head->next){p=head->next;head->next=p->next;delete p;}*/Node<datatype> *p,*q;p=head;while (p){q=p;p=p->next;delete q;}head->next=NULL;}(11)上机实现以上基本操作，写出main()程序：参考p72void main(){int s[]={10,9,8,7,6,5,4,3,2,1};int n=10;cout<<"构造函数插入元素："<<endl;LinkList<int> mylist1(s,10);mylist1.PrintList();cout<<endl;cout<<"删除全部元素后为："<<endl;mylist1.DeleteAll();mylist1.PrintList();cout<<endl<<"单链表为空(1是，0不是):"<<mylist1.IsEmpty()<<endl;LinkList<int> mylist;cout<<endl<<"非构造函数插入元素："<<endl;for(int i=0;i<10;i++)mylist.Insert(i,s[i]);//mylist.Insert(0,10);//mylist.Insert(1,9);mylist.PrintList();cout<<endl;cout<<"表长为："<<mylist.Length()<<endl;cout<<"得到第3个元素为："<<mylist.Get(3)<<endl;cout<<"删除第7个元素为："<<mylist.Delete(7)<<endl;cout<<"单链表为：";mylist.PrintList();cout<<endl;cout<<"第5个元素后插入99后单链表为：";mylist.Insert(5,99);cout<<endl;mylist.PrintList();cout<<endl;}粘贴测试数据及运行结果：2、参考单链表操作定义与实现，自行完成单循环链表的类的定义与相操作操作算法。