链式存储结构实验报告
栈-队列的顺序-链式储存结构(数据结构试验报告)
数据结构实验报告班级：计学号：姓名：设计日期：西安计算机学院实验题目1)栈的顺序存储结构2)栈的链式存储结构3)队列的链式存储结构4)队列的循环存储结构2.需求分析本演示程序用C语言编写，完成栈和列的初始化，入栈、出栈、输出操作。
1）对于顺序栈，入栈时要先判断栈是否满了，栈满不能入栈，否则出现空间溢出；在进栈出栈和读取栈顶时先判栈是否为空，为空时不能操作。
2）在一个链队表中需设定两个指针分别指向队列的头和尾。
3）队列的存储结构：注意要判断队满和队空。
4）程序所能达到的功能：完成栈的初始化，入栈，出栈和输出操作；完成队列的初始化，入队列，出队列和输出操作。
3.概要设计本程序包含1、栈的顺序存储结构包含的函数：1）主函数main（）2）入栈函数Push（）3）出栈函数Pop（）2、栈的链式存储结构包含的函数：1）主函数main（）2）入栈函数PushStack（）3）退栈函数PopStack（）4）取栈顶元素函数Getstack top（）3、队列的链式存储结构所包含的函数：1）主函数main（）2）入队函数EnQueue（）3）出队函数DeQueue（）4 队列的循环所包含的函数：1）主函数main（）2）初始化循环函数CircSeqQueue（）3）入队函数EnQueue（）4）出队函数DeQueue（）5）取队首元素函数GetFront（）4.详细设计1）栈的顺序存储结构#include<stdio.h>#include<stdlib.h>#include<conio.h>#define MAXSIZE 20typedef int datatype;typedef struct{ datatype elem[MAXSIZE];int top;}SeqStack;int init(SeqStack *s){ s->top=-1; return 1;}void print(SeqStack *s){char ch; int i;if(s->top==-1)printf("\n 栈已空.");else{i=s->top;while(i!=-1){printf("\n data=%d",s->elem[i]); i--;}}printf("\n 按回车继续");ch=getch();}void push(SeqStack *s,datatype x){if(s->top==MAXSIZE-1) printf("\n 栈已满！");else s->elem[++s->top]=x;}datatype pop(SeqStack*s){datatype x;if(s->top==-1){printf("\n 栈已空! "); x=-1;}else{x=s->elem[s->top--];}return(x);}void main(){SeqStack s; int k; datatype x;if(init(&s)){do {printf("\n\n\n");printf("\n***************************************");printf("\n\n 1. x进栈");printf("\n\n 2.出栈返回其值");printf("\n\n 3 结束");printf("\n***************************************");printf("\n 请选择(123)");scanf("%d",&k);switch(k){case 1:{printf("\n 请输入进栈整数X=?");scanf("%d",&x);push(&s,x);print(&s);}break;case 2:{ x=pop(&s);printf("\n 出栈元素:%d",x);print(&s);}break;case 3:exit(0);}printf("n---------");}while(k>=1 &&k<3);printf("\n 按回车返回");getch();}elseprintf("\n 初始化失败！\n");}2).栈的链式存储结构#include<stdio.h>#include<stdlib.h>typedef struct SNode{int data;struct SNode*next;}SNode,*LinkStack;LinkStack top;LinkStack PushStack(LinkStack top,int x)//入栈{LinkStack s;s=(LinkStack)malloc(sizeof(SNode));s->data=x;s->next=top;top=s;return top;}LinkStack PopStack(LinkStack top) //退栈{LinkStack p;if(top!=NULL){p=top;top=top->next;free(p);printf("退栈已完成\n");return top;}elseprintf("栈是空的，无法退栈！\n");return 0;}int GetStackTop(LinkStack top) //取栈顶元素{return top->data;}bool IsEmpty(){return top==NULL?true:false;}void Print(){SNode*p;p=top;if(IsEmpty()){printf("The stack is empty!\n");return;}while(p){printf("%d ",p->data);p=p->next;}printf("\n");}void main(){int x,a,b;char m;do{printf("\n");printf(" 链栈的基本操作\n");printf(" \n");printf(" 1.置空栈\n");printf(" 2.进栈\n");printf(" 3.退栈\n");printf(" 4.取栈顶元素\n");printf(" 5.退出程序\n");printf("\n 请选择一个数字（1 2 3 4 5）：");scanf("%c",&m);switch(m){case '1':{top=NULL;printf("\n栈已置空!");break;}case '2':{printf("请输入要进栈的元素个数是：");scanf("%d",&a);printf("\n请输入要进栈的%d个元素:",a);for(b=0;b<a;b++){scanf("%d",&x);top=PushStack(top,x);}printf("进栈已完成！\n");printf("\n输出栈为:");Print();}break;case '3':{printf("\n操作之前的输出栈为:");Print();top=PopStack(top);printf("\n操作过后的输出栈为:");Print();}break;case '4':{printf("\n输出栈为:");Print();if(top!=NULL)printf("\n栈顶元素是：%d\n",GetStackTop(top));elseprintf("\n栈是空的，没有元素！");}break;case '5':break;default:printf("\n输入的字符不对，请重新输入!");break;}getchar();}while(m!='5'); }运算结果:3）队列的链式存储结构#include<stdio.h>#include<stdlib.h>#include<conio.h>#include<stdio.h>#include<stdlib.h>#include<math.h>typedef int dataType;typedef struct node{ dataType data;struct node *next;}QNode;typedef struct{QNode *front,*rear;}LQueue;/*初始化*/int init(LQueue *q){if((q->front=(QNode *)malloc(sizeof(QNode)))==NULL) return 0;q->rear=q->front;q->front->next=NULL;return 1;}/*出队*/void print(LQueue Q){ QNode *p; char ch;p=Q.front->next;while(p!=NULL){printf("\n%d",p->data); p=p->next; } printf("\n 按回车键继续。
线性表的链式存储结构实验报告
实验报告课程名称：数据结构与算法分析实验名称：链表的实现与应用实验日期：班级：数媒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.首先书上给的链表输入是倒序的，写的时候想都没想就抄上去了，结果运行时发现问题，可是上网百度依然没有把问题解决，导致最后输出链表倒序的，并且链表的合并并集依旧是倒序的。
数据结构实验报告-二叉树的链式存储
PreOrderTraverse((*T).Rchild,Visit);
}
}
s.cpp
#include"h.h"
void main()
{
BiTree T;
CreateBiTree(&T);
PreOrderTraverse(&T,Visit);
printf("\n");
InOrderTraverse(&T,Visit);
CreateBiTree((*T).Rchild);//构造右子树
}
}
void PreOrderTraverse(BiTree *T,void (*Visit)(ElemType e))
//先序遍历二叉树T的递归算法，对每个节点调用Visit函数访问；
//采用二叉链表表示的存储结构，Visit是节点访问函数。
{
Visit((*T).data);
if((*T).Lchild!=NULL)
{
PreOrderTraverse((*T).Lchild,Visit);
}
if((*T).Rchild!=NULL)
{
PreOrderTraverse((*T).Rchild,Visit);
}
}
void InOrderTraverse(BiTree *T,void (*Visit)(ElemType e))
三、实验内容与步骤
二叉树的二叉链表存储，实现先序遍历二叉树。
h.h
#include<stdio.h>
#include<stdlib.h>
typedef char ElemType;
实验一 线性表的链式存储
实验一线性表的链式存储【实验时间】【实验地点】【实验目的和要求】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
堆栈链式存储结构表示与实现实验报告.doc
堆栈链式存储结构表示与实现实验报告根据统计和数据，该报告形成并报告班级级别:学校编号:姓氏:Word数据实验主题:堆栈链式存储结构的表达和实验的实现日期；实验要求:1.仔细阅读并掌握本实验的相关知识。
2.编写程序实现栈的链式存储模式。
3.编写程序实现栈空判断、栈入栈出操作和栈顶元素提取。
4.保存程序的运行结果，结合程序分析链结构的特点。
5.填写实验报告的概要设计:(1)初始化链栈。
(2)清空链栈。
(3)完成堆栈入口和堆栈出口操作，并完成堆栈顶部元素提取操作。
(4)选择菜单上的0退出程序并结束实验。
初始化堆栈操作，并将堆栈的顶部指针设置为空值，即设置堆栈S和顶部指针顶部，S→顶部=空。
如果在构建的堆栈中有数据元素，还需要将堆栈顶部指针的值设置为空。
将数据元素插入堆栈的堆栈操作。
首先，应将节点分配给插入的数据元素，并将插入的数据元素的值分配给插入节点的数据字段。
其次，应该修改栈顶指针的指向关系，即应该修改插入节点和栈顶指针的地址。
最后，应该修改栈顶指针。
推送操作从堆栈中移除数据元素。
首先，必须判断堆栈是否为空，如果为空，操作将失败。
否则，栈被推出，删除节点和栈顶指针被修改，最后删除节点被释放。
以堆栈的顶部元素为例。
详细设计://链堆栈类型定义typedef int ElemTypetypedef结构stacknode{ ElemType数据；堆叠*下一个；} StackNodetypedef结构{ stacknode * top}链接堆栈；//进入堆栈void pushl堆栈(linkstack * s，elem type x){ stack de * p；p=新StackNodeP-学校编号:姓氏:Word数据实验主题:堆栈链式存储结构的表达和实验的实现日期；实验要求:1.仔细阅读并掌握本实验的相关知识。
2.编写程序实现栈的链式存储模式。
3.编写程序实现栈空判断、栈入栈出操作和栈顶元素提取。
4.保存程序的运行结果，结合程序分析链结构的特点。
链式存储结构实现多项求和实验报告
链式存储结构实现多项求和实验报告课题设计目的：了解数据结构与算法的设计方法，独立分析和设计一元多项式加减的程序编码，通过程序编写掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能，提高综合运用所学的理论知识和方法独立分析和解决问题的能力，通过这次实践将实际问题中所涉及的对象在计算机中表示出来并对它们进行处理，掌握线性表的链式存储如何实现一元多项式的加减。
课题设计意义：通过完成此次课题，可以了解各种数据结构内在的逻辑关系，讨论它在计算机中的存储表示，以及在其上进行各种运算时的算法实现，并对算法的效率和优化进行简单的分析和讨论，不仅加强了学生对于线性表链式存储的理解，也提高了学生的思维能力，促进学生的综合应用能力和专业素质的提高。
线性表的链式存储结构实验报告
线性表的链式存储结构实验报告实验一：线性表的链式存储结构【问题描述】某项比赛中，评委们给某参赛者的评分信息存储在一个带头结点的单向链表中，编写程序：（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. 通过实验，成功实现了线性表的链式存储结构，包括创建、插入、删除、查找和遍历等基本操作。
数据结构实验四——二叉树链式
实验报告四
实验课名称：数据结构与程序设计实验
实验名称：二叉树链式存储结构
班级：学号：姓名：时间：
一、问题描述
●二叉链表的C语言描述
●基本运算的算法——建立二叉链表、先序遍历二叉树、中序遍历二叉树、后序遍历二叉
树、后序遍历求二叉树深度
二、数据结构设计
typedef struct BiTNode{
ElemType data; //数据域
struct BiTNode *lchild ,*rchild; //左右孩子结点指针
}BiTNode,*BiTree; //树结点、树结构体变量
根据二叉链表的概念来设计数据结构，分为3个域，一个数据域，另外两个指针域分别指向左右孩子结点。
三、算法设计
1)建立二叉链表
2)先序遍历二叉树
3)中序遍历二叉树
4)后序遍历二叉树
5)后序遍历求二叉树深度。
数据结构实验报告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){
链式存储结构实验报告
一．实验目的（1）掌握使用VC++上机调试线性表的基本方法；（2）掌握线性表的基本操作：插入、删除、查找等运算在链式存储结构上的实现。
二．实验内容线性表在链式存储结构下的基本操作三．实验要求（1）认真阅读和理解实验1.1中给出的程序。
并据此写出线性表的各种基本操作在链式存储结构上的程序。
（2）上机运行写出的程序，并且独立调试通过。
四、给出线性表的抽象数据类型ADT LinkLis{数据对象：D={ a i| a i∈ ElemSet,i=1,2,3,…，n,n≥ 0}数据关系：R={ <a i-1，a i>|a i-1,a i∈D,i∈2,3,4, …，n,n≥ 0}基本操作：InitList_L(LinkLis &L);操作结果：创建一个空的线性表LListInsert_L (LinkLis &L,int i,ElemType e);初始条件：线性表L已存在。
操作结果：在线性表L中第i个位置插入元素eDestroyList_L(LinkLis &L);初始条件：线性表L已存在。
操作结果：销毁一个线性表LStatus ClearList_L(LinkLis &L);初始条件：线性表L已存在。
操作结果：将线性表L重置ListEmpty_L (LinkLis L);初始条件：线性表L已存在。
操作结果：若L为空，则返回TURN，否则返回FALSE。
ListLength_L(LinkLis L);初始条件：线性表L已存在。
操作结果：求线性表L中元素的个数（返回表长）GetElem_L (LinkLis L,int i,ElemType &e);初始条件：线性表L已存在。
操作结果：用e返回线性表中第i个元素的值。
LocateElem_L (LinkLis L,ElemType e,Status (*compare)(ElemType,ElemType)); 初始条件：线性表L已存在。
【数据结构】链式存储实验报告
《数据结构B》实验报告系计算机与电子专业电子科学与技术2008级01 __班姓名岳恒学号20081185028 2010年1 0月9日上机题目：链式存储实验1.详细设计实验目的：理解链表的逻辑结构和存储结构，熟练掌握链表的相关操作。
1、问题描述链表是用一组任意的存储单元来依次存储线性表中的各个数据元素，这些存储单元可以是连续的，也可以是不连续的。
用链接存储结构表示线性表的一个元素时至少要有两部分信息:一是这个数据元素的值，二是这个数据元素的直接后继的存储地址。
这两部分信息一起组成了链表的一个结点。
数据域用来存放数据元素的值；指针域（又称链域）用来存放该数据元素的直接后继结点的地址。
链表正是通过每个结点的指针域将线性表的n个结点按其逻辑次序链接成为一个整体。
通常用箭头表示链域中的指针，于是单链表就可以直观地画成用箭头链接起来的结点序列，单链表中每个结点的存储地址存放在其直接前驱的指针域中，因此访问单链表的每一个结点必须从表头指针开始进行。
对单链表的操作主要有：建立单链表、查找（按序号查找、按值查找）、插入一个结点、删除一个结点、求表长等。
2、数据结构设计单链表的结点结构如下：typedef struct node{ /*单链表结点结构*/ElemType data; /*ElemType可以是任何相应的数据类型如int,char等*/struct node *next;} LinkList;3、功能（函数）设计链表的基本操作：InitList1(LinkList *&head)//初始化不带头结点的链表头指针AddHead1(LinkList *&head, ElemType x)//使用表首添加法，向头指针为head的链表中插入一个结点，其值为xInitList(LinkList *&head)//初始化带头结点的链表头指针AddHead(LinkList *head, ElemType x)//使用表尾添加法，向头指针为head的链表中插入一个结点，其值为xCreatList(LinkList *head,int n)//生成含有n个结点的单链表output(LinkList *head)//输出单链表GetNode(LinkList *head, int i)//在带头结点的单链表中查找第i个结点，找到返回该结点指针，否则返回NULLLocateNode(LinkList *head, ElemType x)//在带头结点的单链表中查找值为x的结点，找到返回结点指针，否则返回NULLInsertNode(LinkList *head, int i, ElemType x)//在带头结点的单链表中第i个结点位置上插入值为x的结点DeleteNode1(LinkList *head, ElemType x)//在带头结点的单链表中删除值为x的结点DeleteNode(LinkList *head, int i)//在带头结点的单链表中删除第i个结点Length(LinkList *head)//在带头结点的单链表中求表的长度InsertOrder(LinkList *head,int x)//在有序单链表L中插入值为x的结点，插入后仍然有序union1(LinkList *head,LinkList *B,LinkList *&C)//A和B是两个带头结点的递增有序的单链表，本算法将两表合并成，一个带头结点的递增有序单链表C，利用原表空间。
数据结构实验报告三线性表的链式存储
实验报告三线性表的链式存储班级: 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）初始化带头结点空单链表构造函数实现输入：无前置条件: 无动作: 初始化一个带头结点的空链表输出：无后置条件: 头指针指向头结点。
数据结构实验线性表的链式存储结构
南昌航空大学实验报告课程名称：数据结构实验名称：实验一线性表的链式存储结构班级：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相同的元素。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
学号姓名实验日期2012-12-15实验室计算机软件技术实验指导教师设备编号401 实验内容实习单元2 线性表一．实验目的（1）掌握使用VC++上机调试线性表的基本方法；（2）掌握线性表的基本操作：插入、删除、查找等运算在链式存储结构上的实现。
二．实验内容线性表在链式存储结构下的基本操作三．实验要求（1）认真阅读和理解实验1.1中给出的程序。
并据此写出线性表的各种基本操作在链式存储结构上的程序。
（2）上机运行写出的程序，并且独立调试通过。
四、给出线性表的抽象数据类型ADT LinkLis{数据对象：D={ a i| a i∈ ElemSet,i=1,2,3,…，n,n≥ 0}数据关系：R={ <a i-1，a i>|a i-1,a i∈D,i∈2,3,4, …，n,n≥ 0}基本操作：InitList_L(LinkLis &L);操作结果：创建一个空的线性表LListInsert_L (LinkLis &L,int i,ElemType e);初始条件：线性表L已存在。
操作结果：在线性表L中第i个位置插入元素eDestroyList_L(LinkLis &L);初始条件：线性表L已存在。
操作结果：销毁一个线性表LStatus ClearList_L(LinkLis &L);初始条件：线性表L已存在。
操作结果：将线性表L重置ListEmpty_L (LinkLis L);初始条件：线性表L已存在。
操作结果：若L为空，则返回TURN，否则返回FALSE。
ListLength_L(LinkLis L);初始条件：线性表L已存在。
操作结果：求线性表L中元素的个数（返回表长）GetElem_L (LinkLis L,int i,ElemType &e);初始条件：线性表L已存在。
操作结果：用e返回线性表中第i个元素的值。
LocateElem_L (LinkLis L,ElemType e,Status (*compare)(ElemType,ElemType)); 初始条件：线性表L已存在。
操作结果：在线性表L中查找元素eStatus PriorElem_L (LinkLis L,ElemType cur_e,ElemType &pre_e);初始条件：线性表L已存在。
操作结果：用pre_e返回cur_e的前驱NextElem_L (LinkLis L,ElemType cur_e,ElemType &next_e);初始条件：线性表L已存在。
操作结果：用next_e返回cur_e的后继ListDelete_L (LinkLis &L,int i,ElemType &e);初始条件：线性表L已存在。
操作结果：求线性表L中元素的个数（返回表长）ListTraverse_L (LinkLis L, Status (*visit)(ElemType));初始条件：线性表L已存在。
操作结果：对线性表中每个元素调用函数visit()js_L(LinkLis L)初始条件：线性表L已存在。
操作结果：求奇数个数os_L(LinkLis L)初始条件：线性表L已存在。
操作结果：求偶数个数Findd_L0120(LinkLis L, Status i, ElemType *e)初始条件：线性表L已存在。
操作结果：查找倒数第i个元素五、详细设计1、给出本数据的存储结构定义及链式存储结构定义#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define NULL 0#define OVERFLOW -2实现线性表的抽象数据类型如下:typedef int status;typedef int ElemType; //定义线性表的数据元素类型为int链式存储实现的抽象数据类型如下：typedef struct LNode0120{ElemType data;struct LNode0120 *next;}LNode0120,*LinkLis;2.运算的函数声明：Status InitList_L(LinkLis &L);操作结果：创建一个空的线性表LStatus ListInsert_L (LinkLis &L,int i,ElemType e);初始条件：线性表L已存在。
操作结果：在线性表L中第i个位置插入元素eStatus DestroyList_L(LinkLis &L);初始条件：线性表L已存在。
操作结果：销毁一个线性表LStatus ClearList_L(LinkLis &L);初始条件：线性表L已存在。
操作结果：将线性表L重置Status ListEmpty_L (LinkLis L);初始条件：线性表L已存在。
操作结果：若L为空，则返回TURN，否则返回FALSE。
int ListLength_L(LinkLis L);初始条件：线性表L已存在。
操作结果：求线性表L中元素的个数（返回表长）Status GetElem_L (LinkLis L,int i,ElemType &e);初始条件：线性表L已存在。
操作结果：用e返回线性表中第i个元素的值。
Status LocateElem_L (LinkLis L,ElemType e,Status (*compare)(ElemType,ElemType)); 初始条件：线性表L已存在。
操作结果：在线性表L中查找元素eStatus PriorElem_L (LinkLis L,ElemType cur_e,ElemType &pre_e);初始条件：线性表L已存在。
操作结果：用pre_e返回cur_e的前驱Status NextElem_L (LinkLis L,ElemType cur_e,ElemType &next_e);初始条件：线性表L已存在。
操作结果：用next_e返回cur_e的后继Status ListDelete_L (LinkLis &L,int i,ElemType &e);初始条件：线性表L已存在。
操作结果：求线性表L中元素的个数（返回表长）Status ListTraverse_L (LinkLis L, Status (*visit)(ElemType));初始条件：线性表L已存在。
操作结果：对线性表中每个元素调用函数visit()Status js_L(LinkLis L)初始条件：线性表L已存在。
操作结果：求奇数个数Status os_L(LinkLis L)初始条件：线性表L已存在。
操作结果：求偶数个数Status Findd_L0120(LinkLis L, Status i, ElemType *e)初始条件：线性表L已存在。
操作结果：查找倒数第i个元素3.给出操作实现的伪码Status InitList_L(LinkLis &L){//构造一个线性链表LL=(LinkLis)malloc(sizeof(LNode)); //创建一个结点if(!L) exit(OVERFLOW); //内存分配失败L->next=NULL; //p指针域为空return OK;}Status ListInsert_L(LinkLis &L, int i, ElemType e){//向链表中插入元素LinkLis p = L; int j = 0;while(p&&j<i-1){p = p->next; ++j;//找到第i-1个结点}if(!p||j>i-1) return ERROR;LinkLis s = (LinkLis)malloc(sizeof(LNode)); //创建一新结点s->data=e;s->next=p->next;p->next=s;return OK;}Status DestroyList_L(LinkLis &L){//销毁单链表LLinkLis p = L; LinkLis q = L; //p,q同时指向头结点{q = p;p = p->next;free(q);}return OK;}Status ClearList_L(LinkLis &L){//清空单链表LLinkLis p=L->next;while(p){p->data=NULL;p=p->next;}return OK;}Status ListEmpty_L(LinkLis L){//判断链表L是否为空LinkLis p=L;if(p->next) return TRUE;else return FALSE;}int ListLength_L(LinkLis L){//返回链表L的表长LinkLis p=L; int len=0;while(p->next){++len;p=p->next;}return len;}Status GetElem_L(LinkLis L, int i, ElemType &e) {//用e返回链表L中第i个元素LinkLis p=L->next; int j=1;{p = p->next; ++j;}if(!p||j>i) return ERROR;e = p->data;return OK;}Status LocateElem_L(LinkLis L, ElemType e, Status (__cdecl *compare)(ElemType,ElemType)){LinkLis p = L->next; int i = 1;while(p&&i<=ListLength_L(L) && (*compare)(p->data,e)){++i;p = p->next;}//whileif(i<=ListLength_L(L))return i;elsereturn 0;}Status PriorElem_L(LinkLis L, ElemType cur_e, ElemType &pre_e){//求某元素的前驱LinkLis p = L->next;LinkLis q = L->next;while(p){if(p->data==cur_e&&p->data!=L->next->data){pre_e = q->data;return pre_e;}q = p;p = p->next;}//whilereturn ERROR;}Status NextElem_L(LinkLis L, ElemType cur_e, ElemType &next_e){//求某元素的后继LinkLis p = L->next;while(p){if(p->data==cur_e&&p->next!=NULL){next_e = p->next->data;return next_e;}p = p->next;}//whilereturn ERROR;}Status ListDelete_L(LinkLis &L, int i, ElemType e){//删除链表中的元素LinkLis p = L; int j = 0;while(p->next&&j<i-1){//寻找第i个结点，p指向被删元素的前驱p = p->next; ++j;}if(!p->next||j>i-1) return ERROR;LinkLis q = p->next; //删除并释放结点p->next = q->next;e = q->data;free(q);return OK;}Status ListTraverse_L(LinkLis L, Status (__cdecl *visit)(ElemType)){//依次对L的每个数据元素调用函数visit()。