实验1 线性表的顺序、链式表示及其应用
线性表的基本操作实验报告
实验一:线性表的基本操作【实验目的】学习掌握线性表的顺序存储结构、链式存储结构的设计与操作.对顺序表建立、插入、删除的基本操作，对单链表建立、插入、删除的基本操作算法。
【实验内容】1.顺序表的实践1）建立4个元素的顺序表s=sqlist［］=｛1，2，3，4，5}，实现顺序表建立的基本操作.2) 在sqlist ［]=｛1，2，3,4,5}的元素4和5之间插入一个元素9,实现顺序表插入的基本操作。
3) 在sqlist ［］=｛1,2，3，4，9，5}中删除指定位置(i=5）上的元素9，实现顺序表的删除的基本操作。
2.单链表的实践3.1) 建立一个包括头结点和4个结点的(5，4，2，1）的单链表，实现单链表建立的基本操作。
2）将该单链表的所有元素显示出来。
3) 在已建好的单链表中的指定位置（i=3)插入一个结点3，实现单链表插入的基本操作。
4) 在一个包括头结点和5个结点的（5，4，3，2，1）的单链表的指定位置（如i=2)删除一个结点，实现单链表删除的基本操作。
5) 实现单链表的求表长操作.【实验步骤】1.打开VC++.2.建立工程:点File->New,选Project标签，在列表中选Win32 Console Application，再在右边的框里为工程起好名字，选好路径，点OK-〉finish。
至此工程建立完毕.3.创建源文件或头文件：点File->New，选File标签，在列表里选C++ Source File.给文件起好名字,选好路径，点OK。
至此一个源文件就被添加到了刚创建的工程之中.4．写好代码5．编译－＞链接－＞调试1、#include "stdio。
h”＃include "malloc.h”#define OK 1＃define OVERFLOW -2＃define ERROR 0#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef int ElemType;typedef int Status；typedef struct ｛ElemType *elem;int length;int listsize；} SqList；Status InitList( SqList &L ) {int i，n;L。
实验一 线性表的操作及应用
{
p=p->next;
++j;
}
if ( !p||j>i )
{
printf("参数 i 错或单链表不存在");
return (NULL);
} /*第i个结点不存在*/
return (p);
}
int Insert_LinkList( LinkList H, int i, DataType x)
scanf("%d%d",&n,&m);
for(j=0;j<n;j++)
{
printf("请输入要插入的第%d个元素：",j+1);
scanf("%d",&x);
y=Insert_LinkList( L,m,x);
if(y==1)
{
y=0;
printf("成功插入第%d个元素。\n",j+1);
}
}
代码：
#include <stdio.h>
#include <malloc.h>
typedef int DataType;
typedef struct node{
DataType data; /*每个元素数据信息*/
struct node *next; /*存放后继元素的地址*/
} LNode, *LinkList;
y=0;
/*（将单链表逆置，并输出逆置后单链表中的元素）*/
InvertList(L);
y=Print_LinkList(L);
实验一(线性表及其应用)
实验一 线性表及其应用
一、实验目的
线性表的顺序、链式存储结构的定义；以及在顺序、 链式存储结构下基本操作的实现。（4学时） （1）熟练掌握线性表的基本操作在顺序存储和链式存储 上的实现； （2）以线性表的各种操作（建立、插入、删除、遍历等） 的实现为重点；掌握线性表的动态分配顺序存储结构的定 义和基本操作的实现； （3）通过本章实验帮助学生加深对C语言的使用（特别 是函数的参数调用、指针类型的应用和链表的建立等各种 基本操作）。
安徽工程大学计算机与信息学院电子教案
实验一 线性表及其应用
四、调试与测试
1、主要是逻辑错误的调试过程记录（说明出错现象和分 析原因以及解决的办法，错误直接用红色的笔在详细设计 上改正） 2、测试过程的设计和所使用的测试数据及测试结果
安徽工程大学计算机与信息学院电子教案
实验一 线性表及其应用
五、实验小结
本次实验的收获和心得，通过本次实验掌握理论知识 的情况。
安徽工程大学计算机与信息学院电子教案
实验一 线性表及其应用
六、附录
1、源程序清单： 2、主要的测试界面 （可以省略，在所有实验做完后提交电子版）
安徽工程大学计算机与信息学院电子教案
实验一 线性表及其应用
三、系统设计
1、涉及的数据结构逻辑结构的描述 2、涉及的数据结构存储结构的C语言定义 3、每个操作算法的流程图 4 、每个操作算法的详细设计（必须说明算法函数的功能， 入口参数、出口参数以及算法关键语句的注释）并注明算 法的时间复杂度 5 、主函数main的详细设计 6、程序结构图（功能模块与在主程序中的调用关系图）
安徽工程大学计算机与信息学院电子教案
实验一 线性表及其应用来自二、需求分析1、分别定义数据元素为整型的线性结构的顺序存储方式 和链式存储方式。 2、在每种存储结构下实现下面的操作： （1）创建初始化一个空线性表； （2）销毁线性表； （3）在线性表插入一个元素； （4）在线性表中删除一个元素； （5）求线性表的长度； （6）按序号检索查找线性表； （7）按元素值检索查找线性表； （8）按序号检索查找线性表； （9）遍历线性表。 3、利用线性表实现两个有序线性表的合并操作（选做）
数据结构实验报告1线性表的顺序存储结构
数据结构实验报告1线性表的顺序存储结构数据结构实验报告1线性表的顺序存储结构第一章引言线性表是计算机中最常见的数据结构之一，它是一种有序的数据元素集合，其中的数据元素之间具有一对一的关系。
线性表的存储结构有多种方式，其中顺序存储结构是最简单的一种，它使用一段连续的存储单元来存储线性表中的元素。
第二章顺序存储结构的定义顺序存储结构是将线性表中的元素按照其逻辑顺序依次存储在一块连续的存储空间中。
顺序存储结构的特点是可以快速地访问任意位置的元素，但插入和删除操作需要移动大量的元素。
第三章顺序存储结构的实现1.存储空间的分配顺序存储结构通常使用数组来实现，数组的长度应该大于等于线性表的长度，以防止溢出。
存储空间的分配可以使用静态分配或动态分配两种方式来实现。
2.线性表的初始化初始化线性表时，需要设置线性表的长度和当前元素的个数。
3.线性表的增删改查操作●插入操作：________在指定位置插入一个元素时，需要将插入位置之后的元素依次后移，给待插入的元素腾出位置。
●删除操作：________删除指定位置的元素时，需要将删除位置之后的元素依次前移，覆盖删除位置上的元素。
●修改操作：________修改指定位置的元素时，直接对该位置上的元素进行修改即可。
●查找操作：________根据指定的元素值，查找其在顺序存储结构中的位置。
4.线性表的遍历操作遍历操作可以按照顺序访问线性表中的每个元素，可以使用循环结构实现遍历操作。
第四章顺序存储结构的优缺点分析1.优点：________可以快速地访问任意位置的元素，节省存储空间。
2.缺点：________插入和删除操作需要移动大量的元素，不适用于频繁插入和删除的场景。
第五章实验过程和结果分析在本次实验中，我们以顺序存储结构为基础，实现了线性表的增删改查操作，并进行了遍历操作。
通过实验，我们发现顺序存储结构在查询操作上有较好的性能，但在插入和删除操作上的性能较差。
第六章附件本文档涉及的附件详见附件文件。
数据结构实验报告线性表
数据结构实验报告线性表数据结构实验报告：线性表引言数据结构是计算机科学中非常重要的一个概念，它是用来组织和存储数据的一种方式。
线性表是数据结构中最基本的一种，它是由n个数据元素组成的有限序列。
在本次实验中，我们将对线性表进行深入研究，并进行实验验证。
实验目的1. 了解线性表的基本概念和特性2. 掌握线性表的顺序存储结构和链式存储结构3. 熟练掌握线性表的基本操作：插入、删除、查找等4. 通过实验验证线性表的操作和性能实验内容1. 学习线性表的基本概念和特性2. 熟悉线性表的顺序存储结构和链式存储结构3. 实现线性表的基本操作：插入、删除、查找等4. 对线性表的操作进行性能测试和分析实验步骤1. 学习线性表的基本概念和特性，包括线性表的定义、顺序存储结构和链式存储结构等2. 实现线性表的基本操作：插入、删除、查找等3. 设计实验用例，对线性表的操作进行性能测试4. 对实验结果进行分析和总结实验结果1. 实现了线性表的顺序存储结构和链式存储结构2. 实现了线性表的基本操作：插入、删除、查找等3. 对线性表的操作进行了性能测试，并得出了相应的性能数据4. 对实验结果进行了分析和总结，得出了相应的结论结论通过本次实验，我们深入了解了线性表的基本概念和特性，掌握了线性表的顺序存储结构和链式存储结构，熟练掌握了线性表的基本操作，并对线性表的性能进行了测试和分析。
这些都为我们进一步深入学习和应用数据结构打下了坚实的基础。
总结数据结构是计算机科学中非常重要的一部分，线性表作为数据结构中最基本的一种，对我们学习和应用数据结构具有重要的意义。
通过本次实验，我们对线性表有了更深入的了解，并且掌握了相关的操作和性能测试方法，这将为我们今后的学习和应用提供很大的帮助。
数据结构实验一-线性表
数据结构实验⼀-线性表实验⼀线性表⼀、实验⽬的1、深刻理解线性结构的特点，以及在计算机内的两种存储结构。
2、熟练掌握线性表的顺序存储结构和链式存储结构，及其它们的基本操作，重点掌握查找、插⼊和删除等操作。
⼆、实验要求1、认真阅读程序，将未完成的代码补全（红⾊部分）。
2、上机调试，并运⾏程序。
3、保存和截图程序的运⾏结果，并结合程序进⾏分析。
三、实验内容和基本原理1、实验1.1 顺序表的操作利⽤顺序表存储⽅式实现下列功能（见参考程序1）：1）通过键盘输⼊数据建⽴⼀个线性表，并输出该线性表。
如，依次输⼊元素25,21,46,90,12,98。
2）根据屏幕菜单的选择，进⾏数据的插⼊、删除和查找，并在插⼊或删除数据后，再输出线性表。
如，在第2个位置上插⼊元素43，然后输出顺序表。
删除顺序表第4个元素，输出改变的顺序表。
3）在屏幕菜单中选择0，结束程序的运⾏。
基本原理：在顺序表的第i个位置上插⼊⼀个元素时，必须先将线性表的第i个元素之后的所有元素依次后移⼀个位置，以便腾空⼀个位置，在把新元素插⼊到该位置。
当要删除第i个元素时，只需将第i个元素之后的所有元素前移⼀个位置。
程序代码（蓝⾊为补充的语句）：//* * * * * * * * * * * * * * * * * * * * * * * *//*PROGRAM :顺序结构的线性表 *//*CONTENT :建⽴,插⼊,删除,查找 *//*编程语⾔： Visual c++ 6.0 *//* * * * * * * * * * * * * * * * * * * * * *#include#include#define MAXSIZE 20typedef int ElemType; //数据元素的类型typedef struct{ElemType a[MAXSIZE];int length;}SqList; //顺序存储的结构体类型SqList a,b,c;//函数声明void creat_list(SqList *L);void out_list(SqList L);void insert_sq(SqList *L,int i,ElemType e); ElemType delete_sq(SqList *L,int i);int locat_sq(SqList L,ElemType e);//主函数void main(){int i,k,loc;ElemType e,x;char ch;do {printf("\n\n\n");printf("\n 吴肖遥20151681310131");printf("\n 1.建⽴线性表");printf("\n 2.插⼊元素");printf("\n 3.删除元素");printf("\n 4.查找元素");printf("\n 0.结束程序运⾏");printf("\n =====================");printf("\n 请输⼊要执⾏的操作: ");scanf("%d",&k);switch(k){case 1:{creat_list(&a);out_list(a);}break;case 2:{printf("\n请输⼊插⼊位置： ",a.length+1); scanf("%d",&i);printf("请输⼊要插⼊的元素值： ");scanf("%d",&e);insert_sq(&a,i,e);out_list(a);}break;case 3:{printf("\n请输⼊要删除元素的位置： ",a.length); scanf("%d",&i);x=delete_sq(&a,i);out_list(a);if(x!=-1)printf("\n删除的元素为：%d\n",x);else printf("要删除的元素不存在！");}break;case 4:{printf("\n请输⼊要查找的元素值：");scanf("%d",&e);loc=locat_sq(a,e);if(loc==-1)printf("\n未找到指定元素！");elseprintf("\n已找到，元素的位置是: %d ",loc);}break;}/*switch*/}while(k!=0);printf("\n 按回车键，返回...\n");ch=getchar();}/*main*///建⽴线性表void creat_list(SqList *L){int i;printf("请输⼊线性表的长度: ");scanf("%d",&L->length);for(i=0;ilength;i++){printf("数据 %d =",i);scanf("%d",&(L->a[i]));}}//输出线性表void out_list(SqList L){int i;for(i=0;i<=L.length-1;i++)printf("%10d",L.a[i]);}//在线性表的第i个位置插⼊元素evoid insert_sq(SqList *L,int i,ElemType e){int j;if(L->length==MAXSIZE)printf("线性表已满!\n");else {if(i<1||i>L->length+1)printf("输⼊位置错!\n");else {for(j=L->length-1;j>=i-1;j--)L->a[j+1]=L->a[j];L->a[j+1]=e;/*将未完成的代码补全,提⽰：此处添加⼀条语句，将被删除的元素值赋给e*/ L->length++;}}}//删除第i个元素，返回其值ElemType delete_sq(SqList *L,int i){ElemType x;int j;if(L->length==0)printf("空表!\n");else if(i<1||i>L->length){printf("输⼊位置错！\n");x=-1;}else{x=L->a[i-1];for(j=i;j<=L->length-1;j++)L->a[j-1]=L->a[j];/*将未完成的代码补全,提⽰：此处添加⼀条语句，将被删除元素之后的元素左移。
数据结构线性表实验报告
数据结构线性表实验报告数据结构线性表实验报告实验目的：本次实验主要是为了学习和掌握线性表的基本操作和实现方式。
通过实验，我们可以加深对线性表的理解，并能够熟悉线性表的基本操作。
实验设备与环境：本次实验所需的设备包括计算机和编程环境。
我们选择使用C语言来实现线性表的操作，并在Visual Studio Code编程软件中进行编写和调试。
实验内容：1.线性表的定义和基本操作1.1 线性表的定义：线性表是一种有序的数据结构，其中的元素按照一定的顺序存储，可以插入、删除和访问元素。
1.2 线性表的基本操作：1.2.1 初始化线性表：创建一个空的线性表。
1.2.2 判断线性表是否为空：判断线性表是否不含有任何元素。
1.2.3 获取线性表的长度：返回线性表中元素的个数。
1.2.4 在线性表的指定位置插入元素：在线性表的第i个位置插入元素x，原第i个及其之后的元素依次后移。
1.2.5 删除线性表中指定位置的元素：删除线性表中第i个位置的元素，原第i+1个及其之后的元素依次前移。
1.2.6 获取线性表中指定位置的元素：返回线性表中第i个位置的元素的值。
1.2.7 清空线性表：将线性表中的元素全部删除，使其变为空表。
2.线性表的顺序存储结构实现2.1 线性表的顺序存储结构：使用数组来实现线性表的存储方式。
2.2 线性表的顺序存储结构的基本操作：2.2.1 初始化线性表：创建一个指定长度的数组，并将数组中的每个元素初始化为空值。
2.2.2 判断线性表是否为空：判断线性表的长度是否为0。
2.2.3 获取线性表的长度：返回线性表数组的长度。
2.2.4 在线性表的指定位置插入元素：将要插入的元素放入指定位置，并将原位置及其之后的元素依次后移。
2.2.5 删除线性表中指定位置的元素：将指定位置的元素删除，并将原位置之后的元素依次前移。
2.2.6 获取线性表中指定位置的元素：返回指定位置的元素的值。
2.2.7 清空线性表：将线性表数组中的每个元素赋空值。
数据结构实验一：线性表的应用
数据结构实验报告实验一线性表的应用一、实验目的：1．掌握线性表的两种存储结构及实现方式；2．熟练掌握顺序表和链表的建立、插入和删除的算法。
二、实验要求：1．C完成算法设计和程序设计并上机调试通过。
2．撰写实验报告，提供实验结果和数据。
3．写出算法设计小结和心得。
三、实验内容：1．用顺序表表示集合，编写程序以实现集合的交、并、差运算。
2．设带头结点的单链表ha和hb中结点数据域值按从小到大顺序排列，且各自链表内无重复的结点，要求：（1）建立两个按升序排列的单链表ha和hb。
（2）将单链表ha合并到单链表hb中，且归并后的hb链表内无重复的结点，结点值仍保持从小到大顺序排列。
（3）输出合并后单链表hb中每个结点的数据域值。
四、程序源代码：1.#include<stdio.h>#include<stdlib.h>#define LIST_INIT_CAPACITY 100 typedef int ElementType;typedef struct List{ElementType elem[LIST_INIT_CAPACITY]; int nLength;}SqList;void init(struct List*L)//初始化顺序表{if(L)L->nLength=0;}int visit(SqList*L,ElementType e)//遍历顺序表{for(int i=0;i<L->nLength;i++){if(L->elem[i]==e){return 0;break;}elsecontinue;return 1;}}SqList*jiao(SqList*L1,SqList*L2,SqList*L3)//求两个集合的交集{int n=0;for(int i=0;i<L1->nLength;i++){for(int j=0;j<L2->nLength;i++){if(L1->elem[i]==L2->elem[j]){L3->elem[n]=L1->elem[i];n++;}elsecontinue;}}printf("集合的交集：\n");return L3;}SqList*bing(SqList*L1,SqList*L2,SqList*L3)//求两个集合的并集{int j=0;for (int i=0;i<L1->nLength;i++){if (visit(L2,L1->elem[i])){L3->elem[j]=L1->elem[i];L3->nLength++;j++;}elsecontinue;}printf("集合的并集：\n");return L3;}SqList*cha(SqList*L1,SqList*L2,SqList*L3)//求两个集合的差集{int j=0;for(int i=0;i<L1->nLength;i++){if(visit (L2,L1->elem[i])){L3->elem[j]=L1->elem[i];j++;L3->nLength++;}elsecontinue;}printf("集合的差集：\n");return L3;}void show(SqList *list)//显示线性表元素{for (int i=0;i<list->nLength;i++){printf(" %d",list->elem[i]);}printf("\n");}void main(){SqList*list1,*list2,*list3;list1=(SqList*)malloc(sizeof(SqList));list2=(SqList*)malloc(sizeof(SqList));list3=(SqList*)malloc(sizeof(SqList));init(list1);init(list2);init(list3);intstr1[6]={1,2,3,4,5,6},str2[7]={1,3,4,5,7,9,10};for(int i=0;i<6;i++){list1->elem[i]=str1[i];list1->nLength=i+1;}for(i=0;i<7;i++){list2->elem[i]=str2[i];list2->nLength++;}printf("初始集合：\n");show(list1);show(list2);list3=jiao(list1,list2,list3);show(list3);init(list3);list3=bing(list1,list2,list3);show(list3);init(list3);list3=cha(list1,list2,list3);show(list3);}2.#include <stdio.h>#include<stdlib.h>typedef int ElementType;typedef struct ListNode{ElementType data;struct ListNode *next;}sLinkList;sLinkList*create(ElementType i)//创建接点{sLinkList *p;p=(sLinkList*)malloc(sizeof(sLinkList));if(!p)exit(0);elsep->data=i;return p;}void anotherorder(sLinkList*head){sLinkList*P;P=head->next;if(head!=NULL)//头指针不为空{while (P->next!=NULL){sLinkList*q;//p的后继指针sLinkList*t;q=P->next;t=P->next->next;q->next=head->next;head->next=q;P->next=t;}}}void print(sLinkList*head)//输出链表{if(head==NULL){exit(0);}sLinkList*p=head->next;while(p!=NULL){printf("%4d",p->data);p=p->next;}printf("\n");}void hebing(sLinkList *p,sLinkList *q,sLinkList *l)//将两个链表合并{ sLinkList*z;q=q->next;l=l->next;while(q!=NULL&&l!=NULL){if(q->data>l->data){z=create(l->data);p->next=z;z->next=NULL;p=z;l=l->next;}elseif(q->data<l->data){z=create(q->data);p->next=z;z->next=NULL;p=z;q=q->next;}elseif(q->data==l->data){for(int i=0;i<2;i++){z=create(q->data);p->next=z;z->next=NULL;p=z;}q=q->next;l=l->next;}}if(q==NULL){while (l!=NULL){z=create(l->data);p->next=z;z->next=NULL;p=z;l=l->next;}}if(l==NULL){while (q!=NULL){z=create(q->data);p->next=z;z->next=NULL;p=z;q=q->next;}}printf("合并后：\n");}void deletelist(sLinkList*p)//删除多余元素节点{if(p!=NULL)p=p->next;sLinkList*q;//中间指针while (p!=NULL){int i=p->data;sLinkList*head=p;while (head->next!=NULL){if(i==head->next->data){q=head->next;head->next=q->next;free(q);}elsehead=head->next;}p=p->next;}printf("最终结果：\n");}void main(){sLinkList *ha; ha=(sLinkList*)malloc(sizeof(ListNode)); if(ha!=NULL)//判空{ha->next=NULL;ha->data=-1;}sLinkList *p;sLinkList *q=ha;int a[5]={2,4,6,8,10};for (int i=0;i<5;i++){p=create(a[i]);q->next=p;p->next=NULL;q=p;}printf("初始：\n");print(ha);sLinkList *hb;hb=(sLinkList*)malloc(sizeof(ListNode)); if(hb!=NULL)//判空{hb->next=NULL;hb->data=-1;}q=hb;int b[6]={1,4,5,8,9,10};for (i=0;i<6;i++){p=create(b[i]);q->next=p;p->next=NULL;q=p;}print(hb);//构建ha,hbsLinkList *hc;hc=(sLinkList*)malloc(sizeof(ListNode)); hebing(hc,ha,hb);print(hc);deletelist(hc);print(hc);}五、测试结果：1.2.六、小结（包括收获、心得体会、存在的问题及解决问题的方法、建议等）经过这次实验，我对线性表的两种形式顺序表和链表有了进一步的了解，对线性表之间的运算及线性表的简单应用有了更深的体会。
数据结构实验(1)线性表及其应用
计算机系数据结构实验报告（1）实验目的：帮助学生掌握线性表的基本操作在顺序和链表这两种存储结构上的实现，尤以链表的操作和应用作为重点。
问题描述：1、构造一个空的线性表L。
2、在线性表L的第i个元素之前插入新的元素e；3、在线性表L中删除第i个元素，并用e返回其值。
实验要求：1、分别利用顺序和链表存储结构实现线性表的存储，并设计出在不同的存储结构中线性表的基本操作算法。
2、在实验过程中，对相同的操作在不同的存储结构下的时间复杂度和空间复杂度进行分析。
算法分析：由于两种存储结构都用来创建线性结构的数据表，可采用相同的输出模式和整体结构类似的算法，如下：v1.0 可编辑可修改实验内容和过程：顺序存储结构线性表程序清单：//顺序存储结构线性表的插入删除#include <iostream>#include <>using namespace std;# define LISTSIZE 100# define CREMENTSIZE 10typedef char ElemType; //定义数据元素类型为字符型typedef struct {ElemType *elem; //数据元素首地址int len; //当前元素个数int listsize; //当前存储最大容量}SqList;//构造一个空的线性表Lint InitList(SqList &L){=(ElemType *)malloc(LISTSIZE*sizeof(ElemType));if (! exit(-2); //分配空间失败=0;=LISTSIZE;}//在顺序线性表L中第i个位置之前插入新的元素eint ListInsert(SqList &L,int i,ElemType e){if (i<1||i>+1) return -1; //i值不合法if >={ElemType *newelem=(ElemType *)realloc,+CREMENTSIZE)*sizeof(ElemType));//存储空间已满，增加分配if(!newelem) exit (-2); //分配失败=newelem;+=CREMENTSIZE;}ElemType *q=&[i-1]) ;for (ElemType *p=&[]);p>=q;--p) *(p+1)=*p; //插入位置及其后的元素后移 *q=e; ++;return 1;}//在顺序线性表L中删除第i个元素，并用e返回其值int ListDelete(SqList &L,int i,ElemType&e){if (i<1||i> return -1; //i值不合法ElemType *p=&[i-1]);e=*p; ElemType*q=+;for (++p;p<=q+1;++p) *(p-1)=*p; //被删除元素之后的元素前移;return 1;}int main (){SqList L; char e,ch;int i,j,state;InitList(L); //构造线性表printf("请输入原始数据(字符串个数0~99)：L="); //数据初始化gets;for ( j=1;[j-1]!='\0';j++) =j; //获取表长[j]='\0';printf("操作：插入（I）还是删除(D)\n"); //判断进行插入还是删除操作AGAIN:cin>>ch;if(ch=='I'){cout<<"插在第几个元素之前:"; //插入操作cin>>i; cout<<"输入要插入的新元素:";cin>>e;cout<<endl;printf("输入数据：L=(%s) ListInsert(L,%d,%c)",,i,e);state=ListInsert (L,i,e);}else if (ch=='D'){cout<<"删除第几个元素："; //删除操作cin>>i;cout<<endl;printf("输入数据：L=(%s) DeleteList(L,%d,e)",,i);state=ListDelete(L,i,e);}else goto AGAIN; //操作指示符输入错误处理cout<<endl<<"正确结果：";if(state==-1) cout<<"ERROR,";printf("L=(%s) ",; //输出结果if(ch=='D'&&state!=-1) cout<<",e="<<e;}链式存储结构线性表程序清单：// - - - - -单链存储结构线性表的插入删除 - - - - -#include <iostream>#include <>using namespace std;#define null 0typedef char ElemType; //定义数据元素类型为字符型typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkList;int GetElem(LinkList L,int i,ElemType &e) //获取第i个元素的值 {LinkList p;int j;p=L->next; j=1;while(p&&j<i){p=p->next; ++j; //寻找第i个元素}if(!p||j>i) return -1; //寻找失败e=p->data;return 1;}int ListInsert(LinkList &L,int i,ElemType e){//在带头结点的单链线性表L中第i个元素之前插入元素eLinkList p,s; int j;p=L;j=0;while(p&&j<i-1) {p=p->next;++j;}if(!p||j>i-1) return -1;s=(LinkList) malloc( sizeof(LNode));s->data=e;s->next=p->next;p->next=s;return 1;}int ListDelete(LinkList&L,int i,ElemType&e){//在带头结点的单链线性表L中,删除第i个元素，并由e返回其值LinkList p,q; int j;p=L;j=0;while(p->next&&j<i-1){p=p->next;++j;}if(!(p->next)||j>i-1) return -1;q=p->next;p->next=q->next;e=q->data;free(q);return 1;}int newdata(LinkList&L,char *ch){int k;printf("请输入原始数据(字符串个数0~99)：L="); //数据初始化gets(ch);for (k=0;ch[k]!='\0';k++) ListInsert(L,k+1, ch[k]); //将初始化数据插入链表L中cout<<"OK"<<endl;return k; //返回链表中的元素个数}int main (){char *ch;ch=(char *)malloc(100*sizeof(char)); //定义数组用来辅助数据初始化LinkList L; //头指针LNode head; //头结点L=&head; =null;int i,k,state; char e,CH,f;k=newdata(L,ch); //调用函数使链表数据初始化=k; //将元素个数存入头结点的数据域printf("操作：插入（I）还是删除(D)\n"); //判断进行插入还是删除操作AGAIN:cin>>CH;if(CH=='I'){cout<<"插在第几个元素之前:"; //插入操作cin>>i; cout<<"输入要插入的新元素:";cin>>e;cout<<endl;printf("输入数据：L=(%s) ListInsert(L,%d,%c)",ch,i,e);state=ListInsert(L,i,e);++;}else if (CH=='D'){cout<<"删除第几个元素："; //删除操作cin>>i;cout<<endl;printf("输入数据：L=(%s) DeleteList(L,%d,e)",ch,i);state=ListDelete(L,i,e);--;}else goto AGAIN; //操作指示符输入错误处理cout<<endl<<"正确结果：";if(state==-1) cout<<"ERROR,"; //输出结果cout<<"L=(";for(int m=1;>=m;m++) //一一输出数据{GetElem(L,m,f);cout<<f;}cout<<")";if(CH=='D'&&state!=-1) cout<<",e="<<e; //删除操作反馈e }实验结果：由于两个程序的输出模式相同，在此只列一组测试数据：L = () ListInsert (L, 1, 'k')L = (EHIKMOP) ListInsert (L, 9, 't')L = (ABCEHKNPQTU) ListInsert(L, 4, 'u') L = () ListDelete (L, 1, e)L = (DEFILMNORU) ListDelete_Sq(L, 5, e) L = (CD) ListDelete_Sq(L, 1, e)测试过程中所注意到的问题主要还是输出与输入界面的问题，通过灵活使用cout和cin函数来不断改进。
线性表的顺序表示及实现实验报告
ListDelete(&fibo,c,&item);
PrintList(fibo);
}
实验步骤
1、WIN-TC开发环境安装与配置
1)首先在网上下载WIN-TC的版本；
2)下载完成后进行安装，安装路径默认就可以了，一路next就ok了；
3)打开WIN-TC会出现如下界st(SqList fibo)
{
int i;
for(i=0;i<fibo.length;i++) printf("%d\t",fibo.items[i]);
printf("\n");
return 1;
}
main()
{
int i;
int a,b,c;
int data[10];
DataType item;
{
printf("cha ru bu he fa");
return 0;
}
for(i=fibo->length-1;i>=pos-1;i--)
fibo->items[i+1]=fibo->items[i];
fibo->items[pos-1]=item;
fibo->length++;
return 1;
DataType items[LISTSIZE];
int length;
}SqList;
int ListDelete(SqList *fibo,int pos,DataType *item)
{
int i;
if(ListEmpty(*fibo))
线性表的实验报告
线性表的实验报告线性表的实验报告概述：线性表是一种常见的数据结构，它是由一组具有相同数据类型的元素组成的序列。
本次实验旨在通过实际操作线性表，掌握线性表的基本操作以及了解其应用场景。
实验目的：1. 理解线性表的概念和基本操作；2. 掌握线性表的顺序存储结构和链式存储结构；3. 熟悉线性表的常见应用场景。
实验材料：1. 计算机；2. 编程软件（如C、C++、Java等）；3. 实验教材或参考资料。
实验步骤：一、线性表的顺序存储结构实验1. 创建一个空的线性表；2. 向线性表中插入若干元素；3. 删除线性表中的某个元素；4. 根据索引查找线性表中的元素；5. 遍历线性表，输出所有元素。
二、线性表的链式存储结构实验1. 创建一个空的链表；2. 向链表中插入若干节点；3. 删除链表中的某个节点；4. 根据节点值查找链表中的节点；5. 遍历链表，输出所有节点。
实验结果：1. 顺序存储结构实验结果：- 成功创建空的线性表；- 成功插入若干元素；- 成功删除某个元素；- 成功根据索引查找元素；- 成功遍历线性表，输出所有元素。
2. 链式存储结构实验结果：- 成功创建空的链表；- 成功插入若干节点；- 成功删除某个节点；- 成功根据节点值查找节点；- 成功遍历链表，输出所有节点。
实验分析：1. 顺序存储结构适用于元素个数固定或变化不大的情况，插入和删除操作需要移动大量元素，效率较低；2. 链式存储结构适用于元素个数不固定的情况，插入和删除操作只需修改指针，效率较高；3. 线性表的应用场景包括但不限于：图书馆图书管理系统中的图书列表、学生信息管理系统中的学生列表等。
实验总结：通过本次实验，我深入了解了线性表的概念、基本操作以及两种常见存储结构。
顺序存储结构适用于元素个数固定的情况，而链式存储结构适用于元素个数不固定的情况。
线性表在实际应用中有着广泛的应用场景，如图书馆管理系统、学生信息管理系统等。
在以后的学习和工作中，我将灵活运用线性表，为解决实际问题提供便利。
实验一线性表操作实验报告
实验一_线性表操作_实验报告实验一：线性表操作一、实验目的1.理解线性表的基本概念和特点。
2.掌握线性表的基本操作，包括插入、删除、查找等。
3.通过实验，提高动手能力和解决问题的能力。
二、实验原理线性表是一种较为常见的数据结构，它包含零个或多个数据元素，相邻元素之间有前后关系。
线性表具有以下特点：1.元素之间一对一的顺序关系。
2.除第一个元素外，每个元素都有一个直接前驱。
3.除最后一个元素外，每个元素都有一个直接后继。
常见的线性表有数组、链表等。
本实验主要针对链表进行操作。
三、实验步骤1.创建链表：首先创建一个链表，并给链表添加若干个节点。
节点包括数据域和指针域，数据域存储数据，指针域指向下一个节点。
2.插入节点：在链表中插入一个新的节点，可以选择在链表的头部、尾部或中间插入。
3.删除节点：删除链表中的一个指定节点。
4.查找节点：在链表中查找一个指定数据的节点，并返回该节点的位置。
5.遍历链表：从头节点开始，依次访问每个节点的数据。
四、实验结果与分析1.创建链表结果：我们成功地创建了一个链表，每个节点都有数据域和指针域，数据域存储数据，指针域指向下一个节点。
2.插入节点结果：我们成功地在链表的头部、尾部和中间插入了新的节点。
插入操作的时间复杂度为O(1)，因为我们只需要修改指针域即可。
3.删除节点结果：我们成功地删除了链表中的一个指定节点。
删除操作的时间复杂度为O(n)，因为我们可能需要遍历整个链表才能找到要删除的节点。
4.查找节点结果：我们成功地在链表中查找了一个指定数据的节点，并返回了该节点的位置。
查找操作的时间复杂度为O(n)，因为我们可能需要遍历整个链表才能找到要查找的节点。
5.遍历链表结果：我们成功地遍历了整个链表，并访问了每个节点的数据。
遍历操作的时间复杂度为O(n)，因为我们可能需要遍历整个链表。
通过本次实验，我们更加深入地理解了线性表的基本概念和特点，掌握了线性表的基本操作，包括插入、删除、查找等。
数据结构线性表单链表实验报告
数据结构实验报告班级姓名同组者/ 成绩日期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、题目分别创建两个有序的顺序表（每个表的元素个数及每个元素的值在运行时由键盘输入），现将两个有序表合并，并保证新表依然为有序的顺序表。
线性表 链表实验报告-链表线性表
[线性表链表实验报告]链表线性表实验一：线性表运算的实现班级姓名学号一、实验预备知识1复习C++中编写函数的相关内容。
2复习如何用主函数将多个函数连在一起构成一个C++完整程序。
二、实验目的1掌握线性表的顺序和链式存储结构2熟练运用线性表在顺序存储方式下的初始化、创建、输出、插入和删除运算3熟练运用线性表在链式存储方式下的创建、输出、插入和删除运算三、实验要求1编写初始化并创建线性表和输出线性表的算法。
2编写对线性表插入和删除运算算法，要判断位置的合法性和溢出问题。
3编写一个主函数，将上面函数连在一起，构成一个完整的程序。
4将实验源程序调试并运行，写出输入、输出结果，并对结果进行分析。
四、实验步骤◇顺序表实验内容：1．给定的线性表为L=（12，25，7，42，19，38），元素由键盘输入。
2．初始化并建立顺序表。
3．编写顺序表输出算法。
（内存中开辟的单元数为8）4．依次插入3，21，15三个数，分别插入在第4，6和2位置，每插入一次都要输出一次顺序表。
5．删除第5，第3和第12个位置上的元素，每删除一个元素都要输出一次顺序表。
◇单链表实验内容：1．给定的线性表为L=（12，25，7，42，19，38），元素由键盘输入。
2．建立一个带表头结点的单链表（前插入法和尾插入法都可以）。
3．编写单链表输出算法。
4．依次插入3，21，15三个数，分别插入在第4，6和12位置，每插入一次都要输出一次单链表。
5．删除第5，第3和第12个位置上的元素，每删除一个元素都要输出一次单链表。
五、实验程序◇顺序表实验//LinkList.h#defineMAXSIZE8typedefintDataType;typedefstruct{DataTypedata[MAXSIZE];intlast;}Seqlist;voidcreat_seqlist(Seqlists);voiddisplay_seqlist(Seqlists);intinsert_seqlist(Seqlists,inti,DataTypex);intdelet_seqlist(Seqlists,inti);//LinkList.cpp#include#include”Seqlist.h”voidcreat_seqlist(Seqlists){intx,i=0;coutcinx;while(x!=-1){s.data[i]=x;cinx;i++;}st=i-1;}voiddisplay_seqlist(Seqlists){inti;coutfor(i=0;icoutcout}intinsert_seqlist(Seqlists,inti,DataTypex){intj;if(st==MAXSIZE-1){}st+2){cout=i-1;j--)s.data[j+1]=s.data[j];s.data[i-1]=x;st ++;return1;intdelet_seqlist(Seqlists,inti){intj;if(st+1){coutreturn-1;}for(j=i;js.data[j-1]=s.data[j];st--;return1;}//main.cpp#include#include”Seqlist.h”intmain(){intx,d,s;Seqlists_list;creat_seqlist(s_list);coutd;coutx;s=insert_seqlist(s_list,d,x);if(s==1){coutd;s=delet_seqli st(s_list,d);}if(s==1){cout运行结果:请输入数据（以输入-1结束）12257421938-1顺序表为：12257421938插入操作请输入插入的位置:4请输入要插入的数据：3插入后的顺序表为：122573421938请输入插入的位置:6请输入要插入的数据：21插入后的顺序表为：12257342211938请输入插入的位置:2请输入要插入的数据：15表满！删除操作请输入删除元素的位置：5删除后的顺序表为：122573211938请输入删除元素的位置：3删除后的顺序表为：12253211938请输入删除元素的位置：12不存在该元素！Pressanykeytocontinue◇单链表实验//LinkList.htypedefintDataType;typedefstructNode{DataTypedata;structNode*next;}LNode,*LinkList;voidCreat_LinkList(LinkListL);//创建链表voidShow_LinkList(LinkListL);//显示数据LNode*Get_LinkList(LinkListL,inti);//获得第i个结点的地址intInsert_linklist(LinkListL,inti,DataTypex);//插入结点intDelete_LinkList(LinkListL,inti);//删除结点//LinkList.cpp#include#include”LinkList.h”voidCreat_LinkList(LinkListL){LNode*s;L=NULL;s=newLNode;s-next=L;L=s;intx;}//头插法创建带头结点的链表coutx;while(x!=-1){s=newLNode;s-next=L;L-data=x;L=s;cinx;} voidShow_LinkList(LinkListL){LNode*p;p=L-next;while(p!=NULL){coutdatap=p-next;//显示数据}cout}LNode*Get_LinkList(LinkListL,inti){intj=1;LNode*q;q=L-next;while(q!=NULLjq=q-next;j++;}returnq;}//获得第i个结点的地址intInsert_LinkList(LinkListL,inti,DataTypex)//插入结点{ LNode*p,*s;p=Get_LinkList(L,i-1);if(p==NULL){}coutdata=x;s-next=p-next;p-next=s;return1;}intDelete_LinkList(LinkListL,inti){LNode*p,*s;p=Get_LinkList(L,i-1);if(p==NULL){//删除结点coutnext==NULL){coutreturn0;}else{s=p-next;p-next=s-next;deletes;return1;}}//main.cpp#include#include”LinkList.h”intmain(){intx,d,s;LinkListH;Creat_LinkList(H);Show_LinkList(H);}coutd;coutx;s=Insert_LinkList(H,d,x);if(s==1){coutd;s=Delete_Lin kList(H,d);if(s==1){cout运行结果：请输入数据（以输入-1结束）12257421938-1单链表为：38194272512插入操作请输入插入的位置:4请输入要插入的数据：3插入后的单链表为：381942372512请输入插入的位置:6请输入要插入的数据：21插入后的单链表为： 38194237212512请输入插入的位置:12请输入要插入的数据：15插入位置错误!删除操作请输入删除元素的位置：5删除后的单链表为：3819423212512请输入删除元素的位置：3删除后的单链表为：38193212512 请输入删除元素的位置：12插入位置的前驱结点不存在!。
线性表实验报告
LinkList p;
p=L->next;
while(p){
printf("%5d",p->data);
p=p->next;
}
return OK;
}
void main()
{
int i,n,k,d,e;
LinkList La,Lb;
InitList_L(La);
InitList_L(Lb);
e=L.elem[i];
for(j=i;j<=L.length;j++)
L.elem[j]=L.elem[j+1];
L.length--;
return ok;
}
int output(sqlist &L){
int i;
printf("output sqlist data:\n");
for(i=0;i<L.length;i++)
PrintList(La);
printf("\nAfter delete the list is:\n");
ListDelete_L(La,e);
PrintList(La);
printf("\n");
printf("I will insert:");
scanf("%d",&k);
ListInsert_L(La,k);
int a,j,i,m;
CLinkList p,r;
printf("Input the m(m<=20):\nm=");
scanf("%d",&m);
数据结构线性表实验报告
数据结构线性表实验报告一、实验目的本次实验的主要目的是深入理解和掌握数据结构中线性表的基本概念、存储结构和操作算法，并通过实际编程实现来提高对线性表的应用能力和编程技能。
二、实验环境本次实验使用的编程语言为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、判断链表是否为空，检查头节点的指针域是否为空。
实验一 线性表的操作及应用
2、实验要求： (1) 给出程序设计的基本思想、原理和算法描述。 (2) 源程序给出注释。 (3) 记录程序的运行结果，并结合程序进行分析。
3、实验内容
约瑟夫问题的实现：设有n个人围坐在圆桌周围， 现从某个位置m（1≤m≤n）上的人开始报数，报数 到k的人就站出来。下一个人，即原来的第k+1个位 置上的人，又从1开始报数，再报数到k的人站出来。 依此重复下去，直到全部的人都站出来为止。试设 计一个程序求出出列序列。
6、测试数据
（1）围坐在圆桌周围的人数n=7，第一次开始报数人 的位置m=3，希望报数到第2个数的人出列，则出 列的顺序如下：4 6 1 3 7 5 2； （2）围坐在圆桌周围的人数n=13，第一次开始报数 人的位置m=5，希望报数到第6个数的人出列，则 出列的顺序如下：10 3 9 4 12 7 5 2 6 11 8 1 13； （3）围坐在圆桌周围的人数n=21，第一次开始报数 人的位置m=3，希望报数到第9个数的人出列，则 出列的顺序如下：11 20 8 18 7 19 10 2 15 9 4 1 21 3 6 14 12 13 5 16 17。
4、实验步骤
（1）理解循环链表的基本实验原理；
（2）仔细分析实验内容，给出其算法和流程图； （3）用C或C++语言实现该算法； （4）给出测试数据，并分析其结果； （5）在实验报告册上写出实验过程。
5、实验帮助
（1）这是一个使用循环链表的经典问题。因为要不断地出列， 采用链表的存储形式能更好地模拟出列的情况。 （2）可以建立一个不带头结点的循环链表，其中的n个人用n 个结点来表示。结点结构表示如下： Typedef int Elemtype; Typedef struct Cnode { Elemtype data; struct Cnode *next; }CNode; （3）在本实验中，每次找出需出列结点，要经过k次循环移动 定位指针，全部结点出列，需经过n个k次循环，因此，时 间复杂度为O（k*n）。
实验一 线性表的顺序07
实验一线性表的顺序、链式表示及其应用一、实验目的1. 掌握线性表的顺序存储结构，熟练掌握顺序表基本算法的实现2. 掌握线性表的链式存储结构，熟练掌握单链表基本算法的实现3. 掌握利用线性表数据结构解决实际问题的方法和基本技巧二、实验内容和要求1.编写一个程序test1-1.cpp，实现顺序表的各种基本运算，本实验的顺序表元素的类型为char，完成如下实验要求：（1）初始化顺序表L（2）采用尾插法依次插入a、b、c、d、e（3）输出顺序表L（4）输出顺序表L的长度（5）判断顺序表L是否为空（6）输出顺序表的第3个元素（7）输出元素a的逻辑位置（8）在第4个元素位置上插入元素f（9）输出顺序表L（10）删除L的第3个元素（11）输出顺序表L（12）释放顺序表L#include<stdio.h>#include<stdlib.h>#define MaxSize 60typedefstruct{char data[MaxSize];int length;}SqList;void CreatList_Sq(SqList *&L,char a[],int n){int i;L=(SqList *)malloc(sizeof(SqList));for(i=0;i<n;i++)L->data[i]=a[i];L->length=n;}void ListTraverse_Sq(SqList *&L){int i;for(i=0;i<L->length;i++)printf("%c",L->data[i]);printf("\n");}int ListLength_Sq1(SqList *L){return(L->length);}int LisEmpty_Sq(SqList * L){return(L->length==0);}char a_Sq(SqList *&L,int n){printf("%c\n",L->data[n-1]);return 0;}int b(SqList *&L){int i=1;for(i=0;i<5;i++){if('a'==L->data[i])printf("%d",i+1);elseprintf(" ");}return 0;}bool ListIntsert_Sq(SqList *&L,int i,char e) {int j;if(i<1||i>L->length+1)returnfalse;i--;for(j=L->length;j>i;j--)L->data[j]=L->data[j-1];L->data[j-1]=e;L->length++;returntrue;}bool ListDelete_Sq(SqList *&L,int i,char&e) {int j;if((i<1)||(i>L->length))returnfalse;i--;e=L->data[i];for(j=i;j<L->length-1;j++)L->data[j]=L->data[j+1];L->length--;returntrue;}void DestroyList_Sq(SqList *&L){free(L);}void main(){char a[5]={'a','b','c','d','e'};SqList *Sq;CreatList_Sq(Sq,a,5);ListTraverse_Sq(Sq);LisEmpty_Sq(Sq);ListLength_Sq1(Sq);int n=3;a_Sq(Sq,n);b(Sq);char e='f';ListIntsert_Sq(Sq,4,e);ListTraverse_Sq(Sq);/*ListDelete_Sq(Sq,3,&e);*/ListTraverse_Sq(Sq);DestroyList_Sq(Sq);}2.编写一个程序test1-2.cpp，实现单链表的各种基本运算，本实验的单链表元素的类型为char，完成如下实验要求：（1）初始化单链表h（2）采用尾插法依次插入a、b、c、d、e（3）输出单链表h（4）输出单链表h的长度（5）判断单链表h是否为空（6）输出单链表h的第3个元素（7）输出元素a的逻辑位置（8）在第4个元素位置上插入元素f（9）输出单链表h（10）删除单链表h的第3个元素（11）输出单链表h（12）释放单链表h#include<stdio.h>#include<stdlib.h>typedefstructlnode{char data;structlnode *next;}linklist;void initlist_l(linklist *&l){l=(linklist *)malloc(sizeof(linklist));l->next=NULL;}void createlistr_l(linklist *&l,char a[],int n) {linklist *s, *r;inti;l=(linklist *)malloc(sizeof(linklist));r=l;for(i=0;i<n;i++){s=(linklist *)malloc(sizeof(linklist));s->data=a[i];r->next=s;r=s;}r->next=NULL;}void shuchu_l(linklist *head){linklist *temp;temp=head;while(temp!=NULL){printf("%2d",temp->data);temp=temp->next;}printf("\n");}intlinklist_l(linklist *l){linklist *p=l;int n;while(p->next!=NULL){n++;p=p->next;}return n;}bool listempty_l(linklist *&l){return(l->next==NULL);}char getelem(linklist *l,inti){int j=0;linklist *p=l;while(j<i&& p!=null){j++;p=p->next;}if(p==null){return '!';}else{return p->data;}}bool linklist_l(linklist *&l,inti,char e){linklist *p=l,*s;int j=0;if(i<1)return false;while(p!=NULL&&j<i-1){j++;p=p->next;}if(p==NULL)return false;else{s=(linklist *)malloc(sizeof(linklist));s->data=e;s->next=p->next;p->next=s;return true;}}bool listdelete_l(linklist *&l,inti,char&e) {linklist *p=l,*q;int j=0;if(i<1)return false;while(p!NULL&&j<i-1){j++;p=p->next;}if(p==null)return false;else{s=(linklist*)malloc(sizeof(linklist));s=->data=e;s->next=p->next;return true;}}bool listdelete_l(linklist *&l,inti,char&e) {linklist *p=l,*q;int j=0;if (i<1)return false;while(p!NULL&&j<i-1){j++;p=p->next;}if(p==null)return false;else{q=p->next;if(q==null)return false;e=q->data;p->next=q->next;free(q);return true;}}void destroylist_l(linklist *&l){linklist *pre=l,*l->next;while(p!=null){free(pre);pre=p;p=pre->next;}free(pre)}void main(){char a[5]={'a','b','c','d','e'};int w=3;lintlist *l;createlistr_l(l,a,5);shuchu_l(l);linklist_l(l);listempty_l(l);getelem(l,w);linklist_l(l,4,e);listdelete_l(l,3,e);shuchu_l(l);destroylist_l(linklist *&l);}3.（选做题目）编写一个程序test1-3.cpp，用单链表存储一元多项式，并实现两个多项式的加运算。
实验1 线性表的顺序表示和实现
实验1 线性表的顺序表示和实现
1．实验目的
（1）熟练掌握线性表的基本操作在顺序存储结构上的实现。
（2）用线性表的操作实现表的合并。
2.实验内容
（1）要求用顺序存储结构实现线性表。
然后实现如下操作：
✧初始化线性表
✧建立一个含n个数据的线性表
✧查找：输入一个数，查找线性表，若有，则输出“查找成功”，否则输出
“无此数”。
✧插入：输入一个数和插入位置，实现插入操作，并显示插入成功。
✧删除：输入一个位置数，删除该位置上的数，并显示删除成功。
（2）线性表的合并，已知两个升序线性表，要求合并成一个新的升序线性表。
3．实验要求
（1）上机前编写实验源程序（要求手写,不允许打印），上机前老师检查，没有预先编写实验程序的同学不允许上实验课，按旷课一次处理。
旷课次数超过2次的同学实验成绩不及格，且没有补考资格。
（2）用一切你能想到的办法解决遇到的问题，培养解决问题的能力。
（3）实验报告（于下次实验时交）
报告内容包括：实验目的、实验内容、实验代码、实验输入输出结果以及实验体会供五部分。
线性表的动态分配顺序存储结构如下：
#define LIST_INIT_SIZE 100;//存储空间初始分配量
#define LISTINCREMENT 10;//存储空间分配增量
typedef struct{
ElemType *elem;//存储空间基址
int length; //当前长度
int listsize;//当前已经分配的存储空间，以sizeof(ElemType)为单位
}SqList;。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验1 线性表的顺序、链式表示及其应用
说明：实验1.1和1.2分开来写实验报告
实验1.1 顺序表的操作及其应用
实验目的
1）掌握线性表的顺序存储结构；
2）熟练掌握顺序表基本算法的实现；
3）掌握利用线性表数据结构解决实际问题的方法和基本技巧；
4）按照实验题目要求独立正确地完成实验内容。
实验环境
1) 硬件：每个学生需配备计算机一台，操作系统：Windows2000/XP；
2) 软件：visual c++6.0；
实验学时
1学时
实验内容
要求：数据元素类型ElemType 取整型int 或者char。
顺序存储实现如下算法：1）创建一顺序表；
2）输出该顺序表；
3）在顺序表中查找第i 个元素，并返回其值；
4）在顺序表中第i 个元素之前插入一已知元素；
5）在顺序表中删除第i 个元素；
6）实现顺序表的合并。
（选做）
参考运行界面：
实验2.2 链表的操作及其应用
实验目的
1）掌握线性表的链式存储结构；
2）熟练掌握链式基本算法的实现；
3）掌握利用线性表数据结构解决实际问题的方法和基本技巧；
4）按照实验题目要求独立正确地完成实验内容。
实验环境
1) 硬件：每个学生需配备计算机一台，操作系统：Windows2000/XP；
2) 软件：visual c++6.0；
实验学时
2学时
实验内容
要求：数据元素类型ElemType 取字符型char 或者int。
按照动态单链表结构实现如下算法：
1）创建单链表；
2）输出该链表；
3）在链表中查找第i 个元素，i 合法返回元素值，否则，返回FALSE；
4）在线性表中删除第i 个结点；
5）两个有序链表的合并；（选做题）
6）一元多项式求和；（选做题）。