线性表的抽象数据类型的实现实验报告
数据结构线性表实验报告
实验报告实验一线性表实验目的：1. 理解线性表的逻辑结构特性；2. 熟练掌握线性表的顺序存储结构的描述方法，以及在该存储结构下的基本操作；并能灵活运用；3. 熟练掌握线性表的链表存储结构的描述方法，以及在该存储结构下的基本操作；并能灵活运用；4•掌握双向链表和循环链表的的描述方法，以及在该存储结构下的基本操作。
实验原理：线性表顺序存储结构下的基本算法；线性表链式存储结构下的基本算法；实验内容：2 - 21设计单循环链表，要求：(1 ) 单循环链表抽象数据类型包括初始化操作、求数据元素个数操作、插入操作、删除操作、取消数据元素操作和判非空操作。
(2 ) 设计一个测试主函数，实际运行验证所设计单循环链表的正确性。
2 — 22 .设计一个有序顺序表，要求：(1 ) 有序顺序表的操作集合有如下操作：初始化、求数据元素个数、插入、删除和取数据元素。
有序顺序表与顺序表的主要区别是：有序顺序表中的数据元素按数据元素值非递减有序。
(2 ) 设计一个测试主函数，实际运行验证所设计有序顺序表的正确性。
(3) 设计合并函数ListMerge ( L1,L2,L3 ),功能是把有序顺序表 L1和L2中的数据元素合并到L3，要求L3中的数据元素依然保持有序。
并设计一个主函数，验证该合并函数的正确性。
程序代码：2－21 (1)头文件 LinList.h 如下：typedef struct node{DataType data;struct node *next;}SLNode;/* ( 1 )初始化 ListInitiate(SLNode * * head)*/void ListInitiate(SLNode * * head){ /* 如果有内存空间，申请头结点空间并使头指针 head 指向头结点 */if((*head=(SLNode *)malloc(sizeof(SLNode)))==NULL)exit(1);(*head)->next=NULL; /* 置结束标记 NULL*/}/*(2) 求当前数据元素个数 ListLength(SLNode * head)*/int ListLength(SLNode * head){SLNode *p=head;int size=0;while(p->next!=head){p=p->next;size++;}return size;}/*(3) 插入 ListInsert(SLNode * head ， int i ， DataType x)*//* 在带头结点的单链表的第 i(0<=i<=size) 个结点前 *//* 插入一个存放数据元素 x 的结点。
线性表操作实验报告
忻州师范学院计算机科学与技术系实验报告（第六组）组长：梁启超组员：晋丹丹张艳华马军刘雪梅孙钰林刘涛分块调试：把算法分拆成几个功能模块，按C程序结构标准分模块调试；3)错误跟踪有两种方法：错误信息排查法、执行路线跟踪法。
错误信息排查法：根据错误信息进行分类排查，要求分析者对C的错误代码要有足够的了解和认识，有经验的程序员多用此法。
执行路线跟踪法：变量分析法（跟踪变量的值）、插入标签法（插入输出标签），这种方法适合初学者。
4）调试分析不宜面面俱到，具体写出关键问题就行。
分析如下：主函数main()首先调用显示操作菜单函数scan()，再根据用户输入的数字选项分别调用以下函数：（1）createlist_l头插法构造单链表；（2）createlist_l2尾插法构造单链表；两种二选一；（2）listinsert_l向单链表中插入元素;（3）listdelete_l删除单链表中的元素;（4）printlist_l遍历单链表;（5）getelem_l按位序查找单链表;（6）locateElem_l按值查找单链表;由上述结构可知，采用分功能模块调试的方法较合理，即主要功能按以下顺序实现：添加——查找——删除——遍历。
5．使用说明与测试结果程序名为TXL.exe，运行环境为DOS。
程序执行后显示（下图为参考截图例子。
）第一次操作需选择1或者2，并且只能选择一种。
程序执行显示我们选择的的是头插法构造单链表，输入1后显示要输入几个数1我们写5个请输入要插入的数据：我们插入15 25 35 45 55遍历单链表删除表中第2个元素在第3个元素中插入68按位序查找单链表;查找第4个元素五、实验总结（调试和运行程序过程中产生的问题及采取的措施；对算法的程序的讨论、分析，改进设想以及其它经验教训；对实验方式、组织、设备、题目的意见和建议等）附源程序清单：#include<stdio.h>#include<stdlib.h>typedef struct lnode{int data;struct lnode *next;}lnode,*linklist;linklist createlist_l(int n){int i;linklist l,p;l=(linklist)malloc(sizeof(lnode));l->next=NULL;printf("please input the data of :");for(i=n;i>0;--i){p=(linklist)malloc(sizeof(lnode));scanf("%d",&p->data);p->next=l->next;l->next=p;}return l;}linklist createlist_l2(int n){int i;linklist l,p,r;l=(linklist)malloc(sizeof(lnode));l->next=NULL;r=l;printf("please input the data of:");for(i=1;i<=n;i++)。
实验总结报告-线性表
实验总结报告-线性表第一篇：实验总结报告-线性表实验总结报告—栈和队列学号：姓名：时间：一、目的 1.做实验的目的加深对线性表的理解，学会定义线性表的存储结构，掌握线性表的基本操作。
2.撰写实验报告的目的对本次实验情况进行总结，加强对实验内容的理解，对实验过程有一个系统的认识，从中获得本次试验的经验，并对实验结果进行适当的分析，加深对栈和队列的理解和认识。
二、内容1.说明实验次数及实验内容本次实验用一次实验课时完成实验内容：节点定义：typedef struct node{int idx;int age;struct node *next;}Node,*List;本次实验的对象的存储内容包括ID和AGE，所以定义了如上的结构体，idx用于存储ID 号，age用于存储年龄，next用于形成链式结构，Node定义了该类型的一个节点，List定义了该类型的一个链表。
（1）、编写函数CreateList()和PrintList()，从给定数组创建链表，打印链表。
int idx[8] = {1,2,3,4,5,6,7,8};int age[8] = {15,18,13,22,50,18,30,20};List CreatList(int idx[], int age[],int len){} int PrintList(List L){}（2）、编写函数DeleteNode(List L, int delete_age)，完成以下操作。
int DeleteNodeAge(List L, int delete_age){} 该函数传入List L，可以直接修改链表的节点，建议返回值为int 或void类型，无需为List类型，3，4题同上。
2.1删除年龄为18的成员，打印链表。
2.2删除年龄为20的成员，打印链表。
2.3删除年龄为15的成员，打印链表。
2.4（可选）删除年龄为21的成员（因无此成员，报错），打印链表。
数据结构线性表试验报告
线性表上机实习1、实验目的（1）熟悉将算法转换为程序代码的过程。
（2）了解顺序表的逻辑结构特性，熟练掌握顺序表存储结构的C语言描述方法。
（3）熟练掌握顺序表的基本运算：查找、插入、删除等，掌握顺序表的随机存取特性。
（4）了解线性表的链式存储结构，熟练掌握线性表的链式存储结构的C语言描述方法。
（5）熟练掌握线性链表（单链表）的基本运算：查找、插入、删除等，能在实际应用中灵活选择适当的链表结构。
2、实验要求（1）熟悉顺序表的插入、删除和查找。
（2）熟悉单链表的插入、删除和查找。
3、实验内容:①顺序表（1）抽象数据类型定义typedef struct {TypeData data[maxsize]; //容量为maxsize的静态顺手表int n; //顺序表中的实际元素个数}SeqList; //静态顺序表的定义在本次实验中，首先建立一个空的静态顺序表，然后键盘输入数据存入表中，然后进入菜单选择界面，通过不同的数字输入，实现对顺序表，删除，插入，查找，显示等操作。
（2）存储结构定义及算法思想在顺序表结构体的定义中，typedef int TypeData 为整型，存储结构如下：for(n=0;n<m;n++){cout<<"请输入线性表数据"<<endl;cin>>L.data[n]; //顺序将数据存入顺序表} //其他存储与此类似，都是直接赋值与数组的某一位插入版块子函数：void insert(SeqList &L) //插入数据{int a,b,c,k;cout<<"请输入插入的数及其插入的位置"<<endl;cin>>a>>b;if(b<=0||b>(L.n+1)) {cout<<"不能在该位置插入"<<endl; return;} //判断插入位置是否合法k=L.data[b-1];L.data[b-1]=a; c=L.n; L.n=L.n+1;while(c>b){L.data[c]=L.data[c-1];c--; //通过循环，实现插入位置后的数据挨个往后移动一位}L.data[b]=k;}顺序表的插入与删除操作类似，在插入与删除后，都要循环调整后面数组的每一位元素，同时记录数据元素的长度的标示符也要跟着改变。
线性表的抽象数据类型的实现实验报告
数据结构实验报告实验名称：线性表的抽象数据类型的实现学号：2011129127姓名：刘瑞奇指导老师：解德祥计算机与信息学院实验1线性表的抽象数据类型的实现实验目的1.掌握线性表的顺序存储结构和链式存储结构；2.熟练掌握顺序表和链表基本算法的实现；3.掌握利用线性表数据结构解决实际问题的方法和基本技巧；4.按照实验题目要求独立正确地完成实验内容（编写、调试算法程序，提交程序清单及及相关实验数据与运行结果）；5.按时提交实验报告。
实验环境计算机、C语言程序设计环境实验学时2学时，选做实验。
实验内容一、顺序表的基本操作实现实验要求：数据元素类型ElemType取整型int。
按照顺序存储结构实现如下算法（各算法边界条件和返回结果适当给出）：①创建任意整数线性表（即线性表的元素值随机在键盘上输入），长度限定在20之内；②打印（遍历）该线性表（依次打印出表中元素值）；③在线性表中查找第i个元素，并返回其值；④在线性表中第i个元素之前插入一已知元素；⑤在线性表中删除第i个元素；⑥求线性表中所有元素值（整数）之和；实验步骤C源程序代码/*file:seqlist.cpp*/#include<stdio.h>#include<stdlib.h>#include<malloc.h>#define size 20#define elemtype intstruct seqlist{ elemtype elem[size];int last;};void menu(){ printf("\n..........................................");printf("\n0.退出操作................................");printf("\n1.建立数据类型为整形的顺序表（长度小于20).");printf("\n2.打印线性表..............................");printf("\n3.在线性表中查找第i个元素，并返回其值.....");printf("\n4.在线性表中第i个元素之前插入一已知元素...");printf("\n5.在线性表中删除第i个元素.................");printf("\n6.求线性表中所有元素值（整数）之和........");printf("\n7.初始化..................................\n");}void ins(seqlist *L){L->last=-1;}void creat(seqlist *L){ int i=0; elemtype j;printf("请输入线性表元素(-1结束):");scanf("%d",&j);while(j!=-1){ L->elem[i++]=j; L->last++;if(i>size-1) break;scanf("%d",&j);}}void print(seqlist *L){ int i;printf("顺序表中元素为:");for(i=0;i<=L->last;i++)printf("%d\t",L->elem[i]);}int find(seqlist *L,int i){ if(i<1||i>L->last+1) return 0;else return(L->elem[i-1]);}int insert(seqlist *L,int i,int x){ int j;if(L->last+1==size||i<1||i>L->last+2) return 0;L->last++;for(j=L->last;j>=i-1;j--)L->elem[j+1]=L->elem[j];L->elem[i-1]=x;return 1;}int del(seqlist *L,int i){ int e,j;if(L->last==-1||i<1||i>L->last+1)return 0;e=L->elem[i-1];for(j=i;j<=L->last+1;j++)L->elem[j-1]=L->elem[j];L->last--; return 1;}int sum(seqlist *L){ int i=0,s=0;if(L->last==-1) return 0;for(i=0;i<=L->last;i++) s+=L->elem[i];return s;}int isempty(seqlist *L){ if(L->last==-1)return 1;else return 0;}void main(){ int i,cz,e; elemtype date; seqlist L;menu();printf("请输入你要执行的操作的序号:");i=scanf("%d",&cz);while(1){ if(!i) printf("只能输入数值");else break;printf("\n再输入一次："); rewind(stdin);i=scanf("%d",&cz);}{ switch(cz){ case 1:if(isempty(&L)){ ins(&L); creat(&L); }else printf("表已经存在，先清空再进行此操作！\n");break;case 2:if(isempty(&L))printf("表为空\n");else print(&L);break;case 3:printf("输入待查找元素的位置:\n");scanf("%d",&i);if(find(&L,i))printf("查找的第%d个元素为%d\n",i,find(&L,i));elseprintf("查找位置错误\n");break;case 4:printf("请输入要插入的元素及位置:\n");scanf("%d",&date);scanf("%d",&i);if(insert(&L,i,date))printf("插入元素成功!\n");else printf("插入位置不合法或栈已满!\n");break;case 5:printf("请输入要删除元素的位置\n");scanf("%d",&i);e=L.elem[i-1];if(del(&L,i)){ printf("删除第%d个值为%d的元素\n",i,e);printf("删除成功\n");}Else printf("删除位置不合法或表已空\n");break;case 6:if(isempty(&L))printf("表已空!\n");else printf("线性表中所有元素值（整数）和:%d\n",sum(&L));break;case 7: ins(&L);break;default: printf("无此操作!\n");break;}menu();printf("请输入你要执行的操作的序号:");i=scanf("%d",&cz);while(1){ if(!i) printf("\n只能输入数值");else break;printf("\n再输入一次："); rewind(stdin);i=scanf("%d",&cz);}}}测试数据与实验结果7.初始化1.建表2.打印3.查找4.插入不合法长度超过205.删除然后打印4~.插入合法6.求和二、链表（带头结点）基本操作实验要求：数据元素类型ElemType取字符型char。
数据结构实验报告线性表
数据结构实验报告线性表数据结构实验报告：线性表引言：数据结构是计算机科学中的重要概念，它涉及到如何组织和存储数据，以及如何有效地操作和管理这些数据。
线性表是数据结构中最基本的一种，它是一种有序的数据元素集合，其中的元素之间存在着一对一的关系。
一、线性表的定义和特点线性表是由n个数据元素组成的有限序列，其中n为表的长度。
这些数据元素可以是相同类型的，也可以是不同类型的。
线性表中的数据元素按照一定的顺序排列，并且每个数据元素都有唯一的前驱和后继。
线性表的特点有以下几个方面：1. 数据元素之间是一对一的关系，即每个数据元素只有一个直接前驱和一个直接后继。
2. 线性表中的元素是有序的，每个元素都有一个确定的位置。
3. 线性表的长度是有限的，它的长度可以是0，也可以是任意正整数。
二、线性表的实现方式线性表可以使用不同的数据结构来实现，常见的实现方式有数组和链表。
1. 数组实现线性表：数组是一种连续存储的数据结构，它可以用来存储线性表中的元素。
数组的优点是可以快速访问任意位置的元素，但是插入和删除操作需要移动其他元素，效率较低。
2. 链表实现线性表：链表是一种非连续存储的数据结构，它通过指针将线性表中的元素链接起来。
链表的优点是插入和删除操作简单高效，但是访问任意位置的元素需要遍历链表，效率较低。
三、线性表的基本操作线性表的基本操作包括插入、删除、查找和修改等。
1. 插入操作：插入操作用于向线性表中插入一个新元素。
具体步骤是先将插入位置后面的元素依次后移，然后将新元素插入到指定位置。
2. 删除操作：删除操作用于从线性表中删除一个元素。
具体步骤是先将删除位置后面的元素依次前移，然后将最后一个元素删除。
3. 查找操作：查找操作用于在线性表中查找指定元素。
具体步骤是从线性表的第一个元素开始逐个比较，直到找到匹配的元素或者到达线性表的末尾。
4. 修改操作：修改操作用于修改线性表中的某个元素的值。
具体步骤是先查找到要修改的元素，然后将其值更新为新值。
实验一 线性表 实验报告
数据结构实验报告实验名称：实验一线性表学生姓名：班级：班内序号：学号：日期：2012年11月3日1、实验要求据线性表的抽象数据类型的定义，选择下面任一种链式结构实现线性表，并完成线性表的基本功能。
线性表存储结构（五选一）：1、带头结点的单链表2、不带头结点的单链表3、循环链表4、双链表5、静态链表线性表的基本功能：1、构造：使用头插法、尾插法两种方法2、插入：要求建立的链表按照关键字从小到大有序3、删除4、查找5、获取链表长度6、销毁7、其他：可自行定义编写测试main()函数测试线性表的正确性2、程序分析2.1存储结构单链表的存储结构2.2关键算法分析一：关键算法1：头插法自然语言描述：a:在堆中建立新结点b:将a[i]写入到新结点的数据域c:修改新结点的指针域d:修改头结点的指针域，并将新结点加入链表中伪代码描述：a:Node * s=new Node ;b:s->data=a[i] ;c:s->next=front->next;d:front->next=s;2:尾插法自然语言描述：a:在堆中建立新结点b:将a[i]写入到新结点的数据域c:将新结点加入到链表中d:修改尾指针伪代码描述:a:Node * s=new Node ;b:s->data=a[i] ;c:r->next=s;d:r=s;3:删除大于min小于max元素算法：自然语言描述：a:建立新结点b:保存第一个结点的位置c:执行循环，查找到p结点为第一个大于min小于max的元素，q为比min 大的前一个元素位置d:执行循环，查找到比max小的最后一个元素位置e:将上述两步骤中的满足条件的中间节点删掉f:将前后两条断链重新连接起来，连接p和q结点伪代码描述：a:Node *p,*q,*r;b: p=front->next;c:while(p&&p->data<=min){q=p;p=p->next;}d和e:while(p&&p->data<max) //找比max小的最后一个元素位置{r=p;p=p->next;delete r; //释放满足条件的结点}f: q->next=p;4：链表逆置算法自然语言描述：a:建立新结点b:判断链表是否为空表或者单结点链表c:将开始结点变成终端结点d:执行循环，使每次循环都将后一个结点变成开始结点e:遍历打印伪代码描述：a:Node *p,*q;b:if(front->next&&front->next->next)c: p=front->next;q=p->next;p->next=NULL;d:while(q){p=q; //每次循环将后一个结点变成起始结点q=q->next;p->next=front->next;front->next=p;}e: z=front->next;while(z) //遍历打印逆置后的序列{cout<<z->data<<"";z=z->next;}5.销毁函数自然语言描述：a:新建立一个指针，指向头结点b:判断要释放的结点是否存在c:暂时保存要释放的结点d:移动a中建立的指针e:释放要释放的指针伪代码描述：a:Node * p=frontb:while(p)c:front=pd:p=p->nexte:delete front6.按位查找函数（查找第i个元素的位置）自然语言描述：a:初始化工作指针p和计数器j，p指向第一个结点，j=1b:循环以下操作，直到p为空或者j等于1b1：p指向下一个结点b2：j加1c:若p为空，说明第i个元素不存在，抛出异常d:否则，说明p指向的元素就是所查找的元素，返回元素地址伪代码描述a:Node * p=front->next;j=1;b:while(p&&（j!=i）)b1:p=p->nextb2:j++c:if(!p) throw ”查找位置有误”d:return p7：按位查找函数（查找值为x的元素并返回其位置）自然语言描述：a:初始化工作指针p和计数器j，p指向第一个结点，j=1b:循环以下操作，找到这个元素或者p指向最后一个结点b1：判断p指向的结点是不是要查找的值，如果是，返回j，否则p指向下一个结点，并且j的值加1c:如果找到最后一个结点还没有找到要查找的元素，返回查找失败信息伪代码描述：a:Node * p=front->next;j=1;b:while(p)b1: if(p->next==x)return j;p=p->next;j++ ;c:throw "找不到指定元素";8.插入函数自然语言描述：a:在堆中建立新结点b:将要插入的结点的数据写入到新结点的数据域c:修改新结点的指针域d:修改前一个指针的指针域，使其指向新插入的结点的位置伪代码描述：a:Node * s=new Node ;b:s-data=xc:s->next=p->nextd:p->next=s9.删除函数自然语言描述：a:从第一个结点开始，查找要删除的位数i前一个位置i-1的结点b:设q指向第i个元素c:将q元素从链表中删除d:保存q元素的数据e:释放q元素伪代码描述：a: if(i!=1)p=Get(i-1);b: q=p->nextc:p->next=q->nextd:x=q->datae:delete q10.遍历输出函数自然语言描述：a:判断该链表是否为空链表，如果是，报错b:如果不是空链表，新建立一个temp指针c:将temp指针指向头结点d:打印temp指针的data域e:逐个往后移动temp指针，直到temp指针指向的next域为空伪代码描述：a:If(front->next==NULL)cout<<"该链表为空链表!"<<endl;b和c:Node * temp=front->next;d和e:while(temp){cout<<temp->data<<"";temp=temp->next;}11.获取链表长度函数自然语言描述：a:判断该链表是否为空链表，如果是，输出长度0b:如果不是空链表，新建立一个temp指针，初始化整形数n为0c:将temp指针指向头结点d:判断temp指针是否为空，如果不是，n加1，否则return ne: 使temp指针逐个后移，重复d操作，直到temp指针指向的next域为0，返回n伪代码描述:a:int n=0;if(front->next==NULL) //如果为空链表{n=0;}b和c: else{Node * temp=front->next;d:while(temp){n++;e: temp=temp->next;}}return n;二、代码详细分析1、头插法关键代码：Node * s=new Node ;s->data=a[i] ;s->next=front->next;front->next=s;示意图：2、尾插法关键代码：Node * s=new Node ;s->data=a[i] ;r->next=s;r=s;示意图：3:删除大于min 小于max 元素算法：关键代码：Node *p,*q,*r,*s;p=front->next;while (p&&p->data<=min){q=p;p=p->next;} //此循环结束时，当前p 结点为第一个大于min 小于max 的元素，q 为比min 大的前一个元素位置while (p&&p->data<max) //找比max 小的最后一个元素位置{r=p;p=p->next;delete r; //释放满足条件的结点}q->next=p;流程图：4：链表逆置算法关键代码：Node *p,*q,*z;if (front->next&&front->next->next) //当链表不是空表或者单结点时{p=front->next;q=p->next;p->next=NULL; //将开始结点变成终端结点while(q){p=q; //每次循环将后一个结点变成起始结点q=q->next;p->next=front->next;front->next=p;}}流程图：5、查找算法关键代码：Node *p=front->next;int j=1;while(p&&(j!=i)) //i=1时循环体不执行{p=p->next;j++;}if(!p) throw"查找位置有误";elsereturn p;流程图：六、删除算法关键代码：Node *p=front;if (i!=1)p=Get(i-1); //查到第i-1个元素的地址Node *q=p->next;p->next=q->next;int x=q->data;delete q;return x;流程图：三、关键算法的时间、空间复杂度头插法/尾插法 O(n)按位查找/按值查找 O(n)插入操作 O(n)逆置操作 O(n)删除大于min小于max操作o(n)2.3其他函数中的按值查找可以修改，把终止条件改为直到指向的结点的next域为空，返回多个地址，那么在链表中如果存在多个待找元素都可以返回。
线性表实验报告
天津农学院数据结构实验报告学院: 天津农学院专业: 信息管理与信息系统班级: 一班学号: 1008044203姓名: 谢亚峰一、实验目的——————————————————————————2二、实验需求——————————————————————————22.1输入的形式和输入的范围———————————————————2 2.2输出的形式—————————————————————————2 2.3程序所能达到的功能—————————————————————2 2.4顺序存储测数数据——————————————————————22.5链式存储测试数据——————————————————————2三、概要设计——————————————————————————23.1链式存储——————————————————————————23.2基本算法——————————————————————————3四、详细设计——————————————————————————44.1顺序存储——————————————————————————44.2链式存储——————————————————————————9五、附录————————————————————————————125.1顺序存储结构源代码—————————————————————125.2链式存储结构源代码—————————————————————17六、实验总结——————————————————————————19 .一、实验目的编制一个演示顺序和链式存储单链表插入、删除、查找等操作的程序二、需求分析本演示程序用visual c++ 6.0环境用c语言编写，完成单链表的生成，任意位置的插入、删除，以及确定某一元素在单链表中的位置。
2.1、输入的形式和输入值的范围：插入元素时需要输入插入的位置和元素的值；删除元素时输入删除元素的位置；查找操作时需要输入元素的值。
实验1线性表的抽象数据类型的实现
实验1线性表的抽象数据类型的实现实验目的1）掌握线性表的顺序存储结构和链式存储结构；2）熟练掌握顺序表和链表基本算法的实现；3）掌握利用线性表数据结构解决实际问题的方法和基本技巧；4）按照实验题目要求独立正确地完成实验内容（编写、调试算法程序，提交程序清单及及相关实验数据与运行结果）；5）按时提交实验报告。
实验环境计算机、C语言程序设计环境实验学时2学时，必做实验。
实验内容一、顺序表的基本操作实现实验要求：数据元素类型ElemType取整型int。
按照顺序存储结构实现如下算法（各算法边界条件和返回结果适当给出）：1）创建任意整数线性表（即线性表的元素值随机在键盘上输入），长度限定在25之内；2）打印（遍历）该线性表（依次打印出表中元素值）；3）在线性表中查找第i个元素，并返回其值；4）在线性表中第i个元素之前插入一已知元素；5）在线性表中删除第i个元素；6）求线性表中所有元素值（整数）之和；二、链表（带头结点）基本操作实验要求：数据元素类型ElemType取字符型char。
按照动态单循环链表结构实现如下算法（各算法边界条件适当给出）：1）创建任意字符型有序（递增排序）单循环链表（即链表的字符元素随机在键盘上输入），长度限定在15之内；2）打印（遍历）该链表（依次打印出表中元素值）；3）在链表中查找第i个元素，i合法返回元素值，否则，返回FALSE；4）在链表中查找与一已知字符相同的第一个结点，有则返回TRUE，否则，返回FALSE； 5）在链表中按照有序方式插入一已知字符元素；6）在线性表中删除第i个结点；7）计算链表的长度。
实验步骤一、顺序表的源程序#include<stdlib.h>#include<stdio.h>#include<malloc.h>int list[25];int i,n,a,sum=0,k,l;int eleminsert;/*------------------创建函数--------------*/void initlist(){printf("Please input the total of the elems:");scanf("%d",&n);if(n>25||n<1) {printf("ERROE!");return;}printf("Please input the elems:...\n");for(i=0;i<n;i++){scanf("%d",&list[i]);}return;}/*------------------打印函数--------------*/void Print(int list[],int n){int j;for(j=0;j<n;j++)printf("%d\t",list[j]);printf("\n");return;}/*------------------查找函数------------*/void Search(int list[],int n,int m){if(m<1||m>n){printf("ERROR!\n"); return ;}else printf("The elem is %d at %d place\n",list[m-1],m); return;}/*----------------插入函数------------*/void Insert(int list[],int n,int m,int elem){int j;if(m<1||m>n){printf("ERROR!\n"); return ;}for(j=n-1;j>=m-1;j--){list[j+1]=list[j];}list[m-1]=elem;n=n+1;printf("The new list are:" );Print(list,n);return;}/*---------------删除函数-----------*/void Delete(int list[],int n,int m){int q;if(m<1||m>n){printf("ERROR!\n"); return ;}for(q=m-1;q<=n;q++){list[q]=list[q+1];}printf("The new list are:");Print(list,n-1);return;}/*-------------求和函数------------*/void Sum(int list[],int n,int sum){int j;for(j=0;j<n;j++){sum=sum+list[j];}printf("The sum is :%d",sum);return;}void menu(){int j;/*------------菜单函数------------*/menulab:printf("********************** MENU ******************\n\n"); printf("Create a new int list :...................press 1\n\n"); printf("Print the whole list :....................press 2\n\n"); printf("Search by order :........................press 3\n\n"); printf("Insert the elem in the place i:...........press 4\n\n"); printf("Delete the elem by order :................press 5\n\n"); printf("Sum all elem in the list :................press 6\n\n"); printf("exit the programe :.......................press 0\n\n"); printf("********************** END *******************\n\n"); printf("Please choose the number from (0~6).....");checklabel: scanf("%1d",&j);getchar();if(j<0||j>7){printf("Error! Please choose again......");goto checklabel;}printf("\n\tYou choose the number %d\n ",j);printf("\n\tPress any key to continue.....");getchar();clrscr(); /*clear screen*/switch(j){case 1:/*创建任意整数线性表*/initlist();clrscr(); /*clear screen*/goto menulab;case 2: /*打印（遍历）该线性表*/printf("The original list is:");Print(list,n);printf("Press any key to continue.....");getchar();clrscr(); /*clear screen*/goto menulab;case 3:/*在线性表中查找第i个元素，并返回其值*/printf("Input which LNode you want to Search(Input number):"); scanf("%d",&a);getchar();Search(l,n,a);printf("Press any key to continue.....");getchar();clrscr(); /*clear screen*/goto menulab;case 4:/*在线性表中第i个元素之前插入一已知元素*/printf("Please input the elem's place where you want to insert"); scanf("%d",&k);printf("Input the elem which you want to insert:");scanf("%d",&eleminsert);Insert(list,n,k,eleminsert);printf("Press any key to continue.....");getchar();clrscr(); /*clear screen*/goto menulab;case 5:/*在线性表中删除第i个元素*/printf("Please input the elem you want to delete:");scanf("%d",&l);n=n+1;Delete(list,n,l);n=n-1;printf("Press any key to continue.....");getchar();clrscr(); /*clear screen*/goto menulab;case 6:/*求线性表中所有元素值（整数）之和*/Sum(list,n,sum);printf("Press any key to continue.....");getchar();clrscr(); /*clear screen*/goto menulab;case 0:/*退出程序*/printf("Press any key to continue.....");getchar();exit(0);}}void main(){void menu();menu();}二、链表（带头结点）的源程序#include<stdlib.h>#include<stdio.h>struct LNode{char elem;struct LNode* next;}*l,*p,*new;int i,a,k,n;char c,s;/*----------------创建函数-------------*/void intilist(void){l=(struct LNode *)malloc(sizeof(struct LNode));l->next=NULL;clrscr();printf("Input the total of the elems:.....");scanf("%d",&n);getchar();if(n>15)printf("Error!");for(i=n;i>0;i--){new=(struct LNode *)malloc(sizeof(struct LNode));new->next=l->next;l->next=new;}p=l;while(p->next!=NULL) p=p->next;p->next=l;printf("Input elems:.......\n");p=l->next;for(i=1;i<=n;i++){scanf("%c",&p->elem);getchar();p=p->next;}return;}/*----------------排序函数-------------*/ void Sequence(struct LNode * l, int n) {int i;char swap,*e,*f;for(i=1;i<=n-1;i++){ p=l->next;while(p->next!=l){if(p->elem>p->next->elem) {e=&p->elem;f=&p->next->elem;swap=*e;*e=*f;*f=swap;} p=p->next;}}return;}/*----------------打印函数-------------*/void Print(struct LNode * l, int n){int i;p=l->next;for(i=1;i<=n;i++){printf("%c\t",p->elem);p=p->next;}printf("\n");return;}/*----------------查找函数-------------*/ void Locate(struct LNode * l, int n,int m){int i;if(m>n) { printf("FALSE!\t");return; }else { p=l;for(i=1;i<=m;i++){p=p->next;}printf("The elem is:%c\n",p->elem);}return;}/*------已知字母匹配首结点查找函数------*/void LocateLNode(struct LNode * l, int n,char m){int i;p=l;for(i=1;i<=n;i++){p=p->next; if(p->elem==m) {printf("TRUE!\n");return;}} if(i>n) printf("FALSE!\n");return;}/*----------------插入函数-------------*/void Insert(struct LNode * l, int n,char m){new=(struct LNode *)malloc(sizeof(struct LNode));new->next=l->next;l->next=new;new->elem=m;n=n+1;Sequence(l,n);Print(l,n);return;}/*----------------删除函数-------------*/void Delete(struct LNode * l, int n,int m){int i;p=l;for(i=1;i<m;i++){p=p->next;}p->next=p->next->next;n=n-1;printf("The new list is:");Print(l,n);return;}/*----------------求表长函数-------------*/void Length(int n){int i;int length=0;for(i=1;i<=n+1;i++){length=length+sizeof(struct LNode);}printf("The length of the list is:%d",length);return;}/*----------------菜单函数-------------*/void menu(){int j;menulab:printf("********************** MENU ******************\n\n"); printf("Create the new list :..................press 1\n\n"); printf("Sequence the list :...................press 2\n\n"); printf("Search the Lnode by order :............press 3\n\n"); printf("Search the Lnode by elem :.............press 4\n\n"); printf("Insert the elem :......................press 5\n\n"); printf("Delete the elem by order :.............press 6\n\n"); printf("Return the length of the list :........press 7\n\n"); printf("exit the programe :....................press 0\n\n"); printf("********************** END *******************\n\n"); printf("Please choose the number from (0~7)....."); checklabel: scanf("%1d",&j);getchar();if(j<0||j>7){printf("Error! Please choose again......");goto checklabel;}printf("\n\tYou choose the number %d\n ",j);printf("\n\tPress any key to continue.....");getchar();clrscr(); /*clear screen*/switch(j){case 1:/*创建链表并输入元素*/intilist();clrscr(); /*clear screen*/goto menulab;case 2: /*排序并打印链表*/Sequence(l,n);printf("The orignal list is:\n");Print(l,n);printf("Press any key to continue.....");getchar();clrscr(); /*clear screen*/goto menulab;case 3:/*查找第i个元素*/printf("Input which LNode you want to locate(Input number):"); scanf("%d",&a);getchar();Locate(l,n,a);printf("Press any key to continue.....");getchar();clrscr(); /*clear screen*/goto menulab;case 4:/*查找与已知字符相同的第一个结点*/printf("Input the elem you want to search ");scanf("%c",&c);getchar();LocateLNode(l,n,c);printf("Press any key to continue.....");getchar();clrscr(); /*clear screen*/goto menulab;case 5:/*插入已知字符的结点*/printf("Input the elem you want to insert:");scanf("%c",&s);getchar();Insert(l,n,s);n=n+1;printf("Press any key to continue.....");getchar();clrscr(); /*clear screen*/goto menulab;case 6:/*删除第i个结点*/printf("Input which one you want to delete:");scanf("%d",&k);if(k<1||k>n)printf("ERROR!");else{Delete(l,n,k);}n=n-1;getchar();clrscr(); /*clear screen*/goto menulab;case 7:/*计算链表长度*/Length(n);printf("Press any key to continue.....");getchar();clrscr(); /*clear screen*/goto menulab;case0:/*退出链表程序*/printf("Press any key to continue.....");getchar();exit(0);}}/*------------------主函数---------------*/main(){void menu(void);menu();}测试数据与实验结果（可以抓图粘贴）一、顺序表程序抓图及其简要说明菜单选项如下图1所示：该菜单由八个函数组成，实现八项功能。
抽象数据类型试验报告
抽象数据类型试验报告
实验目的：
掌握抽象数据类型的概念与实现方式，并进一步理解面向对象程序设计的思想。
实验内容：
设计并实现一个简单的学生信息管理系统，采用抽象数据类型的思想实现。
实验步骤：
1. 设计抽象数据类型：学生信息类。
学生信息类的属性包括姓名、学号、性别、年龄和班级等基本信息。
2. 编写类的定义文件，包括类名、类属性、构造函数和访问方法等。
3. 编写测试程序，实例化学生信息类并设置学生信息。
测试程序应能够对学生信息进行增、删、改、查等操作。
4. 运行测试程序，检查学生信息管理系统功能是否正常。
实验结果：
实验结果显示，学生信息管理系统可以有效地管理学生的基本信息，能够满足学校信息管理的基本需求。
抽象数据类型的应用让程序具有了更好的可维护性和可扩展性，也更符合面向对象程序设计的思想。
实验结论：
抽象数据类型是现代程序设计中的一种重要思想和技术手段，能够有效地提高程序的可重用性和可扩展性，并使程序的设计更加合理和安全。
学生信息管理系统的实现也反映了抽象数据类型的优越性，使得程序开发人员能够更加便捷和高效地开发与维护程序。
线性表实验报告
线性表实验报告一、实验目的本次实验的主要目的是深入理解线性表的基本概念和操作，通过实际编程实现线性表的存储和基本运算，掌握线性表在数据结构中的应用，提高对数据结构的理解和编程能力。
二、实验环境本次实验使用的编程语言为C+＋，开发工具为Visual Studio 2019。
三、实验原理线性表是一种最基本、最简单的数据结构，它是由 n（n≥0）个数据元素组成的有限序列。
在这个序列中，每个数据元素的位置是按照其逻辑顺序排列的。
线性表有两种存储结构：顺序存储结构和链式存储结构。
顺序存储结构是用一组地址连续的存储单元依次存储线性表中的数据元素，使得逻辑上相邻的两个元素在物理位置上也相邻。
其优点是可以随机访问表中的任意元素，时间复杂度为 O(1)；缺点是插入和删除操作需要移动大量元素，时间复杂度为 O(n)。
链式存储结构是通过指针将各个数据元素链接起来，每个数据元素由数据域和指针域组成。
其优点是插入和删除操作不需要移动大量元素，时间复杂度为 O(1)；缺点是不能随机访问表中的元素，需要从头指针开始遍历，时间复杂度为 O(n)。
四、实验内容本次实验实现了顺序表和链表的基本操作，包括创建、插入、删除、查找、遍历等。
1、顺序表的实现定义顺序表的结构体，包括数据存储数组和表的长度。
实现顺序表的初始化函数，将表的长度初始化为 0。
实现顺序表的插入函数，在指定位置插入元素，如果插入位置非法或表已满，则返回错误。
实现顺序表的删除函数，删除指定位置的元素，如果删除位置非法，则返回错误。
实现顺序表的查找函数，查找指定元素，如果找到则返回元素的位置，否则返回－1。
实现顺序表的遍历函数，输出表中的所有元素。
2、链表的实现定义链表的结构体，包括数据域和指向下一个节点的指针域。
实现链表的创建函数，创建一个空链表。
实现链表的插入函数，在指定位置插入元素，如果插入位置非法，则返回错误。
实现链表的删除函数，删除指定位置的元素，如果删除位置非法，则返回错误。
数据结构线性表实验报告
数据结构线性表实验报告⼀、实验⽬的：1、复习c/c++语⾔，并实现简单的算法设计。
2、掌握结构体类型/类的定义⽅法以及⾃定义数据类型使⽤。
3、掌握函数的设计和调⽤。
4、学会理解ADT(Abstract Data Type)描述，从⽽利⽤程序语⾔加以实现。
5、学会基本的程序组织⽅法和对抽象数据类型实现的应⽤。
⼆、实验内容和要求实验内容：设计⼀个复数的抽象类型定义。
实现复数基本运算基本操作。
编写函数对所实现的抽象数据类型进⾏测试并验证。
实验要求：1、由输⼊⽣成复数的实部虚部。
2、对所定义的数据类型的应⽤中，间接访问结构体类型/类内部数据。
3、完成基本四则运算，设置复数实部、虚部等操作。
三、实现提⽰1、抽象数据类型定义抽象数据类型⽤⼀个三元组（D，S，P）表实，其中D表⽰数据对象，S是D上的关系集，P是对数据对象D的基本操作集合。
A、抽象数据类型的定义格式：ADT抽象类型名{数据对象：<数据对象定义>数据关系：<数据关系定义>基本操作：<基本操作定义>}ADT抽象数据类型名B、抽象数据类型中基本操作的定义格式：基本操作名（参数表）初始条件：<初始条件描述>操作结果：<操作结果描述>赋值参数：为操作提供输⼊值；引⽤参数：既可为操作提供输⼊值，还返回操作结果；初始条件：指操纵前数据结构和参数应满⾜的条件。
若不满⾜，操作失败，返回相应错误信息。
初始条件为空，省略之。
操作结果：操作正常完成，数据结构的变化和返回结果。
2、抽象数据类型的复数例ADTComplex{D: {real, imag | e1,e2为实数}R:{<real, imag>}P: void InitialComplex(Complex &x,float r, float i);赋值参数：初始化复数x，实数r，虚部i；操作结果：设置复数x的实部为r，虚部为i；float GetReal(Complex x);赋值参数：复数x操作结果：返回复数x的实部float GetImag(Complex x);赋值参数：复数x操作结果：返回复数x的虚部void SetReal(Complex &x, float real);赋值参数：操作复数x，将为复数x赋值于实部的real；操作结果：复数x的实部被设置为real；void SetImag (Complex &x, float imag);赋值参数：操作复数x，将为复数x赋值于虚部的imag；操作结果：复数x的虚部被设置为imag；Complex add(Complex x, Complex y);赋值参数：所要相加的两个复数x，y操作结果：返回两个复数x和y的和Complex sub(Complex x, Complex y);赋值参数：所要相减的两个复数x，yComplex multi(Complex x, Complex y);赋值参数：所要相称的两个复数x，y操作结果：返回两个复数x和y积Complex expect(Complex x, Complex y);赋值参数：所要相除的两个复数x，y操作结果：返回两个复数x和y商3、复数基本知识复数基本四则运算：①、复数z1与z2的和的定义：z1+z2=（a+bi）+（c+di）=（a+c）+（b+d）i；②、复数z1与z2的差的定义：z1-z2=（a+bi）-（c+di）=（a-c）+（b-d）i；③、复数的乘法运算规则：设z1=a+bi，z2=c+di（a、b、c、d∈R）是任意两个复数，那么它们的积（a+bi）（c+di）=（ac-bd）+（bc+ad）i，其实就是把两个复数相乘，类似两个多项式相乘，在所得的结果中把i2换成-1，并且把实部与虚部分别合并，两个复数的积仍然是⼀个复数。
线性表的实验报告
线性表的实验报告线性表的实验报告概述：线性表是一种常见的数据结构，它是由一组具有相同数据类型的元素组成的序列。
本次实验旨在通过实际操作线性表，掌握线性表的基本操作以及了解其应用场景。
实验目的：1. 理解线性表的概念和基本操作；2. 掌握线性表的顺序存储结构和链式存储结构；3. 熟悉线性表的常见应用场景。
实验材料：1. 计算机；2. 编程软件（如C、C++、Java等）；3. 实验教材或参考资料。
实验步骤：一、线性表的顺序存储结构实验1. 创建一个空的线性表；2. 向线性表中插入若干元素；3. 删除线性表中的某个元素；4. 根据索引查找线性表中的元素；5. 遍历线性表，输出所有元素。
二、线性表的链式存储结构实验1. 创建一个空的链表；2. 向链表中插入若干节点；3. 删除链表中的某个节点；4. 根据节点值查找链表中的节点；5. 遍历链表，输出所有节点。
实验结果：1. 顺序存储结构实验结果：- 成功创建空的线性表；- 成功插入若干元素；- 成功删除某个元素；- 成功根据索引查找元素；- 成功遍历线性表，输出所有元素。
2. 链式存储结构实验结果：- 成功创建空的链表；- 成功插入若干节点；- 成功删除某个节点；- 成功根据节点值查找节点；- 成功遍历链表，输出所有节点。
实验分析：1. 顺序存储结构适用于元素个数固定或变化不大的情况，插入和删除操作需要移动大量元素，效率较低；2. 链式存储结构适用于元素个数不固定的情况，插入和删除操作只需修改指针，效率较高；3. 线性表的应用场景包括但不限于：图书馆图书管理系统中的图书列表、学生信息管理系统中的学生列表等。
实验总结：通过本次实验，我深入了解了线性表的概念、基本操作以及两种常见存储结构。
顺序存储结构适用于元素个数固定的情况，而链式存储结构适用于元素个数不固定的情况。
线性表在实际应用中有着广泛的应用场景，如图书馆管理系统、学生信息管理系统等。
在以后的学习和工作中，我将灵活运用线性表，为解决实际问题提供便利。
数据结构线性表实验报告五篇
数据结构线性表实验报告五篇第一篇：数据结构线性表实验报告实验报告课程名：数据结构实验名：线性表及其操作姓名：班级：学号：撰写时间：2014.09.24一实验目的与要求1.掌握线性表的实现2.掌握线性表的基本操作的实现二实验内容• 分别完成线性表的顺序表示及链式表示• 在两种表示上, 分别实现一些线性表的操作, 至少应该包括–在第i个位置插入一个元素–删除第i个元素–返回线性表长–返回第i个元素的值三实验结果与分析#include #include //---------线性表链式表示-----------struct V//声明一个结构体类型struct V { int value;struct V * next;//定义结构体变量};void PrintLink(struct V*p)//定义一个结构体指针{ while(p!=NULL)//只要指针指向的变量不为NULL；就会一直循环链表指向下一个结构体{printf(“%d, ”,(*p).value);p=(*p).next;//指针指向下一个结构体} printf(“n”);} void Link(){struct V*head;head=(struct V*)malloc(sizeof(struct V));//开辟一个长度为size的内存(*head).value=-100;//表头为-100(*head).next=NULL;printf(“------------线性表链式表示------------n”);int i,n=10;struct V*p=head;printf(“10个数据:n”);for(i=0;i(*p).next=(struct V*)malloc(sizeof(struct V));p=(*p).next;(*p).value=2*i;(*p).next=NULL;} PrintLink(head);//调用PrintLink函数printf(“删除第四个数据:n”);int k=4;p=head;for(i=1;ip=(*p).next;} struct V*temp=(*p).next;//k表示插入和删除的位置(*p).next=(*temp).next;free(temp);PrintLink(head);printf(“插入第十个数据:n”);k=10;p=head;for(i=1;ip=(*p).next;} temp=(*p).next;(*p).next=(struct V*)malloc(sizeof(struct V));(*(*p).next).value=-99;(*(*p).next).next=temp;PrintLink(head);}//---------线性表顺序表示-----------void seq1(){ int i,n=10,k=4;int a[10];//---------输出数组元素------------printf(“-------------线性表顺序表示---------n”);for(i=0;ia[i]=i;} printf(“数组元素为:n”);for(i=0;iprintf(“%3d”,a[i]);} printf(“n”);//--------插入一个数组元素---------int m=n+1,j=12;//插入元素12 int b[20];for(i=0;i if(i{b[i]=a[i];}else if(i==k){b[i]=j;}else{b[i]=a[i-1];} } printf(“输出插入一个元素的数组:n”);for(i=0;i{if(i{c[i]=a[i];}else{c[i]=a[i+1];} } printf(“输出删除一个元素的数组:n”);for(i=0;i printf(“数组元素为:n”);for(i=1;i<=a[0];i++){a[i]=i;} for(i=0;i<2*a[0];i++){printf(“%d,”,a[i]);} printf(“n”);//-----在k 位置插入一个元素------------for(i=a[0];i>=k;i--){a[i+1]=a[i];} a[k]=-100;++a[0];for(i=0;i<2*a[0];i++){printf(“%d,”,a[i]);} printf(“n”);//-------在k---------------for(i=0;i>k;i++){a[i]=a[i+1];} a[k]=-1;a[0]=n;--a[0];for(i=0;i<2*a[0];i++){printf(“%d,”,a[i]);} printf(“n”);} int main(int argc,char *argv[]){ seq1();seq2();Link();return 0;} 图1：实验结果截图实验分析：已在程序中按规定格式标注。
数据结构线性表实验报告
数据结构线性表实验报告一、实验目的本次实验的主要目的是深入理解和掌握数据结构中线性表的基本概念、存储结构和操作算法，并通过实际编程实现来提高对线性表的应用能力和编程技能。
二、实验环境本次实验使用的编程语言为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、判断链表是否为空，检查头节点的指针域是否为空。
线性表实验报告
线性表实验报告实验目的：掌握线性表的基本概念和实现方式，熟悉线性表的各种操作。
实验原理：线性表是由同类型的数据元素构成的有序序列。
在线性表中，除了第一个元素外，每个元素都有且仅有一个直接前驱元素；除了最后一个元素外，每个元素都有且仅有一个直接后继元素。
本实验主要通过C语言的实现，实现了线性表的基本操作，包括初始化、插入、删除、查找等。
实验内容：1.初始化线性表：定义一个长度为n的结构体数组，用于存储线性表的元素，同时设置线性表的长度为0。
2.插入元素：在指定位置pos后插入元素elem，首先判断线性表是否已满，若已满则无法插入；若未满，则将pos后的所有元素往后移动一位，然后将elem插入到pos位置，最后将线性表的长度加1。
3.删除元素：删除指定位置pos的元素，首先判断线性表是否为空或pos是否合法，若为空或pos不合法则无法删除；若合法，则将pos后的所有元素往前移动一位，最后将线性表的长度减1。
4.查找元素：按照元素值查找元素在线性表中的位置，首先判断线性表是否为空，若为空则无法查找；若不为空，则遍历线性表，逐一比较元素值，找到则返回其位置，找不到则返回-1。
5.输出线性表：按顺序输出线性表中的元素值。
实验结果：经过测试，线性表的各种操作均实现了。
可以正确地初始化、插入、删除、查找元素，并成功输出线性表中的元素值。
实验总结：通过本实验，我对线性表的概念和实现方式有了更深入的了解，并通过C语言的实现掌握了线性表的各种操作。
线性表是数据结构中最基本、最简单的一种，但在实际应用中非常广泛。
掌握了线性表的操作，对于理解和应用其他更复杂的数据结构具有重要的意义。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据结构实验报告实验名称：线性表的抽象数据类型的实现计算机与信息学院实验1线性表的抽象数据类型的实现实验目的1.掌握线性表的顺序存储结构和链式存储结构；2.熟练掌握顺序表和链表基本算法的实现；3.掌握利用线性表数据结构解决实际问题的方法和基本技巧；4.按照实验题目要求独立正确地完成实验内容（编写、调试算法程序，提交程序清单及及相关实验数据与运行结果）；5.按时提交实验报告。
实验环境计算机、C语言程序设计环境实验学时2学时，选做实验。
实验内容一、顺序表的基本操作实现实验要求：数据元素类型ElemType取整型int。
按照顺序存储结构实现如下算法（各算法边界条件和返回结果适当给出）：①创建任意整数线性表（即线性表的元素值随机在键盘上输入），长度限定在20之内；②打印（遍历）该线性表（依次打印出表中元素值）；③在线性表中查找第i个元素，并返回其值；④在线性表中第i个元素之前插入一已知元素；⑤在线性表中删除第i个元素；⑥求线性表中所有元素值（整数）之和；实验步骤C源程序代码/*file:seqlist.cpp*/#include<stdio.h>#include<stdlib.h>#include<malloc.h>#define size 20#define elemtype intstruct seqlist{ elemtype elem[size];int last;};void menu(){ printf("\n..........................................");printf("\n0.退出操作................................");printf("\n1.建立数据类型为整形的顺序表（长度小于20).");printf("\n2.打印线性表..............................");printf("\n3.在线性表中查找第i个元素，并返回其值.....");printf("\n4.在线性表中第i个元素之前插入一已知元素...");printf("\n5.在线性表中删除第i个元素.................");printf("\n6.求线性表中所有元素值（整数）之和........");printf("\n7.初始化..................................\n");void ins(seqlist *L){L->last=-1;}void creat(seqlist *L){ int i=0; elemtype j;printf("请输入线性表元素(-1结束):");scanf("%d",&j);while(j!=-1){ L->elem[i++]=j; L->last++;if(i>size-1) break;scanf("%d",&j);}}void print(seqlist *L){ int i;printf("顺序表中元素为:");for(i=0;i<=L->last;i++)printf("%d\t",L->elem[i]);}int find(seqlist *L,int i){ if(i<1||i>L->last+1) return 0;else return(L->elem[i-1]);int insert(seqlist *L,int i,int x){ int j;if(L->last+1==size||i<1||i>L->last+2) return 0;L->last++;for(j=L->last;j>=i-1;j--)L->elem[j+1]=L->elem[j];L->elem[i-1]=x;return 1;}int del(seqlist *L,int i){ int e,j;if(L->last==-1||i<1||i>L->last+1)return 0;elsee=L->elem[i-1];for(j=i;j<=L->last+1;j++)L->elem[j-1]=L->elem[j];L->last--; return 1;}int sum(seqlist *L){ int i=0,s=0;if(L->last==-1) return 0;for(i=0;i<=L->last;i++) s+=L->elem[i];return s;}int isempty(seqlist *L){ if(L->last==-1)return 1;else return 0;}void main(){ int i,cz,e; elemtype date; seqlist L;menu();printf("请输入你要执行的操作的序号:");i=scanf("%d",&cz);while(1){ if(!i) printf("只能输入数值");else break;printf("\n再输入一次："); rewind(stdin);i=scanf("%d",&cz);}while(cz){ switch(cz){ case 1:if(isempty(&L)){ ins(&L); c reat(&L); }else printf("表已经存在，先清空再进行此操作！\n");break;case 2:if(isempty(&L))printf("表为空\n");else print(&L);break;case 3:printf("输入待查找元素的位置:\n");scanf("%d",&i);if(find(&L,i))printf("查找的第%d个元素为%d\n",i,find(&L,i));elseprintf("查找位置错误\n");break;case 4:printf("请输入要插入的元素及位置:\n");scanf("%d",&date);scanf("%d",&i);if(insert(&L,i,date))printf("插入元素成功!\n");else printf("插入位置不合法或栈已满!\n");break;case 5:printf("请输入要删除元素的位置\n");scanf("%d",&i);e=L.elem[i-1];if(del(&L,i)){ printf("删除第%d个值为%d的元素\n",i,e);printf("删除成功\n");}Else printf("删除位置不合法或表已空\n");break;case 6:if(isempty(&L))printf("表已空!\n");else printf("线性表中所有元素值（整数）和:%d\n",sum(&L));break;case 7: ins(&L);break;default: printf("无此操作!\n");break;}menu();printf("请输入你要执行的操作的序号:");i=scanf("%d",&cz);while(1){ if(!i) printf("\n只能输入数值");else break;printf("\n再输入一次："); rewind(stdin);i=scanf("%d",&cz);}}}测试数据与实验结果7.初始化1.建表2.打印3.查找4.插入不合法长度超过205.删除然后打印4~.插入合法6.求和二、链表（带头结点）基本操作实验要求：数据元素类型ElemType取字符型char。
按照动态单循环链表结构实现如下算法（各算法边界条件适当给出）：①创建任意字符型有序（递增排序）单循环链表（即链表的字符元素随机在键盘上输入），长度限定在15之内；②打印（遍历）该链表（依次打印出表中元素值）；③在链表中查找第i个元素，i合法返回元素值，否则，返回FALSE；④在链表中查找与一已知字符相同的第一个结点，有则返回TRUE，否则，返回FALSE；⑤在链表中按照有序方式插入一已知字符元素；⑥在线性表中删除第i个结点；⑦计算链表的长度。
实验步骤C源程序代码#include<stdio.h>#include<stdlib.h>#include<malloc.h>#define elemtype char#define size 15static int n=0;typedef struct Node{elemtype data;struct Node * next;}Node,*linklist;void init(linklist *L){*L=(linklist)malloc(sizeof(Node));(*L)->next=*L;n=0;}void creat(linklist L){int i=0,j;Node *s,*r;elemtype c[size],t;r=L->next;printf("请输入字符型元素(最多15个,输入字符'@'结束):");scanf("%s",c);while(c[i]!='@'){n++;i++;}i=0;for(i=0;i<n;i++){for(j=i;j<n-i-1;j++){if(c[j]<c[j+1]){t=c[j];c[j]=c[j+1];c[j+1]=t;}}}for(i=0;i<n;i++){t=c[i];s=(Node *)malloc(sizeof(Node));s->data=t;r->next=s;r=s;}}void length(linklist L){printf("链表长度为:%d",n);}void show(linklist L){int j;Node *p;p=L;if(!p) {printf("表为空!");return;}for(j=0;j<n;j++){printf("%c",p->next->data);p=p->next;}}int isempty(linklist L){Node *pre;pre=L;if(pre->next==L)return 1;return 0;}void find4(linklist L,int i) {int j=0;Node *p;if(i<1||i>size)printf("查找位置错误!");p=L;while(j<i){p=p->next;j++;}if(i=j)printf("%c",p->data);}void find5(linklist L,elemtype k){int i=1,j;Node *p;p=L->next;if(n==0){printf("表为空!\n");return;}for(j=0;j<n;j++){if(p->data!=k)p=p->next;else {printf("第%d个元素是要查找的元素%c",i,k);return;}}printf("链表中无此字符!");}void insert(linklist L,elemtype t) {Node *r,*s;int i=0;r=L;if(n==size){printf("表已满!");return;}for(i;i<n-1&&t<r->next->data;i++) {i++;r=r->next;}s=(Node *)malloc(sizeof(Node));s->data=t;s->next=r->next;r->next=s;printf("插入成功!");n++;return;}void del(linklist L,int i){int j=0;Node *p,*r;if(i<1||i>n) {printf("删除位置不对!");return;} p=L;while(j<i-1){j++;p=p->next;}printf("开始删除");r=p->next;p->next=r->next;free(r);printf("删除成功!");n--;}void menu(){printf(".........................................................................\n ");printf("0.退出程序...............................................................\n");printf("1.初始化单循环链表.......................................................\n");printf("2.创建任意字符型有序（递减排序最长15）单循环链表........................\n");printf("3.打印（遍历）该链表（依次打印出表中元素值）.............................\n");printf("4.在链表中查找第i个元素..................................................\n");printf("5.在链表中查找与一已知字符相同的第一个结点...............................\n");printf("6.在链表中按照有序方式插入一已知字符元素.................................\n");printf("7.在线性表中删除第i个结点................................................\n");printf("8.计算链表的长度.........................................................\n");printf(".........................................................................\n ");}void main(){int cz,i,j,k;char key,t;linklist L;menu();printf("请输入你要执行的操作的序号:");i=scanf("%d",&cz);while(1){if(!i)printf("\n只能输入数值");elsebreak;printf("\n再输入一次：");rewind(stdin);i=scanf("%d",&cz);}while(cz){switch(cz){case 1:init(&L);break;case 2:if(isempty(L))creat(L);elseprintf("表已存在，请先初始化单循环链表!\n");break;case 3:show(L);break;case 4:printf("请输入查找的第i个元素的i值:");j=scanf("%d",&i);while(1){if(!j)printf("\n只能输入数值");elsebreak;printf("\n再输入一次：");rewind(stdin);j=scanf("%d",&cz);}find4(L,i);break;case 5:printf("请输入要查找的字符:");rewind(stdin);scanf("%c",&key);find5(L,key);break;case 6:printf("请输入要插入的字符:");rewind(stdin);scanf("%c",&t);insert(L,t);break;case 7:printf("输入要删除的第i个元素的i值:");scanf("%d",&k);del(L,k);break;case 8:length(L);break;default:printf("无此操作!\n");break;}menu();printf("请输入你要执行的操作的序号:");i=scanf("%d",&cz);while(1){if(!i)printf("\n只能输入数值");elsebreak;printf("\n再输入一次：");rewind(stdin);i=scanf("%d",&cz);}}}测试数据与实验结果。