数据结构实验报告实验一线性表链式存储运算的算法实现
数据结构与算法分析实验报告
数据结构与算法分析实验报告一、实验目的本次实验旨在通过实际操作和分析，深入理解数据结构和算法的基本概念、原理和应用，提高解决实际问题的能力，培养逻辑思维和编程技巧。
二、实验环境本次实验使用的编程语言为 Python，使用的开发工具为 PyCharm。
操作系统为 Windows 10。
三、实验内容（一）线性表的实现与操作1、顺序表的实现使用数组实现顺序表，包括插入、删除、查找等基本操作。
通过实验，理解了顺序表在内存中的存储方式以及其操作的时间复杂度。
2、链表的实现实现了单向链表和双向链表，对链表的节点插入、删除和遍历进行了实践。
体会到链表在动态内存管理和灵活操作方面的优势。
（二）栈和队列的应用1、栈的实现与应用用数组和链表分别实现栈，并通过表达式求值的例子，展示了栈在计算中的作用。
2、队列的实现与应用实现了顺序队列和循环队列，通过模拟银行排队的场景，理解了队列的先进先出特性。
（三）树和二叉树1、二叉树的遍历实现了先序、中序和后序遍历算法，并对不同遍历方式的结果进行了分析和比较。
2、二叉搜索树的操作构建了二叉搜索树，实现了插入、删除和查找操作，了解了其在数据快速查找和排序中的应用。
（四）图的表示与遍历1、邻接矩阵和邻接表表示图分别用邻接矩阵和邻接表来表示图，并比较了它们在存储空间和操作效率上的差异。
2、图的深度优先遍历和广度优先遍历实现了两种遍历算法，并通过对实际图结构的遍历，理解了它们的应用场景和特点。
（五）排序算法的性能比较1、常见排序算法的实现实现了冒泡排序、插入排序、选择排序、快速排序和归并排序等常见的排序算法。
2、算法性能分析通过对不同规模的数据进行排序实验，比较了各种排序算法的时间复杂度和空间复杂度。
四、实验过程及结果（一）线性表1、顺序表在顺序表的插入操作中，如果在表头插入元素，需要将后面的元素依次向后移动一位，时间复杂度为 O(n)。
删除操作同理，在表头删除元素时，时间复杂度也为 O(n)。
数据结构实验报告-实验：1线性表的顺序存储和操作实现
}
for(inti=pos-1;i<length;i++)
if(listArray[i].equals(obj))returni+1;
return-1;
}
publicbooleanmodify(Object obj,intpos){
if(pos<1||pos>length){
List sort();
}
publicclasssequenceListimplementsList {
finalintmaxSize=10;
privateintlength;
privateObject[]listArray;
publicsequenceList(){//无参数的构造函数的定义
length=0;//线性表初始为空，即长度为0
System.out.println();
list2.preOrder();
System.out.println("线性表list2长度："+list2.size());
}
}
publicinterfaceList {
Object value(intpos);
booபைடு நூலகம்eanadd(Object obj,intpos);
int[] a={20,16,38,42,29};
for(inti=0;i<a.length;i++) list1.add(a[i], i+1);
intn1=(Integer)list1.remove(2);
list1.add(80, 3);
intn2=(Integer)list1.value(4);
实验一 线性表的链式存储
实验一线性表的链式存储【实验时间】【实验地点】【实验目的和要求】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() 建立单链表的函数很明显这个函数的返回值时结点指针类型的，所以这个函数应该返回的时建立的单链表的头指针。
同学们可以根据自己的构思，从前往后或从后往前建立单链表。
此外，提醒同学们最好建立带有附加头结点的单链表。
算法与及数据结构实验报告
算法与及数据结构实验报告算法与数据结构实验报告一、实验目的本次算法与数据结构实验的主要目的是通过实际操作和编程实现，深入理解和掌握常见算法和数据结构的基本原理、特性和应用，提高我们解决实际问题的能力和编程技巧。
二、实验环境本次实验使用的编程语言为 Python，开发环境为 PyCharm。
同时，为了进行算法性能的分析和比较，使用了 Python 的 time 模块来计算程序的运行时间。
三、实验内容1、线性表的实现与操作顺序表的实现：使用数组来实现顺序表，并实现了插入、删除、查找等基本操作。
链表的实现：通过创建节点类来实现链表，包括单向链表和双向链表，并完成了相应的操作。
2、栈和队列的应用栈的实现与应用：用数组或链表实现栈结构，解决了表达式求值、括号匹配等问题。
队列的实现与应用：实现了顺序队列和循环队列，用于模拟排队系统等场景。
3、树结构的探索二叉树的创建与遍历：实现了二叉树的先序、中序和后序遍历算法，并对其时间复杂度进行了分析。
二叉搜索树的操作：构建二叉搜索树，实现了插入、删除、查找等操作。
4、图的表示与遍历邻接矩阵和邻接表表示图：分别用邻接矩阵和邻接表来存储图的结构，并对两种表示方法的优缺点进行了比较。
图的深度优先遍历和广度优先遍历：实现了两种遍历算法，并应用于解决路径查找等问题。
5、排序算法的比较插入排序、冒泡排序、选择排序：实现了这三种简单排序算法，并对不同规模的数据进行排序，比较它们的性能。
快速排序、归并排序：深入理解并实现了这两种高效的排序算法，通过实验分析其在不同情况下的表现。
6、查找算法的实践顺序查找、二分查找：实现了这两种基本的查找算法，并比较它们在有序和无序数据中的查找效率。
四、实验步骤及结果分析1、线性表的实现与操作顺序表：在实现顺序表的插入操作时，如果插入位置在表的末尾或中间，需要移动后续元素以腾出空间。
删除操作同理，需要移动被删除元素后面的元素。
在查找操作中，通过遍历数组即可完成。
线性表的链式存储结构实验报告
实验报告课程名称：数据结构与算法分析实验名称：链表的实现与应用实验日期：班级：数媒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.首先书上给的链表输入是倒序的，写的时候想都没想就抄上去了，结果运行时发现问题，可是上网百度依然没有把问题解决，导致最后输出链表倒序的，并且链表的合并并集依旧是倒序的。
数据结构实训实验报告
一、实验背景数据结构是计算机科学中一个重要的基础学科，它研究如何有效地组织和存储数据，并实现对数据的检索、插入、删除等操作。
为了更好地理解数据结构的概念和原理，我们进行了一次数据结构实训实验，通过实际操作来加深对数据结构的认识。
二、实验目的1. 掌握常见数据结构（如线性表、栈、队列、树、图等）的定义、特点及操作方法。
2. 熟练运用数据结构解决实际问题，提高算法设计能力。
3. 培养团队合作精神，提高实验报告撰写能力。
三、实验内容本次实验主要包括以下内容：1. 线性表（1）实现线性表的顺序存储和链式存储。
（2）实现线性表的插入、删除、查找等操作。
2. 栈与队列（1）实现栈的顺序存储和链式存储。
（2）实现栈的入栈、出栈、判断栈空等操作。
（3）实现队列的顺序存储和链式存储。
（4）实现队列的入队、出队、判断队空等操作。
3. 树与图（1）实现二叉树的顺序存储和链式存储。
（2）实现二叉树的遍历、查找、插入、删除等操作。
（3）实现图的邻接矩阵和邻接表存储。
（4）实现图的深度优先遍历和广度优先遍历。
4. 算法设计与应用（1）实现冒泡排序、选择排序、插入排序等基本排序算法。
（2）实现二分查找算法。
（3）设计并实现一个简单的学生成绩管理系统。
四、实验步骤1. 熟悉实验要求，明确实验目的和内容。
2. 编写代码实现实验内容，对每个数据结构进行测试。
3. 对实验结果进行分析，总结实验过程中的问题和经验。
4. 撰写实验报告，包括实验目的、内容、步骤、结果分析等。
五、实验结果与分析1. 线性表（1）顺序存储的线性表实现简单，但插入和删除操作效率较低。
（2）链式存储的线性表插入和删除操作效率较高，但存储空间占用较大。
2. 栈与队列（1）栈和队列的顺序存储和链式存储实现简单，但顺序存储空间利用率较低。
（2）栈和队列的入栈、出队、判断空等操作实现简单，但需要考虑数据结构的边界条件。
3. 树与图（1）二叉树和图的存储结构实现复杂，但能够有效地表示和处理数据。
数据结构实验报告
数据结构实验报告一、实验目的数据结构是计算机科学中重要的基础课程，通过本次实验，旨在深入理解和掌握常见数据结构的基本概念、操作方法以及在实际问题中的应用。
具体目的包括：1、熟练掌握线性表（如顺序表、链表）的基本操作，如插入、删除、查找等。
2、理解栈和队列的特性，并能够实现其基本操作。
3、掌握树（二叉树、二叉搜索树）的遍历算法和基本操作。
4、学会使用图的数据结构，并实现图的遍历和相关算法。
二、实验环境本次实验使用的编程环境为具体编程环境名称，编程语言为具体编程语言名称。
三、实验内容及步骤（一）线性表的实现与操作1、顺序表的实现定义顺序表的数据结构，包括数组和表的长度等。
实现顺序表的初始化、插入、删除和查找操作。
2、链表的实现定义链表的节点结构，包含数据域和指针域。
实现链表的创建、插入、删除和查找操作。
（二）栈和队列的实现1、栈的实现使用数组或链表实现栈的数据结构。
实现栈的入栈、出栈和栈顶元素获取操作。
2、队列的实现采用循环队列的方式实现队列的数据结构。
完成队列的入队、出队和队头队尾元素获取操作。
（三）树的实现与遍历1、二叉树的创建以递归或迭代的方式创建二叉树。
2、二叉树的遍历实现前序遍历、中序遍历和后序遍历算法。
3、二叉搜索树的操作实现二叉搜索树的插入、删除和查找操作。
（四）图的实现与遍历1、图的表示使用邻接矩阵或邻接表来表示图的数据结构。
2、图的遍历实现深度优先遍历和广度优先遍历算法。
四、实验结果与分析（一）线性表1、顺序表插入操作在表尾进行时效率较高，在表头或中间位置插入时需要移动大量元素，时间复杂度较高。
删除操作同理，在表尾删除效率高，在表头或中间删除需要移动元素。
2、链表插入和删除操作只需修改指针，时间复杂度较低，但查找操作需要遍历链表，效率相对较低。
（二）栈和队列1、栈栈的特点是先进后出，适用于函数调用、表达式求值等场景。
入栈和出栈操作的时间复杂度均为 O(1)。
2、队列队列的特点是先进先出，常用于排队、任务调度等场景。
数据结构实验报告线性表(数组、链表)的操作
}
//查找第i个元素,并由e返回其值
int GetElem(LinkList&L,int i, int &e) {
LinkList p=L->next;
int j=1;
while (p && j<i) {
p=p->next; ++j;
}
if (!p||j>i) return 0;
e=p->data;
LNode *q=L->next;while(q){cout<<q->data<<" ";q=q->next;}
cout<<endl;
int choice;
cout<<"请选择功能:"<<endl;
cout<<"1.插入元素"<<endl;
cout<<"2.删除元素"<<endl;
cout<<"3.查找元素"<<endl;
LinkList p=L->next;
int j=1;
while (p && j<i) {
p=p->next; ++j;
}
if (!p||j>i) return 0;
e=p->data;
cout<<"该元素的值为"<<e<<"\n";
return 1;
}
排序：
[数据结构]实验一 线性表的顺序存储结构和链式存储结构
![[数据结构]实验一 线性表的顺序存储结构和链式存储结构](https://img.taocdn.com/s3/m/81694a01a6c30c2259019e72.png)
中山大学新华学院实验报告课程名称：数据结构实验名称：实验一线性表的顺序存储结构和链式存储结构班级：09级计算机学生姓名：郑永坤学号：09052029指导教师评定：签名:题目：利用线性表的顺序存储结构和链式存储结构分别存储数据并把数据输出。
一、需求分析⒈本演示程序分别用顺序存储结构和链式存储结构存储数据并把数据输出。
⒉在演示过程序中，用户敲击键盘，输入数据存储，即可看到数据的输出。
⒊程序执行的命令包括：（1）定义结构体（2）建立空表（3）构造输入数据的函数（4）构造输出数据的函数二、概要设计⒈为实现上述算法，需要线性表的抽象数据类型：顺序存储结构的抽象数据类型：ADT SqList {数据对象：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}基本操作:InitList_Sq(SqList *L)操作结果：构造一个空的线性表L。
inputlist(SqList *L)初始条件：线性表L已经存在操作结果：存储输入的数据元素。
outputlist(SqList *L)初始条件：线性表L已经存在操作结果：输出表L。
}ADT SqList链式存储结构的抽象数据类型：ADT linklist {数据对象：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}基本操作:linklist *creatL(linklist *L)初始条件：线性表L已经存在操作结果：存储输入的数据元素。
output(linklist *L)初始条件：线性表L已经存在操作结果：输出表L。
}ADT linklist2. 本程序有三个模块：⑴主程序模块void main(){初始化；{接受命令；显示结果；｝｝⑵线性表单元模块：实现线性表抽象数据类型；⑶结点结构单元模块：定义线性表中的结点结构。
数据结构实验报告（一）线性表的应用
数据结构实验报告（⼀）线性表的应⽤实验说明数据结构实验⼀ 线性表的实验——线性表的应⽤⼀、实验⽬的通过本实验使学⽣了解线性表的⼀种简单应⽤，熟悉线性表顺序存储与链式存储的特性，特别训练学⽣编程灵活控制链表的能⼒，为今后编程控制更为复杂的数据结构奠定基础。
⼆、实验内容1.⽤顺序表和链表分别分别编程实现教材中例⼦2-1与2-2。
要求：（1）只能⽤C语⾔编程实现；（2）完全保持书中算法2.1与算法2.2形式，不允许有任何变化，除⾮语法上不允许;所调⽤各函数参照书中19页的功能描述，其中函数名、参数个数及性质、函数功能必须与书中完全⼀致，不能有变化。
2.利⽤线性表表⽰⼀元多项式完成多项式的加、减、乘、求导、求值运算。
要求：（1）输⼊的⼀元多项式可以采⽤只输⼊各项的系数与指数这种简化的⽅式。
如对于多项式2x2+6x5，输⼊可为： 2,2 6,5 这样的简单形式。
（2）遇到有消项时应当处理，如2x2+6x5与3x2-6x5进⾏相加时，结果为5*x^2。
（3）当给定x的值时，能计算表达式相加或相减的结果。
（4）操作的结果放⼊⼀个新线性表中，原来的两个表达式存储表⽰不变，也可以不是产⽣新的线性表，⽽是将两上线性表合并为⼀个。
（5）要求程序功能模块划分合理（每个函数功能单⼀、可重⽤性好），使⽤空间尽可能少，算法尽可能⾼效。
实验报告1.实现功能描述使⽤线性表表⽰⼀元多项式完成多项式的加、减，乘，求导、求值运算。
2.⽅案⽐较与选择（1）因为使⽤的是线性表，所以主要⽅案有数组法和链表法。
（2）从时间复杂度来说，使⽤数组法更优；从空间复杂度来说，链表法更优。
因为数组法是指定好空间的，若式⼦⼤⼩超出设置⼤⼩，那程序必然出错；若式⼦⼤⼩⼩于设置⼤⼩，那就意味着有多余的空间被浪费了。
综合来讲，若计算式⼦较为庞⼤，使⽤链表法更佳；相反，若计算式⼦较⼩，数组法更佳。
3.设计算法描述（1）单个项式的数据存储使⽤了结构体，数组法是在⼀个结构体中定义两个⼀维数组；链表法是通过⼀个结构体作为⼀个节点，通过next指针连接起来。
线性表的链式存储结构实验报告
线性表的链式存储结构实验报告实验一：线性表的链式存储结构【问题描述】某项比赛中，评委们给某参赛者的评分信息存储在一个带头结点的单向链表中，编写程序：（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;}实验结束。
数据结构实验报告-实验一顺序表、单链表基本操作的实现
数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现l 实验⽬的1、顺序表（1）掌握线性表的基本运算。
（2）掌握顺序存储的概念，学会对顺序存储数据结构进⾏操作。
（3）加深对顺序存储数据结构的理解，逐步培养解决实际问题的编程能⼒。
l 实验内容1、顺序表1、编写线性表基本操作函数：（1）InitList(LIST *L,int ms)初始化线性表；（2）InsertList(LIST *L,int item,int rc)向线性表的指定位置插⼊元素；（3）DeleteList1(LIST *L,int item)删除指定元素值的线性表记录；（4）DeleteList2(LIST *L,int rc)删除指定位置的线性表记录；（5）FindList(LIST *L,int item)查找线性表的元素；（6）OutputList(LIST *L)输出线性表元素；2、调⽤上述函数实现下列操作：（1）初始化线性表；（2）调⽤插⼊函数建⽴⼀个线性表；（3）在线性表中寻找指定的元素；（4）在线性表中删除指定值的元素；（5）在线性表中删除指定位置的元素；（6）遍历并输出线性表；l 实验结果1、顺序表（1）流程图（2）程序运⾏主要结果截图（3）程序源代码#include<stdio.h>#include<stdlib.h>#include<malloc.h>struct LinearList/*定义线性表结构*/{int *list; /*存线性表元素*/int size; /*存线性表长度*/int Maxsize; /*存list数组元素的个数*/};typedef struct LinearList LIST;void InitList(LIST *L,int ms)/*初始化线性表*/{if((L->list=(int*)malloc(ms*sizeof(int)))==NULL){printf("内存申请错误");exit(1);}L->size=0;L->Maxsize=ms;}int InsertList(LIST *L,int item,int rc)/*item记录值；rc插⼊位置*/ {int i;if(L->size==L->Maxsize)/*线性表已满*/return -1;if(rc<0)rc=0;if(rc>L->size)rc=L->size;for(i=L->size-1;i>=rc;i--)/*将线性表元素后移*/L->list[i+=1]=L->list[i];L->list[rc]=item;L->size++;return0;}void OutputList(LIST *L)/*输出线性表元素*/{int i;printf("%d",L->list[i]);printf("\n");}int FindList(LIST *L,int item)/*查找线性元素，返回值>=0为元素的位置，返回-1为没找到*/ {int i;for(i=0;i<L->size;i++)if(item==L->list[i])return i;return -1;}int DeleteList1(LIST *L,int item)/*删除指定元素值得线性表记录，返回值为>=0为删除成功*/ {int i,n;for(i=0;i<L->size;i++)if(item==L->list[i])break;if(i<L->size){for(n=i;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return i;}return -1;}int DeleteList2(LIST *L,int rc)/*删除指定位置的线性表记录*/{int i,n;if(rc<0||rc>=L->size)return -1;for(n=rc;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return0;}int main(){LIST LL;int i,r;printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.size,LL.Maxsize);printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.list,LL.Maxsize);while(1){printf("请输⼊元素值，输⼊0结束插⼊操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d",&i);if(i==0)break;printf("请输⼊插⼊位置：");scanf("%d",&r);InsertList(&LL,i,r-1);printf("线性表为：");OutputList(&LL);}while(1){printf("请输⼊查找元素值，输⼊0结束查找操作：");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d ",&i);if(i==0)break;r=FindList(&LL,i);if(r<0)printf("没有找到\n");elseprintf("有符合条件的元素，位置为：%d\n",r+1);}while(1){printf("请输⼊删除元素值，输⼊0结束查找操作：");fflush(stdin);/*清楚标准缓存区*/scanf("%d",&i);if(i==0)break;r=DeleteList1(&LL,i);if(i<0)printf("没有找到\n");else{printf("有符合条件的元素，位置为：%d\n线性表为：",r+1);OutputList(&LL);}while(1){printf("请输⼊删除元素位置，输⼊0结束查找操作：");fflush(stdin);/*清楚标准输⼊缓冲区*/scanf("%d",&r);if(r==0)break;i=DeleteList2(&LL,r-1);if(i<0)printf("位置越界\n");else{printf("线性表为：");OutputList(&LL);}}}链表基本操作l 实验⽬的2、链表（1）掌握链表的概念，学会对链表进⾏操作。
数据结构线性表单链表实验报告
数据结构实验报告班级姓名同组者/ 成绩日期2020.3.25指导教师实验名称线性表及其应用一、实验目的：1、深刻理解线性表的逻辑特性及其顺序、链式存储方式的特点。
2、熟练掌握线性表的常用操作（建立、插入、删除、遍历等）在顺序、链式存储上的实现。
3、加深对C/C++、Java等编程语言的相关知识点的理解（如结构体/类、指针/引用、函数/方法、引用参数等）。
二、实验内容：1、题目根据给定的整型数组，以尾插法建立一个单链表，并实现以下操作：①查找：输入一个欲查找的整数，找到则显示第一个相匹配的整数在单链表中所处的位置，若不存在，则显示提示信息。
②删除：输入一个欲删除的整数e，若存在则在单链表中删除第一个值为e的元素。
③插入：输入一个欲插入位置i和欲插入元素e，将e插入到第i个整数之前（注意i的合法性）。
源码#include<stdio.h>#include<stdlib.h>typedef int Elemtype;typedef int Status;typedef struct node// 定义存储节点{int data;// 数据域struct node *next;// 结构体指针} *linklist,node;//结构体变量，结构体名称linklist creat (int n)//创建单链表{linklist head,r,p;// 定义头指针r,p,指针int x,i;head=(node *)malloc(sizeof(node));// 生成头结点r=head;//r指向头结点printf(" 输入数字:\n");for(i=n;i>0;i--)//for循环用于生成第一个节点并读入数据{scanf("%d",&x);p=(node *)malloc(sizeof(node));p->data=x;//读入第一个节点的数据r->next=p;//把第一个节点连在头结点的后面r=p;//循环以便于生成第二个节点}r->next=0;//生成链表后的断开符return head;// 返回头指针}void output (linklist head) //输出链表{linklist p;p=head->next;do{printf("%3d",p->data);p=p->next;}while(p);printf("\n");}Status insert ( linklist &l,int i, Elemtype e)// 插入操作{int j=0;linklist p = l,s;while(j<i-1 && p){p=p->next;++j;}if(!p || j>i-1)return -1;else{s=(node *)malloc(sizeof(node));s->data=e;s->next=p->next;p->next=s;return 1;}}Status delect ( linklist &l,int i, Elemtype &e) //删除操作{int j=0;linklist p=l,q;while(j<i-1 && p->next){p=p->next;++j;}if(!p->next || j>i-1)return -1;else{q=p->next;p->next=q->next;e=q->data;free(q);return 1;}}void combine(linklist la,linklist lb)//合并单链表{node *pa,*pb,*pc;linklist lc;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);}Status GetElem(linklist l,int i,Elemtype &e )//查找操作{linklist p;int j;p=l->next;j=1;while(p && j<i){p=p->next;++j;}if(!p || j>i)return -2;e=p->data;return e;}void main(){linklist la,lb;int n;int i,j;Elemtype e;printf(" 请输入第一个链表:\n");printf(" 输入链表元素的个数:\n");scanf("%d",&n);la=creat(n);printf(" 输出链表:\n");output(la);printf(" 请输入要查找元素的位置:\n");scanf("%d",&i);j=GetElem(la,i,e);printf(" 所要查找的元素是%d\n",j);printf(" 请输入插入位置和元素:\n");scanf("%d%d",&i,&e);insert(la,i,e);printf(" 插入后的链表:\n");output(la);printf(" 请输入要删除的位置:\n");scanf("%d",&i);delect(la,i,e);printf(" 删除的那个元素是:%d\n",e);printf(" 输出删除后的顺序表:\n");output(la);printf(" 请输入第一个非递减链表:\n");printf(" 输入链表元素的个数:\n");scanf("%d",&n);la=creat(n);printf(" 输出链表:\n");output(la);printf(" 请输入第二个非递减链表:\n");printf(" 输入链表元素个数:\n")；scanf("%d",&n);lb=creat(n);printf(" 输出链表:\n");output(lb);combine(la,lb);printf(" 输出合并后的链表:\n");output(la);}运行结果：2、题目分别创建两个有序的顺序表（每个表的元素个数及每个元素的值在运行时由键盘输入），现将两个有序表合并，并保证新表依然为有序的顺序表。
线性表的链式存储结构实验报告
线性表的链式存储结构实验报告文件编码（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.首先书上给的链表输入是倒序的，写的时候想都没想就抄上去了，结果运行时发现问题，可是上网百度依然没有把问题解决，导致最后输出链表倒序的，并且链表的合并并集依旧是倒序的。
(完整版)数据结构线性表的应用实验报告
实验报告课程名称____数据结构上机实验__________ 实验项目______线性表的应用 ____________实验仪器________PC机___________________系别_____电子信息与通信学院___专业________ ___班级/学号______ __学生姓名______ ___________实验日期_______________________成绩_______________________指导教师_______________________实验一.线性表的应用1.实验目的：掌握线性链表的存储、运算及应用。
利用链表实现一元多项式计算。
2.实验内容：1)编写函数，实现用链表结构建立多项式；2)编写函数，实现多项式的加法运算；3)编写函数，实现多项式的显示；4)测试：编写主函数，它定义并建立两个多项式，显示两个多项式，然后将它们相加并显示结果。
变换测试用的多项式，检查程序的执行结果。
选做内容：修改程序，选择实现以下功能：5)多项式求值：编写一个函数，根据给定的x值计算并返回多项式f(x)的值。
测试该函数（从终端输入一个x的值，调用该函数并显示返回结果）。
6)多项式相减：编写一个函数，求两个多项式相减的多项式。
7)多项式相乘：编写一个函数，求两个多项式的乘积多项式。
3.算法说明：1)多项式的建立、显示和相加算法见讲义。
可修改显示函数，使输出的多项式更符合表达规范。
2)多项式减法：同次项的系数相减（缺项的系数是0）。
例如a(x)=-5x2+2x+3，b(x)= -4x3+3x，则a(x)-b(x)=4x3-5x2-x+3。
提示：a(x)-b(x) = a(x)+(-b(x))。
3)多项式乘法：两个多项式的相乘是“系数相乘，指数相加”。
算法思想是用一个多项式中的各项分别与另一个多项式相乘，形成多个多项式，再将它们累加在一起。
例如，a(x)=-5x2+2x+3，b(x)=-4x3+3x，则a(x)*b(x) = (-4x3)*(-5x2+2x+3)+(3x)*(-5x2+2x+3)= (20x5-8x4-12x3) + (-15x3+6x2+9x) =20x5-8x4-27x3+6x2+9x。
数据结构线性表实验报告
数据结构线性表实验报告一、实验目的本次实验的主要目的是深入理解和掌握数据结构中线性表的基本概念、存储结构和操作算法，并通过实际编程实现来提高对线性表的应用能力和编程技能。
二、实验环境本次实验使用的编程语言为C+＋，开发工具为Visual Studio 2019。
三、实验内容（一）线性表的顺序存储结构顺序表是用一组地址连续的存储单元依次存储线性表的数据元素。
其特点是逻辑上相邻的元素在物理位置上也相邻，便于随机存取，但插入和删除操作需要移动大量元素，效率较低。
（二）线性表的链式存储结构链表是通过指针将一组零散的存储单元链接成一个线性序列。
常见的链表有单链表、双向链表和循环链表。
链表的插入和删除操作只需修改指针，无需移动元素，但随机存取效率较低。
（三）线性表的基本操作实现1、初始化线性表2、销毁线性表3、清空线性表4、判断线性表是否为空5、获取线性表的长度6、获取指定位置的元素7、查找指定元素在线性表中的位置8、在线性表指定位置插入元素9、删除线性表指定位置的元素四、实验步骤（一）顺序表的实现1、定义顺序表的结构体，包括数据存储数组和表的长度。
2、实现顺序表的初始化函数，分配初始存储空间并设置表长度为0。
3、销毁顺序表函数，释放存储空间。
4、清空顺序表函数，将表长度置为 0。
5、判断顺序表是否为空，根据表长度判断。
6、获取顺序表长度，直接返回表长度。
7、获取指定位置元素，检查位置合法性后返回对应元素。
8、查找指定元素位置，遍历表进行比较。
9、插入元素函数，检查插入位置合法性，若合法则移动后续元素，插入新元素并更新表长度。
10、删除元素函数，检查删除位置合法性，若合法则移动后续元素，更新表长度。
（二）链表的实现1、定义链表节点结构体，包含数据域和指针域。
2、实现链表的初始化函数，创建头节点。
3、销毁链表函数，遍历链表释放节点内存。
4、清空链表函数，遍历链表删除节点但保留头节点。
5、判断链表是否为空，检查头节点的指针域是否为空。
数据结构实验线性表的链式存储结构
南昌航空大学实验报告课程名称：数据结构实验名称：实验一线性表的链式存储结构班级：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() 序运行结果：
五.实验总结：
通过线性表链式存储运算的算法实现的上机实验，我了解了链式的基本原理和方法，能编程对数据进行链式存储。
由于顺序储存是用物理位置上的邻接关系来表示结点间的逻辑关系，其插入或删除运算不方便，而且当表长变化较大时，难以确定合适的存储规模，为了解决这些问题，我们采用链接方式存储线性表。
所以，当线性表的长度变化较大，难以估计其存储规模时，以采用动态链表作为存储结构为好；如果对于频繁进行插入删除的线性表，以采用链表做存储结构。
链接存储是最常用的存储方法之一，它不仅可以表示线性表，还可以用来表示各种非线性的数据结构。
线性表链式存储运算的算法实现
昆明理工大学信息工程与自动化学院学生实验报告（2011—2012学年第1学期）课程名称：数据结构开课实验室：信自楼442 2011年 11月 08日年级、专业、班学号姓名成绩实验项目名称线性表链式存储运算的算法实现指导教师教师评语教师签名：年月日一、程序功能：（1）.线性表链式存储运算的的主要函数设置如下：1.主程序：void main(){linkList *head=NULL;char ch;int i,key;do{ch=caiDan();printf("%c",ch);getch();printf("\n");switch(ch){case '1': head=createList();printf("\n链表被成功的创建");getch();break;case '2': display(head);if(head==NULL) { getch(); break; }else {printf("\n请输入你想插入的元素:");scanf("%d",&key);printf("请输入你想插入的位置:");scanf("%d",&i);insert(head,key,i);break; }case '3': display(head);if(head==NULL) { getch(); break; }else {printf("\n请输入你想删除元素的位置:");scanf("%d",&i);Delete(head,i-1);break; }case '4': display(head);getch();break;case '5': exit(0);}}while(ch!='5');2.链表的建立linkList *createList(){int num;linkList *head,*s,*r;head=NULL;r=NULL;printf("请输入元素(输入0时停止):");scanf("%d",&num);while(num!=00){s=(linkList*)malloc(sizeof(linkList));s->data=num;if(head==NULL) head=s;else r->next=s;r=s;printf("请输入元素(输入0时停止):");scanf("%d",&num);}3.链表的数据插入void insert(linkList *L,dataType x,int i){linkList *p;int j;j=i-1;p=get(L,j);if(p==NULL){printf("插入失败！\n");getch();}else {insertAfter(p,x);printf("\n插入成功！");getch();} }4.链表的数据删除void Delete(linkList *L,int i){int j;linkList *p;j=i-1;p=get(L,j);if(p!=NULL&&p->next!=NULL){deleteAfter(p);printf("\n删除成功");getch();}else{printf("删除失败\n");getch();}}5.链表的输出void display(linkList *head){int i=1;if(head==NULL){printf("Empty List\n");}while(head!=NULL){printf("Index[%d]:%d\n",i,head->data);head=head->next;i++;}}char caiDan(){char ch;do{printf("1:创建一个链表\n");printf("2:插入\n");printf("3:删除\n");printf("4:显示\n");printf("5:退出\n");printf("请选择:");}while(ch=getch(),ch!='1'&&ch!='2'&&ch!='3'&&ch!='4'&&ch!='5');（2）.程序代码如下：#include<stdio.h>#include<conio.h>#include<malloc.h>#include<stdlib.h>typedef int dataType;typedef struct node{dataType data;struct node *next;}linkList;linkList *createList(){int num;linkList *head,*s,*r;head=NULL;r=NULL;printf("请输入元素(输入0时停止):");scanf("%d",&num);while(num!=00){s=(linkList*)malloc(sizeof(linkList));s->data=num;if(head==NULL) head=s;else r->next=s;r=s;printf("请输入元素(输入0时停止):");scanf("%d",&num);}if(r!=NULL) r->next=NULL;return head;}linkList *get(linkList *head,int i){int j;linkList *p;p=head;j=0;while((p->next!=NULL)&&(j<i))p=p->next;j++;}if(i==j) return p;else return NULL;}linkList *locate(linkList *head,dataType key) {linkList *p;p=head->next;while(p!=NULL){if(p->data!=key)p=p->next;else break;}return p;}void insertAfter(linkList *p,dataType x) {linkList *s;s=(linkList*)malloc(sizeof(linkList));s->data=x;s->next=p->next;p->next=s;}void insertBefore(linkList *p,dataType x) {linkList *s;s=(linkList*)malloc(sizeof(linkList));s->data=p->data;s->next=p->next;p->next=s;p->data=x;}void insert(linkList *L,dataType x,int i) {linkList *p;int j;j=i-1;p=get(L,j);if(p==NULL)printf("插入失败！\n");getch();}else {insertAfter(p,x);printf("\n插入成功！");getch();} }void deleteAfter(linkList *p){linkList *r;r=p->next;p->next=r->next;free(r);}void Delete(linkList *L,int i){int j;linkList *p;j=i-1;p=get(L,j);if(p!=NULL&&p->next!=NULL){deleteAfter(p);printf("\n删除成功");getch();} else{printf("删除失败\n");getch();}}void display(linkList *head){int i=1;if(head==NULL){printf("Empty List\n");}while(head!=NULL){printf("Index[%d]:%d\n",i,head->data);head=head->next;i++;}}char caiDan(){char ch;do{printf("1:创建一个链表\n");printf("2:插入\n");printf("3:删除\n");printf("4:显示\n");printf("5:退出\n");printf("请选择:");}while(ch=getch(),ch!='1'&&ch!='2'&&ch!='3'&&ch!='4'&&ch!='5'); return ch;}void main(){linkList *head=NULL;char ch;int i,key;do{ch=caiDan();printf("%c",ch);getch();printf("\n");switch(ch){case '1': head=createList();printf("\n链表被成功的创建");getch();break;case '2': display(head);if(head==NULL) { getch(); break; }else {printf("\n请输入你想插入的元素:");scanf("%d",&key);printf("请输入你想插入的位置:");scanf("%d",&i);insert(head,key,i);break; }case '3': display(head);if(head==NULL) { getch(); break; }else {printf("\n请输入你想删除元素的位置:");scanf("%d",&i);Delete(head,i-1);break; }case '4': display(head);getch();break;case '5': exit(0);}}while(ch!='5');}二、实验报告：(1).运行截图如下：1)创建一个链表：2)插入元素：3)删除元素：4)显示插入和删除操作后的链表：5)退出(2)..总结比较线性表顺序存储与链式存储的各自特点。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
昆明理工大学信息工程与自动化学院学生实验报告
（ 201 —201 学年第一学期）
课程名称：数据结构开课实验室：年月日
一.实验内容：
线性表链式存储运算的算法实现，实现链表的建立、链表的数据插入、链表的数据删除、链表的数据输出。
二.实验目的：
1.掌握线性表链式存储结构的C语言描述及运算算法的实现；
2.分析算法的空间复杂度和插入和删除的时间复杂度；
3.总结比较线性表顺序存储存储与链式存储的各自特点。
三.主要程序代码分析：
LinkList creatListR1() 序运行结果：
五.实验总结：
通过线性表链式存储运算的算法实现的上机实验，我了解了链式的基本原理和方法，能编程对数据进行链式存储。
由于顺序储存是用物理位置上的邻接关系来表示结点间的逻
辑关系，其插入或删除运算不方便，而且当表长变化较大时，难以确定合适的存储规模，为了解决这些问题，我们采用链接方式存储线性表。
所以，当线性表的长度变化较大，难以估计其存储规模时，以采用动态链表作为存储结构为好；如果对于频繁进行插入删除的线性表，以采用链表做存储结构。
链接存储是最常用的存储方法之一，它不仅可以表示线性表，还可以用来表示各种非线性的数据结构。