实验三、线性表的链式存储
线性表的链式存储结构
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));
线性表ADT的顺序存储与链式存储实验报告
实验报告题目：完成线性表ADT的顺序存储和链式存储方式的实现一、需求分析1、本演示程序中，线性表的数据元素类型限定为整型2、演示程序以用户和计算机的对话方式执行，即在计算机的终端上显示“提示信息”之后由用户在键盘上键入演示程序规定的运算命令，相应的输出结果显示在后面。
3、程序的执行命令包括：创建、撤销、清空、插入、修改、删除、定位等线性表ADT各项基本操作二、概要设计为实现上述功能，我们给出线性表的抽象数据类型定义，具体的有单向链，双向链，顺序表等，同时对于上述功能的实现还采用有/无头结点两种方式来实现1.线性表的抽象数据类型定义为ADT List{数据对象：D={a i|a i∈ElemSet，i=1,2,…,n,n≥0}数据关系：R1={<a i-1,a i>|ai-1,ai∈D，i=2,…,n}基本操作：InitList(&L)操作结果：构造一个空的线性表LDestroyList(&L)初始条件：线性表L已存在。
操作结果：销毁线性表L。
ClearList(&L)初始条件：线性表L已存在。
操作结果：将L重置为空表。
ListEmpty(L)初始条件：线性表L已存在。
操作结果：若L为空表，则返回TRUE，否则返回FALSE。
ListLength(L)初始条件：线性表L已存在。
操作结果：返回L中的i个数据元素的值。
GetElem(L,i,&e)初始条件:线性表L已存在，1≤i≤ListLength（L）。
操作结果：用e返回L中第i个数据元素的值。
LocateElem（L,e,compare()）初始条件：线性表L已存在，compare()是数据元素判定函数操作结果：返回L中第一个与e满足compare()的数据元素的位序。
若这样的数据元素不存在，则返回值为0.PriorElem（L,cur_e,&pre_e）初始条件：线性表已存在操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，否则操作失败，pre_e无定义。
实验三链表及其多项式相加 - 副本
实验三、链表及其多项式相加一、实验目的1.了解线性表的链式存储结构，熟练掌握链表。
2.了解作为链表的多项式存贮方式。
3.熟悉掌握多项式加法的算法。
二、实验原理顺序存储的线性表有一些弱点，其一，插入与删除元素需要大量移动元素；其二，预先分配存储空间时必须按最大的空间来分配。
其三，表长难以扩充。
所以，必须引入链式存储结构。
链式存储结构的特点是用一组任意的存储单元存储线性链表的数据元素，与顺序表的区别在于链式存储的存储单元可以是连续的，也可以是不连续的。
为了实现这种结构，链表采取由两部分信息组成数据元素a i的存储映像，称为结点。
结点包括两个域，其中存储数据信息的域称为数据域，存储直接后继信息的称为指针域。
指针域中存储的信息叫做指针或链。
这样，n个结点链接成一个链表，即为线性表（a1,a2,a3,···,a n）。
1.符号多项式的操作，已经成为表处理的典型用例，在数学上，一个一元多项式pn(x)可以按升幂写成：pn(x)=p0+p1·x+p2·（x的2次幂）+···+p n·（x的n次幂）。
它由n+1个系数唯一确定。
因此，在计算机里，它可用一个线性表P来表示：P=(p0,p1,p2,···,p n), 显然，此种表示仅适于顺序存储结构，在通常的应用中，多项式的次数变化很高且很大，将造成内存的很大浪费。
2.实现单链表就地逆置。
三、实验要求1．参照书上的原理说明分析程序，深入理解链表的物理存储模式和逻辑模式。
2．看懂书上算法，参考实验程序编出程序上机调试。
3．参考书上的程序，编写建立链表存储多项式，并实现两多项式相加。
四、代码实现：1.# include<stdio.h># include<stdlib.h>typedef struct Polynode{int coef;int exp;Polynode *next;}Polynode,* Polylist;Polylist polycreate(){Polynode * head,*rear,*s;int c,e;head=(Polynode *)malloc(sizeof(Polynode)); rear=head;scanf("%d,%d",&c,&e);while(c!=0){s=(Polynode *)malloc(sizeof(Polynode));s->coef=c;s->exp=e;rear->next=s;rear=s;scanf("%d,%d",&c,&e);}rear->next=NULL;return (head);}void polyadd(Polylist polya,Polylist polyb) {Polynode *p,*q,*tail,*temp;int sum;p=polya->next;q=polyb->next;tail=polya;while(p!=NULL && q!=NULL){if (p->exp<q->exp){tail->next=p;tail=p;p=p->next;}else if (p->exp==q->exp){sum=p->coef+q->coef;if (sum!=0){p->coef=sum;tail->next=p;tail=p;p=p->next;temp=q;q=q->next;free(temp);}else{temp=p;p=p->next;free(temp);temp=q;q=q->next;free(temp);}}else{tail->next=q;tail=q;q=q->next;}}if(p==NULL)tail->next=p;elsetail->next=q;}void main(){Polynode *p;printf("请输入第一个多项式,次数从低到高:\n"); Polylist A=polycreate();printf("\n多项式创建完成!\n");printf("\n请输入第二个多项式,次数从低到高:\n"); Polylist B=polycreate();printf("\n多项式创建完成!\n\n");polyadd(A,B);p=A->next;while(p!=NULL){printf("[%d %d] ",p->coef,p->exp);p=p->next;}printf("\n\n");}2.# include<stdio.h># include<stdlib.h>typedef struct Node{char data;struct Node * next;}Node,* Linklist;void Initlist(Linklist *L){*L=(Linklist)malloc(sizeof(Node));(*L)->next=NULL;}void CreateFromHead(Linklist L){Node *s;char c;int flag=1;while(flag){c=getchar();if (c!='$'){s=(Node *)malloc(sizeof(Node));s->data=c;s->next=L->next;L->next=s;}else flag=0;}}void Reverselist(Linklist L){Linklist p,q;p=L->next;L->next=NULL;while(p!=NULL){q=p->next;p->next=L->next;L->next=p;p=q;}}void main (){Linklist p;Linklist L;Initlist(&L);printf("Please input datas:\n");CreateFromHead(L);p=L;while (p->next!=NULL){p=p->next;printf("%c ",p->data);}Reverselist(L);printf("\n\n");}五：结果验证：1.2。
线性表的链式存储结构实验报告
实验报告课程名称：数据结构与算法分析实验名称：链表的实现与应用实验日期：班级：数媒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.首先书上给的链表输入是倒序的，写的时候想都没想就抄上去了，结果运行时发现问题，可是上网百度依然没有把问题解决，导致最后输出链表倒序的，并且链表的合并并集依旧是倒序的。
线性表的链式存储实现
结点 数据域 指针域
链式存储
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 ，除存储本身信息外，还需 存储其直接后继的信息 其中：元素(数据元素的映象) + 指针(指示后继元素存储位置) = 结点(表示数据元素及其映象)
实验三+线性表的链式存储.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六个元素时的运行结果：。
实验三 链式存储
实验三链式存储一、实验目的和要求掌握线性表链式存储结构的描述，学会针对链式存储线性表的基本操作。
二、实验内容和原理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. 设计一个算法，将一个结点值为自然数的单链表拆分成两个单链表，原表中保留值为偶数的结点，而值为奇数的结点按它们在原表中的相对次序组成一个新的单链表。
数据结构-线性表链式存储结构
04 线性表链式存储结构的实 现
C语言实现
创建链表
通过动态内存分配，创建链表节 点并逐个连接起来，形成链表。
插入节点
在链表指定位置插入节点，需要 更新插入位置节点的指针域，使 其指向新插入的节点。
删除节点
删除链表中的指定节点，需要更新被 删除节点前一个节点的指针域，使其 指向被删除节点的下一个节点。
01
遍历链表
从头节点开始，依次访问链表中的每 个节点，输出节点的数据值。
05
03
插入节点
在链表指定位置插入节点，需要更新 插入位置节点的引用，使其指向新插 入的节点。
04
删除节点
删除链表中的指定节点，需要更新被 删除节点前一个节点的引用，使其指 向被删除节点的下一个节点。
Python语言实现
在Python中，可以使
THANKS FOR WATCHING
感谢您的观看
适用场景
链式存储结构适用于需要频繁进行插入、删除等操作的数据结构，如动态数组、队列、链表等。
展望
01 02 03
未来发展方向
随着大数据和云计算的普及，数据结构的应用场景越来越 广泛，链式存储结构作为其中的一种重要形式，未来将有 更多的应用场景和优化空间。例如，针对大数据场景下的 链式存储结构优化、新型的链式数据结构等都是值得研究 的方向。
06 总结与展望
总结
定义与特点
链式存储结构是线性表的另一种存储方式，它通过在数据元素之间建立指针链接，实现了数据元素的逻辑顺序与物理 顺序的分离。相比于顺序存储结构，链式存储结构具有更好的动态性，能够方便地插入、删除等操作。
基本操作
链式存储结构支持的主要操作包括插入、删除、查找等，这些操作的时间复杂度通常为O(1)、O(n)、O(n)，其中n为链表 长度。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验二线性表的链式存储实验目的：●掌握线性表的链式存储结构的定义及C语言实现●掌握单链表中的各种基本操作（单链表的建立、合并、删除等）实验内容：1、单链表的建立及输出(插入)参考代码：/*保存在头文件Linklist.h*/#include <stdio.h>#include<malloc.h>#define NULL 0typedef int Elemtype;typedef struct Lnode{Elemtype data;struct Lnode *next;}Lnode,*Linklist;//使用尾插法创建单链表void creatlist_L(Linklist L,int n){int i;Linklist p,q;q=L;for(i=1;i<=n;i++){p=(Linklist)malloc(sizeof(Lnode)); printf("输入线性表的第%d个元素：",i); scanf("%d",&p->data);p->next=q->next;q->next=p;q=q->next;}}//使用头插法创建单链表void creatlist_L(Linklist L,int n){int i;Linklist p;p=L;for(i=n;i>0;i--){p=(Linklist)malloc(sizeof(Lnode));printf("输入线性表的第%d个元素：",i);scanf("%d",&p->data);p->next=L->next;L->next=p;}}void traverlist_L(Linklist head){Linklist p;printf("以head 为头指针的单链表中的元素为："); p=head->next;while(p!=NULL){printf("%5d ",p->data);p=p->next;}printf("\n");}#include<stdio.h>#include<Linklist.h>void main(){Linklist head;int n;printf("********建立一个单链表中的操作******\n");printf("输入要建立链表的长度：");scanf("%d",&n);head=(Linklist)malloc(sizeof(Lnode));head->next=NULL;creatlist_L(head,n);printf("\n********输出单链表中元素*****\n");traverlist_L(head);}2、单链表的查找创建一个单链表，编写单链表的查找函数，实现单链表的查找。
int Getelem(Linklist L,int i,Elemtype &e){int j;Linklist p;p=L->next;j=1;while(p&&j<i){p=p->next;++j;}if (!p||j>i)return NULL;e=p->data;return e;}//按序查找void Getelem(Linklist L,Elemtype e){Linklist p;p=L->next;while(p && p->data!=e){p=p->next;printf("\n查找成功！\n");}if (!p)printf("\n查找失败！\n");}//按值查找3、单链表的删除创建一个单链表，编写函数实现单链表的删除操作。
void Listdelete(Linklist &L,int i){Linklist p,q;p=L;int j=0;while((p->next)&&(j<i-1)){p=p->next;++j;}if(!(p->next)||(j<i-1))printf("删除位置不合理，操作失败！");else{q=p->next;p->next=q->next;delete q;printf("删除成功！");}}//删除指定位置的元素4、有序单链表的合并建立两个带头结点的有序单链表La，Lb（单调递增），利用La，Lb的结点空间，将La和Lb合并成一个按元素值递增的有序单链表Lc。
参考代码：#include <Linklist.h>void mergelist_L(Linklist La,Linklist Lb,Linklist &Lc){InList(Lc);int i,j,k,La_len,Lb_len,e,ai,bj;i=j=1;k=0;La_len=ListLength(La);Lb_len=ListLength(Lb);while((i<=La_len)&&(j<=Lb_len)){ai=GetElem(La,i,ai);bj=GetElem(Lb,j,bj);if(ai<=bj){ListInsert(Lc,++k,ai);++i;}else{ListInsert(Lc,++k,bj);++j;}}while(i<=La_len){ai=GetElem(La,i++,ai);ListInsert(Lc,++k,ai);}while(j<=Lb_len){bj=GetElem(Lb,j++,bj);ListInsert(Lc,++k,bj);}}void main(){Linklist La,Lb,Lc;int n1,n2;La=(Linklist)malloc(sizeof(Lnode));La->next=NULL;printf("******两个单链表的合并操作******\n");printf("\n请输入要建立的链表La的长度：");scanf("%d",&n1);creatlist_L(La,n1);printf("\n******输出链表La中元素******\n");traverlist_L(La);Lb=(Linklist)malloc(sizeof(Lnode));Lb->next=NULL;printf("******两个单链表的合并操作******\n");printf("\n请输入要建立的链表Lb的长度：");scanf("%d",&n2);creatlist_L(Lb,n2);printf("\n******输出链表Lb中元素******\n");traverlist_L(Lb);printf("\n******下面执行合并操作******\n");Lc=La;mergelist_L(La,Lb,Lc);printf("\n******输出由链表La和Lb归并所得新的链表Lc中的元素******\n");traverlist_L(Lc);}5、已知带头结点的单链表L中的结点是按整数值递增排列。
试写一个算法，将值为x的结点插入到表L中，使得L仍然有序。
分析算法的时间复杂度。
void Insert(Linklist L,int x){Linklist p,q;p=L->next;q=L;while(p&&p->data<x){q=p;p=p->next;}p=(Linklist)malloc(sizeof(Lnode));p->data=x;p->next=q->next;q->next=p;}6、线性表的合并有两个集合A 和B 分别用线性表LA 和LB 表示，即：线性表中的数据元素为集合中的成员。
现求一个新的集合A＝A∪B。
（线性表任选一种存储方式）void Union(Linklist &La,Linklist Lb){int i,La_len,Lb_len,e;La_len=ListLength(La);Lb_len=ListLength(Lb);for(i=1;i<=Lb_len;i++){e=GetElem(Lb,i,e);Insert(La,e);}}实验总结：1.头插法创建单链表2.单链表的查找3.单链表的删除4.有序表中插入元素5.（4-5）有序链表的合并和两个集合的合并。