下载文档原格式
实验一 线性表的基本操作及其应用一、实验目的1、帮助读者复习C++语言程序设计中的知识。
2、熟悉线性表的逻辑结构。
3、熟悉线性表的基本运算在两种存储结构上的实现。
4、掌握顺序表的存储结构形式及其描述和基本运算的实现。
5、熟练掌握动态链表结构及有关算法的设计二、实验内容求两个多项式的相加运算[问题描述]用单链表存储一元多项式，并实现两个多项式的相加运算。
[基本要求]（1）本程序需要基于线性表的基本操作来实现一元多项式的加法，也可以用数组实现。
；（2）两个多项式都有键盘输入相应的系数和指数[测试数据] 由学生任意指定。
三、源代码#include <stdio.h>#include <malloc.h>#define MAX 20 //多项式最多项数typedef struct //定义存放多项式的数组类型{double coef; //系数int exp; //指数} PolyArray[MAX];typedef struct pnode //定义单链表结点类型{double coef; //系数int exp; //指数struct pnode *next;} PolyNode;void DispPoly(PolyNode *L) //输出多项式{bool first=true; //first为true表示是第一项PolyNode *p=L->next;while (p!=NULL){if (first)first=false;else if (p->coef>0)printf("+");if (p->exp==0)printf("%g",p->coef);else if (p->exp==1)printf("%gx",p->coef);elseprintf("%gx^%d",p->coef,p->exp);p=p->next;}printf("\n");}void DestroyList(PolyNode *&L) //销毁单链表{PolyNode *p=L,*q=p->next;while (q!=NULL){free(p);p=q;q=p->next;}free(p);}void CreateListR(PolyNode *&L,PolyArray a,int n) //尾插法建表{PolyNode *s,*r;int i;L=(PolyNode *)malloc(sizeof(PolyNode)); //创建头结点L->next=NULL;r=L; //r始终指向终端结点,开始时指向头结点for (i=0;i<n;i++){s=(PolyNode *)malloc(sizeof(PolyNode));//创建新结点s->coef=a[i].coef;s->exp=a[i].exp;r->next=s; //将*s插入*r之后r=s;}r->next=NULL; //终端结点next域置为NULL}void Sort(PolyNode *&head) //按exp域递减排序{PolyNode *p=head->next,*q,*r;if (p!=NULL) //若原单链表中有一个或以上的数据结点{r=p->next; //r保存*p结点后继结点的指针 p->next=NULL; //构造只含一个数据结点的有序表 p=r;while (p!=NULL){r=p->next; //r保存*p结点后继结点的指针 q=head;while (q->next!=NULL && q->next->exp>p->exp)q=q->next; //在有序表中找插入*p的前驱结点*qp->next=q->next; //将*p插入到*q之后q->next=p;p=r;}}}void Add(PolyNode *ha,PolyNode *hb,PolyNode *&hc) //求两有序集合的并{PolyNode *pa=ha->next,*pb=hb->next,*s,*tc;double c;hc=(PolyNode *)malloc(sizeof(PolyNode)); //创建头结点tc=hc;while (pa!=NULL && pb!=NULL){if (pa->exp>pb->exp){s=(PolyNode *)malloc(sizeof(PolyNode)); //复制结点s->exp=pa->exp;s->coef=pa->coef;tc->next=s;tc=s;pa=pa->next;}else if (pa->exp<pb->exp){s=(PolyNode *)malloc(sizeof(PolyNode)); //复制结点s->exp=pb->exp;s->coef=pb->coef;tc->next=s;tc=s;pb=pb->next;}else //pa->exp=pb->exp{c=pa->coef+pb->coef;if (c!=0) //系数之和不为0时创建新结点{s=(PolyNode *)malloc(sizeof(PolyNode)); //复制结点s->exp=pa->exp;s->coef=c;tc->next=s;tc=s;}pa=pa->next;pb=pb->next;}}if (pb!=NULL) pa=pb; //复制余下的结点while (pa!=NULL){s=(PolyNode *)malloc(sizeof(PolyNode)); //复制结点 s->exp=pa->exp;s->coef=pa->coef;tc->next=s;tc=s;pa=pa->next;}tc->next=NULL;}void main(){PolyNode *ha,*hb,*hc;PolyArray a={{2.3,0},{-2.8,2},{5.6,3},{-10.9,7},{7.6,10}};PolyArray b={{-1.2,0},{8.6,1},{-13.9,3},{15.5,5},{5.6,9}};CreateListR(ha,a,5);CreateListR(hb,b,5);printf("原多项式A: ");DispPoly(ha);printf("原多项式B: ");DispPoly(hb);Sort(ha);Sort(hb);printf("有序多项式A: ");DispPoly(ha);printf("有序多项式B: ");DispPoly(hb);Add(ha,hb,hc);printf("多项式相加: ");DispPoly(hc);DestroyList(ha);DestroyList(hb);DestroyList(hc);}四、测试结果五、心得体会两个简单的的多项式用相加，编程却需要线性表各种用法显得很复杂。
数据结构线性表试验报告（最终定稿）第一篇：数据结构线性表试验报告线性表上机实习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;ncout<<“请输入线性表数据”<cin>>L.data[n];//顺序将数据存入顺序表}//其他存储与此类似，都是直接赋值与数组的某一位插入版块子函数：void insert(SeqList &L)//插入数据 {int a,b,c,k;cout<<“请输入插入的数及其插入的位置”<cin>>a>>b;if(b<=0||b>(L.n+1)){cout<<“不能在该位置插入”<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;} 顺序表的插入与删除操作类似，在插入与删除后，都要循环调整后面数组的每一位元素，同时记录数据元素的长度的标示符也要跟着改变。
数据结构线性表实验报告数据结构线性表实验报告1.简介本实验报告旨在介绍数据结构中线性表的实现和应用。
线性表是一种重要的数据结构，它的特点是数据元素之间存在一对一的前后关系，且具有唯一的起点和终点。
本实验通过实现线性表的基本操作，加深对线性表的理解，并通过实例应用展示线性表在实际问题中的应用。
2.实验环境本次实验采用的是编程语言C，并搭配使用一些常用的开发工具和库。
具体环境如下：________●操作系统：________Windows 10●编程语言：________C●开发工具：________Visual Studio Code●辅助库：________Stdio.h、stdlib.h、conio.h3.实验内容3.1 线性表的定义和基本操作3.1.1 线性表的定义线性表是由n（n ≥ 0）个数据元素组成的有限序列，数据元素之间存在一对一的前后关系。
3.1.2 线性表的基本操作●初始化线性表：________创建一个空的线性表。
●插入元素：________在指定位置插入一个新的元素。
●删除元素：________删除指定位置的元素。
●查找元素：________根据值或位置查找指定元素。
●修改元素：________根据位置修改指定元素的值。
●清空线性表：________将线性表中的所有元素清空。
3.2 线性表的顺序存储结构3.2.1 顺序存储结构的定义顺序存储结构是指使用一段连续的存储空间，依次存储线性表中的元素。
3.2.2 顺序存储结构的实现●初始化顺序表：________创建一个空的顺序表，并指定最大容量。
续元素依次后移。
●删除元素：________删除指定位置的元素，并将后续元素依次前移。
●查找元素：________根据值或位置查找指定元素，并返回其位置或值。
●修改元素：________根据位置修改指定元素的值。
●清空顺序表：________将顺序表中的所有元素清空。
●扩容：________当顺序表容量不足时，自动进行扩容。
数据结构..实验报告线性表的基本操作数据结构实验报告线性表的基本操作1.引言本实验报告旨在介绍线性表的基本操作。
线性表是一种常见的数据结构，它是一组有限元素的有序集合，其中每个元素之间存在一个特定的顺序关系。
线性表的操作包括插入、删除、查找等，这些操作对于有效地管理和利用数据非常重要。
2.实验目的本实验的目的是通过实践理解线性表的基本操作，包括初始化、插入、删除、查找等。
通过编写相应的代码，加深对线性表的理解，并掌握相应的编程技巧。
3.实验内容3.1 初始化线性表初始化线性表是指创建一个空的线性表，为后续的操作做准备。
初始化线性表的方法有多种，如顺序表和链表等。
下面以顺序表为例进行说明。
顺序表的初始化包括定义表头指针和设置表的长度等操作。
3.2 插入元素插入元素是指将一个新的元素插入到线性表的指定位置。
插入元素有两种情况：插入到表的开头和插入到表的中间。
插入元素的操作包括移动其他元素的位置以腾出空间，并将新的元素插入到指定位置。
3.3 删除元素删除元素是指将线性表中的某个元素删除。
删除元素有两种情况：删除表的开头元素和删除表的中间元素。
删除元素的操作包括将被删除元素的前一个元素与后一个元素进行连接，断开被删除元素与表的联系。
3.4 查找元素查找元素是指在线性表中寻找指定的元素。
查找元素的方法有多种，如遍历线性表、二分查找等。
查找元素的操作包括比较目标元素与线性表中的元素进行匹配，直到找到目标元素或遍历完整个线性表。
4.实验步骤4.1 初始化线性表根据线性表的类型选择相应的初始化方法，如创建一个空的顺序表并设置表的长度。
4.2 插入元素输入要插入的元素值和插入的位置，判断插入的位置是否合法。
如果合法，移动其他元素的位置以腾出空间，将新的元素插入到指定位置。
如果不合法，输出插入位置非法的提示信息。
4.3 删除元素输入要删除的元素值，判断元素是否在线性表中。
如果在，则找到目标元素的前一个元素和后一个元素，进行连接删除操作。
数据结构--实验报告线性表的基本操作数据结构--实验报告线性表的基本操作一、引言本实验报告旨在通过实际操作，掌握线性表的基本操作，包括初始化、插入、删除、查找等。
线性表是最基本的数据结构之一，对于理解和应用其他数据结构具有重要的作用。
二、实验目的1·了解线性表的定义和基本特性。
2·掌握线性表的初始化操作。
3·掌握线性表的插入和删除操作。
4·掌握线性表的查找操作。
5·通过实验巩固和加深对线性表的理解。
三、线性表的基本操作1·初始化线性表线性表的初始化是将一个线性表变量设置为空表的过程。
具体步骤如下：（1）创建一个线性表的数据结构，包括表头指针和数据元素的存储空间。
（2）将表头指针指向一个空的数据元素。
2·插入元素插入元素是向线性表中指定位置插入一个元素的操作。
具体步骤如下：（1）判断线性表是否已满，如果已满则无法插入元素。
（2）判断插入位置是否合法，如果不合法则无法插入元素。
（3）将插入位置及其后面的元素都向后移动一个位置。
（4）将待插入的元素放入插入位置。
3·删除元素删除元素是从线性表中删除指定位置的元素的操作。
具体步骤如下：（1）判断线性表是否为空，如果为空则无法删除元素。
（2）判断删除位置是否合法，如果不合法则无法删除元素。
（3）将删除位置后面的元素都向前移动一个位置。
（4）删除最后一个元素。
4·查找元素查找元素是在线性表中查找指定元素值的操作。
具体步骤如下：（1）从线性表的第一个元素开始，逐个比较每个元素的值，直到找到目标元素或遍历完整个线性表。
（2）如果找到目标元素，则返回该元素的位置。
（3）如果未找到目标元素，则返回找不到的信息。
四、实验步骤1·初始化线性表（1）定义线性表的数据结构，包括表头指针和数据元素的存储空间。
（2）将表头指针指向一个空的数据元素。
2·插入元素（1）判断线性表是否已满。
数据结构--实验报告线性表的基本操作数据结构实验报告[引言]在本次实验中,我们将学习线性表的基本操作,包括插入、删除、查找等。
通过实践操作,加深对线性表的理解和掌握。
[实验目的]1．学习线性表的基本概念和操作。
2.熟悉线性表的插入、删除和查找等基本操作。
3.掌握线性表的实现方式及其相应的算法。
［实验内容]１.线性表的定义与表示1．1 线性表的定义1.2 线性表的顺序存储结构１.3 线性表的链式存储结构2.线性表的基本操作２．１初始化线性表2.２判断线性表是否为空2.3 插入操作２.3.1 在指定位置插入元素2.3.2 在表尾插入元素2．4 删除操作2．4.1 删除指定位置的元素2．４．2 删除指定值的元素2．5 查找操作2.5.1 按位置查找元素2．5.2 按值查找元素２．6 修改操作2．６．１修改指定位置的元素 2.6.2 修改指定值的元素2.7 清空线性表2．8 销毁线性表[实验步骤]1.初始化线性表1.1 创建一个空的线性表对象１.2 初始化线性表的容量和长度2.插入操作2.１在指定位置插入元素2.1.1 检查插入位置的合法性2.1.2 将插入位置后的元素依次后移2.1．３在指定位置插入新元素2.2 在表尾插入元素２.2．1 将表尾指针后移2.2.2 在表尾插入新元素３.删除操作3.1 删除指定位置的元素３.1.1 检查删除位置的合法性3.１．2 将删除位置后的元素依次前移3.1.3 修改线性表的长度3.2 删除指定值的元素3.2.1 查找指定值的元素位置3.２.２调用删除指定位置的元素操作4.查找操作４.1 按位置查找元素4．1．1 检查查找位置的合法性4.1.2 返回指定位置的元素4.2 按值查找元素4.2．1 从头到尾依次查找元素4.2．2 返回第一个匹配到的元素5.修改操作5.１修改指定位置的元素５.１.1 检查修改位置的合法性5.1.２修改指定位置的元素值5.２修改指定值的元素5.2．1 查找指定值的元素位置5．２．２调用修改指定位置的元素操作6.清空线性表6．1 设置线性表长度为07.销毁线性表７.1 释放线性表的内存空间[实验结果]使用线性表进行各种基本操作的测试,并记录操作的结果和运行时间。
数据结构线性表实验报告数据结构线性表实验报告实验目的：本次实验主要是为了学习和掌握线性表的基本操作和实现方式。
通过实验，我们可以加深对线性表的理解，并能够熟悉线性表的基本操作。
实验设备与环境：本次实验所需的设备包括计算机和编程环境。
我们选择使用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.掌握线性表的插入和删除操作。
2.理解线性表的查找和修改元素的方法。
3.熟悉线性表的基本操作在算法中的应用。
3.实验环境本实验使用编程语言/软件名称作为开发环境，具体要求如下：________●操作系统：________操作系统名称和版本●编程语言：________编程语言名称和版本4.实验步骤4.1 初始化线性表在程序中创建一个空的线性表，用于存储元素。
实现方法：________具体的初始化方法和代码示例 4.2 插入元素在线性表中指定位置插入一个新元素。
实现方法：________具体的插入元素方法和代码示例 4.3 删除元素删除线性表中指定位置的元素。
实现方法：________具体的删除元素方法和代码示例 4.4 查找元素在线性表中查找指定元素的位置。
实现方法：________具体的查找元素方法和代码示例 4.5 修改元素修改线性表中指定位置的元素值。
实现方法：________具体的修改元素方法和代码示例5.实验结果在完成上述步骤后，我们得到了一个可以进行插入、删除、查找和修改元素的线性表。
具体操作结果如下：________●插入元素操作结果：________插入元素的具体操作结果●删除元素操作结果：________删除元素的具体操作结果●查找元素操作结果：________查找元素的具体操作结果●修改元素操作结果：________修改元素的具体操作结果6.实验总结通过本次实验，我们深入理解了线性表的基本操作，并且掌握了这些操作的实现方法。
线性表在实际应用中十分常见，熟练掌握线性表的操作对于开发高效的算法和数据结构具有重要意义。
《数据结构》实验报告模板(附实例)---实验一线性表的基本操作实现实验一线性表的基本操作实现及其应用一、实验目的1、熟练掌握线性表的基本操作在两种存储结构上的实现，其中以熟悉各种链表的操作为重点。
2、巩固高级语言程序设计方法与技术，会用线性链表解决简单的实际问题。
二、实验内容√ 1、单链表的表示与操作实现 ( * )2、约瑟夫环问题3、Dr.Kong的艺术品三、实验要求1、按照数据结构实验任务书，提前做好实验预习与准备工作。
2、加“*”题目必做，其他题目任选；多选者并且保质保量完成适当加分。
3、严格按照数据结构实验报告模板和规范，及时完成实验报告。
四、实验步骤（说明：依据实验内容分别说明实验程序中用到的数据类型的定义、主程序的流程以及每个操作（成员函数）的伪码算法、函数实现、程序编码、调试与分析、总结、附流程图与主要代码）㈠、数据结构与核心算法的设计描述（程序中每个模块或函数应加注释，说明函数功能、入口及出口参数）1、单链表的结点类型定义/* 定义DataType为int类型 */typedef int DataType;/* 单链表的结点类型 */typedef struct LNode{ DataType data;struct LNode *next;}LNode,*LinkedList;2、初始化单链表LinkedList LinkedListInit( ){ // 每个模块或函数应加注释，说明函数功能、入口及出口参数 }3、清空单链表void LinkedListClear(LinkedList L){// 每个模块或函数应加注释，说明函数功能、入口及出口参数}4、检查单链表是否为空int LinkedListEmpty(LinkedList L){ …. }5、遍历单链表void LinkedListTraverse(LinkedList L){….}6、求单链表的长度int LinkedListLength(LinkedList L){ …. }7、从单链表表中查找元素LinkedList LinkedListGet(LinkedList L,int i){ //L是带头结点的链表的头指针，返回第 i 个元素 }8、从单链表表中查找与给定元素值相同的元素在链表中的位置LinkedList LinkedListLocate(LinkedList L, DataType x){ …… }9、向单链表中插入元素void LinkedListInsert(LinkedList L,int i,DataType x) { // L 为带头结点的单链表的头指针，本算法// 在链表中第i 个结点之前插入新的元素 x}10、从单链表中删除元素void LinkedListDel(LinkedList L,DataType x){ // 删除以 L 为头指针的单链表中第 i 个结点 }11、用尾插法建立单链表LinkedList LinkedListCreat( ){ …… }㈡、函数调用及主函数设计（可用函数的调用关系图说明）㈢程序调试及运行结果分析㈣实验总结五、主要算法流程图及程序清单1、主要算法流程图：2、程序清单（程序过长，可附主要部分）说明：以后每次实验报告均按此格式书写。
线性表的实验报告线性表的实验报告概述：线性表是一种常见的数据结构，它是由一组具有相同数据类型的元素组成的序列。
本次实验旨在通过实际操作线性表，掌握线性表的基本操作以及了解其应用场景。
实验目的：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：实验结果截图实验分析：已在程序中按规定格式标注。
线性表实验报告导言：线性表是数据结构中最基本也是最常用的一种结构之一。
它以一种线性的方式存储和组织数据，简单而高效。
本实验旨在通过对线性表的实践操作，加深对线性表概念的理解，并掌握其基本操作。
实验目的：1. 了解线性表的基本概念和特点；2. 掌握线性表的基本操作，如插入、删除、查找等；3. 熟悉线性表的顺序存储和链式存储结构；4. 学会通过编程实现线性表的基本操作。
实验内容：本次实验分为两个部分，分别是线性表的顺序存储和链式存储结构。
一、顺序存储结构的线性表操作1. 初始化线性表：定义一个固定大小的数组，用于存储线性表中的元素；2. 插入元素：从表尾开始，逐个向前移动元素，为新元素腾出位置；3. 删除元素：从指定位置开始，逐个向后移动元素，覆盖待删除元素；4. 查找元素：按照线性表的顺序依次比较元素，直到找到目标元素或遍历结束；5. 获取表长度：通过记录插入和删除操作的次数，得到线性表的长度。
二、链式存储结构的线性表操作1. 定义结点：创建一个结点类，包含数据域和指向下一结点的指针；2. 初始化链表：定义一个头指针，将其初始化为 NULL，表示链表为空；3. 插入元素：找到插入位置的前一个结点，将新结点插入到其后面；4. 删除元素：找到待删除结点的前一个结点，将其指针指向待删除结点的下一个结点；5. 查找元素：从链表头部开始遍历，逐个比较结点中的数据，直到找到目标元素或遍历结束；6. 获取表长度：通过遍历链表中的结点，计数来获取表长度。
实验过程：1. 根据实验目的，在 C/C++ 环境下创建一个项目，并命名为"LinearList"；2. 依次完成顺序存储结构和链式存储结构的线性表操作函数的编写；3. 调用这些函数，对线性表进行初始化、插入、删除、查找等操作；4. 验证线性表操作的正确性，并检查函数是否能正确处理各种边界情况；5. 根据实验内容，编写实验报告，记录实验过程和结果。
线性表的基本操作实验报告线性表的基本操作1、需求分析:构建一个顺序表并实现顺序表的一些基本操作，例如创建列表，插入、删除元素，求元素的前驱等功能。
(1) 顺序表中数据元素为整形数字，范围属于int型。
(2) 输出部分操作提示以及功能操作所得到的数据(int型)。
(3) 顺序表建立、删除、插入、查询、判空、判满、查询前后驱等功能。
(4) 测试数据:a)b)2、概要设计:用一个结构定义了一个数组，和数组内容的长度。
主程序使用switch语句对将要进行的操作进行选择，调用各个功能函数。
3、实验源代码如下:#include<iostream>using namespace std;typedef struct{int date[100];int length;}SeqList;SeqList L;SeqList SeqListInit()//初始化顺序表 {cout<<"你定义的顺序表的长度(长度小于)"<<endl;cin>>L.length;cout<<"顺序表里面储存数据为"<<endl;for(int i=0;i<L.length;i++){int a;cin>>a;L.date[i]=a;}return L;}void ListClear()/* 清空顺序表*/{L.length=0;}int ListLength()/* 求顺序表长度*/{cout<<L.length<<endl;return 0;}int ListEmpty()/* 检查顺序表是否为空*/ { if(L.length==0)cout<<"为空"<<endl;elsecout<<"不为空"<<endl;return 0;}int ListFull()/*检查顺序表是否为满*/ { if(L.length==100)cout<<"为满"<<endl;elsecout<<"未满"<<endl;return 0;}void ListTraverse()/* 遍历顺序表*/{for(int i=0;i<L.length;i++)cout<<L.date[i]<<" ";cout<<endl;}int ListGet(int i)/* 从顺序表中查找元素*/ { if(i>=0&&i<L.length)cout<<L.date[i-1]<<endl;return 0;}int ListLocate(int x){for(int i=0;i<L.length;i++)if(L.date[i]==x)cout<<L.date[i];return 0;}void ListInsert(int i, int x){if(i>=0&&i<L.length){for(int m=0;i<=L.length-i;m++)L.date[L.length]=L.date[L.length-1];L.date[i-1]=x;L.length++;}}void ListDelete(int i){if(i>=0&&i<L.length){for(i;i<L.length;i++)L.date[i-1]=L.date[i];L.length--;}}int ListPrior(int e){if(e-2>=0&&e-2<L.length)cout<<L.date[e-2]<<endl;return 0;}int ListNext(int e){if(e>=0&&e<L.length)cout<<L.date[e]<<endl; return 0; }int main(){while(1){int i;cout<<"1初始化顺序表"<<endl;cout<<"2清空顺序"<<endl;cout<<"3求顺序表长度"<<endl;cout<<"4检查顺序表是否为空"<<endl;cout<<"5检查顺序表是否为满"<<endl;cout<<"6遍历顺序表"<<endl;cout<<"7从顺序表中查找元素"<<endl;cout<<"8从顺序表中查找与给定元素值相同的元素的位置"<<endl; cout<<"9向顺序表插入元素"<<endl;cout<<"10从顺序表中删除元素"<<endl;cout<<"11求元素前驱"<<endl;cout<<"12求元素后继"<<endl;cin>>i;switch (i){case 1:SeqListInit();break;case 2:ListClear();break;case 3:ListLength();break;case 4:ListEmpty();break;case 5:ListFull();break;case 6:ListTraverse();break;case 7:{int m;cout<<"请输入查找元素的位置"<<endl; cin>>m;ListGet(m);break;}case 8:{int m;cout<<"请输入查找元素"<<endl; cin>>m;ListLocate(m);break;}case 9:{int x;cout<<"请输入插入的元素"<<endl; cin>>x;ListInsert(i,x);break;}case 10:{int m;cout<<"请输入删除的元素"<<endl; cin>>m;ListDelete(m);break;}case 11:{int m;cout<<"请输入元素的位置"<<endl; cin>>m;ListPrior(m);break;}case 12:{int m;cout<<"请输入元素的位置"<<endl; cin>>m;ListNext(m);break;}default:break;}}}4、a) 遇见形参与实参搞混问题，改形参里面的内容并不影响其原本数据。
数据结构线性表实验报告一、实验目的本次实验的主要目的是深入理解和掌握数据结构中线性表的基本概念、存储结构和操作算法，并通过实际编程实现来提高对线性表的应用能力和编程技能。
二、实验环境本次实验使用的编程语言为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.顺序表的实践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.elem = (ElemType*) malloc (LIST_INIT_SIZE*sizeof (ElemType)); if (!L.elem) return(OVERFLOW);printf("输入元素的个数:");scanf("%d",&n);printf("输入各元素的值:");for(i=0;i<n;i++)scanf("%d",&L.elem[i]);L.length = n;L.listsize = LIST_INIT_SIZE;return OK;}Status ListInsert(SqList &L, int i, ElemType e) {ElemType *newbase,*p,*q;if (i < 1 || i > L.length+1) return ERROR;if (L.length >= L.listsize) {newbase = (ElemType *)realloc(L.elem, (L.listsize+LISTINCREMENT)*sizeof (ElemType));if (!newbase) return(OVERFLOW);L.elem = newbase;L.listsize += LISTINCREMENT;}q = &(L.elem[i-1]);for (p = &(L.elem[L.length-1]); p >= q; --p)*(p+1) = *p;*q = e;++L.length;return OK;}Status ListDelete(SqList &L, int i, ElemType &e) {ElemType *p,*q;if((i < 1) || (i > L.length)) return ERROR;p = &(L.elem[i-1]);e = *p;q = L.elem+L.length-1;for (++p; p <= q; ++p) *(p-1) = *p;--L.length;return OK;}void VisitList(SqList L){ int i;for(i=0;i<L.length;i++)printf("%d\t",L.elem[i]);}void main(){int i,e;SqList L;InitList(L) ;VisitList(L);printf("输入插入位置和值:");scanf("%d,%d",&i,&e);printf("插入元素后，表中的值:"); ListInsert(L,i,e);VisitList(L);printf("输入删除位置:");scanf("%d",&i);printf("删除元素后，表中的值:"); ListDelete(L,i,e);VisitList(L);}2、#include "stdio.h"#include "malloc.h"#define OK 1#define OVERFLOW -2#define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 typedef int ElemType;typedef int Status;typedef struct {ElemType *elem;int length;int listsize;} SqList;Status InitList( SqList &L ) {int i,n;L.elem = (ElemType*) malloc (LIST_INIT_SIZE*sizeof (ElemType)); if (!L.elem) return(OVERFLOW);printf("输入元素的个数:");scanf("%d",&n);printf("输入各元素的值:");for(i=0;i<n;i++)scanf("%d",&L.elem[i]);L.length = n;L.listsize = LIST_INIT_SIZE;return OK;}void VisitList(SqList L){ int i;for(i=0;i<L.length;i++)printf("%d\t",L.elem[i]);}void main(){SqList L;InitList(L) ;VisitList(L);}3、#include "stdio.h"#include "malloc.h"#define OK 1#define OVERFLOW -2#define ERROR 0typedef int Status;typedef int ElemType;typedef struct LNode {ElemType data;struct LNode *next;} LNode,*LinkList;Status ListInsert(LinkList &L,int i,ElemType e){ LinkList p,s;int j;p=L;j=0;while(p&&j<i-1) {p=p->next;++j;}if(!p||j>i) return ERROR;s=(LinkList)malloc(sizeof(LNode));s->data=e;s->next=p->next;p->next=s;return OK;}Status ListDelete(LinkList &L,int i,ElemType &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 ERROR;q=p->next;p->next=q->next;e=q->data;free(q);return OK;}Status CreateList(LinkList &L, int n) {int i;LinkList p;L = (LinkList) malloc (sizeof (LNode));L->next = NULL;printf("输入元素的个数和相应值：");scanf("%d",&n);for (i = n; i > 0; --i) {p = (LinkList) malloc (sizeof (LNode));//生成新结点 scanf("%d",&p->data);//输入指针p指出i=n时所对应的数值 p->next = L->next;L->next = p;}return OK;}void VisitList(LinkList L){LNode *p;p=L->next;while(p){printf("%d\t",p->data);p=p->next;}}void main(){int i,n;LinkList L;ElemType e;CreateList(L,n);VisitList(L);printf("输入插入位置和值:");scanf("%d,%d",&i,&e);printf("插入元素后，表中的值:");ListInsert(L,i,e);VisitList(L);printf("输入删除位置:");scanf("%d",&i);printf("删除元素后，表中的值:");ListDelete(L,i,e);VisitList(L);}【实验心得】今天是本学期的第一次上机实验课，老师先给我们发了本次上机的容以及部分实验代码，因为是第一次接触这门课程，还没有理解这门学科的特点和学习方法，所以同学们都觉得无从下手。
学《数据结构》课程实验报告实验名称：线性表基本操作的实现实验室(中心)：学生信息：专业班级：指导教师：实验完成时间： 2016实验一线性表基本操作的实现一、实验目的1.熟悉C语言的上机环境，进一步掌握C语言的结构特点。
2.掌握线性表的顺序存储结构的定义及C语言实现。
3.掌握线性表的链式存储结构——单链表的定义及C语言实现。
4.掌握线性表在顺序存储结构即顺序表中的各种基本操作。
5.掌握线性表在链式存储结构——单链表中的各种基本操作。
二、实验内容及要求1.顺序线性表的建立、插入、删除及合并。
2.链式线性表的建立、插入、删除及连接。
三、实验设备及软件计算机、Microsoft Visual C++ 6.0软件四、设计方案（算法设计）㈠采用的数据结构本程序顺序表的数据逻辑结构为线性结构，存储结构为顺序存储；链表的数据逻辑结构依然为线性结构，存储结构为链式结构。
㈡设计的主要思路1.建立含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度，顺序表的长度和元素由用户输入；2.利用前面建立的顺序表，对顺序表进行插入、删除及合并操作；3.建立一个带头结点的单链表，结点的值域为整型数据，链表的元素由用户输入；4.对前面建立的链表进行插入、删除及连个链表的连接操作；㈢算法描述1、顺序表void Init(sqlist &);//初始化顺序表BOOL Inse(sqlist &,int,char); //在线性表中插入元素BOOL del(sqlist&,int,char &); //在线性表中删除元素int Loc(sqlist,char); //在线性表中定位元素void print(sqlist); //输出顺序表void combine( sqlist & , sqlist & , sqlist &);//两个线性表的合并2、链表void CreaL(LinkList &,int); //生成一个单链表BOOL LInsert(LinkList &,int,char); //在单链表中插入一个元素BOOL LDele(LinkList &,int,char &); //在单链表中删除一个元素BOOL LFind_key(LinkList,char,int &); //按关键字查找一个元素BOOL LFind_order(LinkList,char &,int); //按序号查找一个元素void LPrint(LinkList); //显示单链表所有元素void LUnion(LinkList &,LinkList &,LinkList &,int); //两个链表的连接五、程序代码1、顺序表#include <stdio.h>#include <conio.h>#define Max 116enum BOOL{False,True};typedef struct{char elem[Max]; //线性表int last; //last指示当前线性表的长度}sqlist;void Init(sqlist &);BOOL Inse(sqlist &,int,char); //在线性表中插入元素BOOL del(sqlist&,int,char &); //在线性表中删除元素int Loc(sqlist,char); //在线性表中定位元素void print(sqlist);void combine( sqlist & , sqlist & , sqlist &);void main(){sqlist L1;sqlist L2;sqlist L3;int loc,S=1;char j,ch;BOOL temp;printf("本程序用来实现顺序结构的线性表。
实验一线性表的基本操作一、实验目的与基本要求1．掌握数据结构中的一些基本概念。
数据、数据项、数据元素、数据类型和数据结构，以及它们之间的关系。
2．了解数据的逻辑结构和数据的存储结构之间的区别与联系；数据的运算与数据的逻辑结构的关系。
3．掌握顺序表和链表的基本操作：插入、删除、查找以及表的合并等运算。
4．掌握运用C语言上机调试线性表的基本方法。
二、实验条件1．硬件：一台微机2．软件：操作系统和C语言系统三、实验方法确定存储结构后，上机调试实现线性表的基本运算。
四、实验内容1．建立顺序表，基本操作包括：初始化，建立一个顺序存储的链表，输出顺序表，判断是否为空，取表中第i个元素，定位函数（返回第一个与x相等的元素位置），插入，删除。
2．建立单链表，基本操作包括：初始化，建立一个链式存储的链表，输出顺序表，判断是否为空，取表中第i个元素，定位函数（返回第一个与x相等的元素位置），插入，删除。
3．假设有两个按数据元素值非递减有序排列的线性表A和B，均以顺序表作为存储结构。
编写算法将A表和B表归并成一个按元素值非递增有序（允许值相同）排列的线性表C。
（可以利用将B中元素插入A中，或新建C表）4．假设有两个按数据元素值非递减有序排列的线性表A和B，均以单链表作为存储结构。
编写算法将A表和B表归并成一个按元素值递减有序（即非递增有序，允许值相同）排列的线性表C。
五、附源程序及算法程序流程图1.源程序（1）源程序(实验要求1和3)#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef struct arr{int * elem;int length;int listsize;}Sqlist;void menu(); //菜单void InitList(Sqlist *p); // 创建线性表void ShowList(Sqlist *p); // 输出顺序线性表void ListDelete(Sqlist *p,int i,int &e); // 在顺序线性表中删除第i个元素，并用e返回其值void ListInsert(Sqlist *p); // 在顺序线性表中第i个元素前插入新元素evoid ListEmpty(Sqlist *p); // 判断L是否为空表void GetList(Sqlist *p,int i,int &e); // 用e返回L中第i个数据元素的值void ListInsert(Sqlist *p,int i,int e);bool compare(int a,int b);void LocateElem(Sqlist *L,int e); // 在顺序线性表L中查找第1个值与e满足compare()d元素的位序void MergeList_L(Sqlist *La,Sqlist *Lb); // 归并void main(){Sqlist La;Sqlist Lb;int n,m,x;menu();scanf("%d",&n);while(n){switch(n){case 0: ; break;case 1:InitList(&La);break;case 2:ListEmpty(&La);break;case 3:printf("请输入插入的位序:\n");scanf("%d",&m);printf("请出入要插入的数:\n");scanf("%d",&x);ListInsert(&La,m,x);break;case 4:printf("请输入删除元素的位序:\n");scanf("%d",&m);ListDelete(&La,m,x);printf("删除的元素为:%d\n",x);break;case 5:printf("请输入要找的与线性表中相等的数:\n");scanf("%d",&m);LocateElem(&La,m);break;case 6:printf("请输入查找的位序:\n");scanf("%d",&m);GetList(&La,m,x);printf("La中第%d个元素的值为%d\n",m,x);break;case 7:ShowList(&La);break;case 8:InitList(&Lb);break;case 9:MergeList_L(&La,&Lb);printf("归并成功!");break;}menu();scanf("%d",&n);}}/*菜单*/void menu(){printf("********************\n\n");printf(" 0.退出\n\n");printf(" 1.创建线性表La\n\n");printf(" 2.判断La是否为空表\n\n");printf(" 3.插入元素(La)\n\n");printf(" 4.删除元素(La)\n\n");printf(" 5.定位元素(La)\n\n");printf(" 6.取元素(La)\n\n");printf(" 7.输出线性表\n\n");printf(" 8.创建线性表Lb\n\n");printf(" 9.归并为一个线性表La\n\n");printf("********************\n\n");}/*创建顺序线性表L*/void InitList(Sqlist *L){int n;int i=0;L->elem=(int *)malloc(LIST_INIT_SIZE*sizeof(int));if(NULL==L->elem)printf("储存分配失败!\n");else{L->length=0;L->listsize=LIST_INIT_SIZE;printf("输入顺序表a:\n");scanf("%d",&n);while(n){L->elem[i]=n;i++;L->length++;L->listsize=L->listsize-4;scanf("%d",&n);}}}/*输出顺序线性表*/void ShowList(Sqlist *p){int i;if(0==p->length)printf("数组为空!\n");elsefor(i=0;i<p->length;i++)printf("%d ",p->elem[i]);printf("\n");}/*判断L是否为空表*/void ListEmpty(Sqlist *p)if(0==p->length)printf("L是空表!\n");elseprintf("L不是空表!\n");}/*在顺序线性表中第i个元素前插入新元素e */void ListInsert(Sqlist *p,int i,int e){int *newbase;int *q1;int *q2;while(i<1||i>p->length+1){printf("您输入的i超出范围!\n请重新输入要插入的位置\n:");scanf("%d",&i);}if(p->length>=p->listsize){newbase=(int *)realloc(p->elem,(p->listsize+LISTINCREMENT)*sizeof(int));if(!newbase)exit(0);else{p->elem=newbase;p->listsize+=LISTINCREMENT;}}q1=&(p->elem[i-1]);for(q2=&(p->elem[p->length-1]);q2>=q1;--q2)*(q2+1)=*q2;*q1=e;++p->length;}/*/在顺序线性表中删除第i个元素，并用e返回其值*/void ListDelete(Sqlist *p,int i,int &e){int *q1,*q2;while(i<1||i>p->length){printf("您输入的i超出范围!请重新输入:");scanf("%d",&i);}q1=&(p->elem[i-1]);e=*q1;q2=p->elem+p->length-1;for(++q1;q1<=q2;++q1)*(q1-1)=*q1;--p->length;}/*对比a与b相等*/bool compare(int a,int b){if(a==b)return 1;elsereturn 0;}/*在顺序线性表L中查找第1个值与e满足compare()d元素的位序*/ void LocateElem(Sqlist *L,int e){int i=1;int *p;p=L->elem;while(i<=L->length && !compare(*p++,e))++i;if(i<=L->length)printf("第1个与e相等的元素的位序为%d\n",i);elseprintf("没有该元素!\n");}/*用e返回L中第i个数据元素的值*/void GetList(Sqlist *p,int i,int &e){Sqlist *p1;p1=p;e=p1->elem[i-1];}/* 已知顺序线性表La和Lb是元素按值非递减排列*//* 把La和Lb归并到La上,La的元素也是按值非递减*/void MergeList_L(Sqlist *La,Sqlist *Lb){int i=0,j=0,k,t;int *newbase;Sqlist *pa,*pb;pa=La;pb=Lb;while(i<pa->length && j<pb->length){if(pa->elem[i] >= pb->elem[j]){if(pa->listsize==0){newbase=(int*)realloc(pa->elem,(pa->listsize+LISTINCREMENT)*sizeof(int));if(!newbase)exit(0);}for(k=pa->length-1; k>=i; k--)pa->elem[k+1]=pa->elem[k];pa->length++;pa->elem[i]=pb->elem[j];i++;j++;}elsei++;}while(j<pb->length){if( pa->listsize < pb->length-j ){newbase=(int*)realloc(pa->elem,(pa->listsize+LISTINCREMENT)*sizeof(int));if(!newbase)exit(0);}for(j;j<pb->length;j++,i++){pa->elem[i]=pb->elem[j];pa->length++;}}for(i=0;i<pa->length/2;i++){t=pa->elem[i];pa->elem[i]=pa->elem[pa->length-i-1];pa->elem[pa->length-i-1]=t;}}（2）源程序(实验要求2和4)#include<stdio.h>#include<malloc.h>#include<stdlib.h>typedef struct LNode{int data;struct LNode *next;}LNode, *LinkList;void menu();LinkList InitList();void ShowList(LinkList L);void ListDelete(LinkList L,int i,int &e);void ListEmpty(LinkList L);void GetList(LinkList L,int i,int &e);void ListInsert(LinkList L,int i,int e);bool compare(int a,int b);void LocateElem(LinkList L,int e);LinkList MergeList_L(LinkList La,LinkList Lb);int total=0;void main(){LinkList La;LinkList Lb;La=(LinkList)malloc(sizeof(struct LNode));La->next=NULL;Lb=(LinkList)malloc(sizeof(struct LNode));Lb->next=NULL;int n;int m;int x;menu();scanf("%d",&n);while(n){switch(n){case 0: ; break;case 1:La->next=InitList();break;case 2:ListEmpty(La);break;case 3:printf("请输入要插入到第几个节点前:\n");scanf("%d",&m);printf("请输入插入的数据:\n");scanf("%d",&x);ListInsert(La,m,x);break;case 4:printf("请输入删除元素的位序:\n");scanf("%d",&m);ListDelete(La,m,x);printf("删除的元素为:%d\n",x);break;case 5:printf("请输入要找的与线性表中相等的数:\n");scanf("%d",&m);LocateElem(La,m);break;case 6:printf("请输入查找的位序:\n");scanf("%d",&m);GetList(La,m,x);printf("La中第%d个元素的值为%d\n",m,x);break;case 7:ShowList(La);break;case 8:Lb->next=InitList();break;case 9:La=MergeList_L(La,Lb);printf("归并成功\n");break;}menu();scanf("%d",&n);}}void menu(){printf("********************\n\n");printf(" 0.退出\n\n");printf(" 1.创建线性表La\n\n");printf(" 2.判断是否为空表\n\n");printf(" 3.插入元素\n\n");printf(" 4.删除元素\n\n");printf(" 5.定位元素\n\n");printf(" 6.取元素\n\n");printf(" 7.输出线性表\n\n");printf(" 8.创建线性表Lb\n\n");printf(" 9.归并两线性表\n\n");printf("********************\n\n");}// 创建链式线性表LLinkList InitList(){int count=0;LinkList pHead=NULL;LinkList pEnd,pNew;pEnd=pNew=(LinkList)malloc(sizeof(struct LNode));printf("请输入数据:\n");scanf("%d",&pNew->data);while(pNew->data){count++;if(count==1){pNew->next=pHead;pEnd=pNew;pHead=pNew;}else{pNew->next=NULL;pEnd->next=pNew;pEnd=pNew;}pNew=(LinkList)malloc(sizeof(struct LNode));printf("请输入数据:\n");scanf("%d",&pNew->data);}free(pNew);total=total+count;return pHead;}// 判断L是否为空表void ListEmpty(LinkList L){if(NULL==L->next)printf("此表为空表!\n");elseprintf("此表不为空表!\n");}// 在链式线性表中第i个元素前插入新元素e void ListInsert(LinkList L,int i,int e){LinkList p;LinkList s;p=L;int j=0;while(p&&j<i-1){p=p->next;++j;}if(!p||j>i-1)printf("不存在您要找的节点!\n");else{s=(LinkList)malloc(sizeof(int));s->data=e;s->next=p->next;p->next=s;printf("插入节点成功!\n");}}// 输出链式线性表void ShowList(LinkList L){LinkList p;p=L->next;if(p==NULL)printf("此表为空表!\n");elsewhile(p){printf("%d ",p->data);p=p->next;}printf("\n");}// 在链式线性表中删除第i个元素，并用e返回其值void ListDelete(LinkList L,int i,int &e){LinkList p;LinkList q;p=L;int j=0;while(p->next && j<i-1){p=p->next;++j;}if(!(p->next)||j>i-1)printf("没有找到要删除的位置!");else{q=p->next;p->next=q->next;e=q->data;free(q);}}// 用e返回L中第i个数据元素的值void GetList(LinkList L,int i,int &e){LinkList p;p=L->next;int j=0;while(p->next && j<i-1){p=p->next;++j;}if(!(p)||j>i-1)printf("没有找到要查找的位置!");elsee=p->data;}// 对比a与b相等bool compare(int a,int b){if(a==b)return 1;elsereturn 0;}// 在链式线性表L中查找第1个值与e满足compare()d元素的位序void LocateElem(LinkList L,int e){int i=0;LinkList p;p=L;while(p->next && !compare(p->data,e)){p=p->next;i++;}if(NULL==p->next){if(0==compare(p->data,e))printf("没有该元素!\n");elseprintf("第1个与e相等的元素的位序为%d\n",i);}elseif(compare(p->data,e))printf("没有该元素!\n");}LinkList MergeList_L(LinkList La,LinkList Lb){int i,j,k;LinkList pa_1,pb_1,pa_2,pb_2,pc,pd;pa_1=La->next;pc=pa_2=La;pb_1=pb_2=Lb->next;if(pa_1->data > pb_1->data){pc=pa_2=Lb;pa_1=Lb->next;pb_1=pb_2=La->next;}while(pa_1 && pb_1){if(pa_1->data >= pb_1->data){pa_2->next=pb_1;pb_2=pb_1->next;pb_1->next=pa_1;pb_1=pb_2;pa_2=pa_2->next;}else{pa_1=pa_1->next;pa_2=pa_2->next;}}if(pb_1)pa_2->next=pb_1;pd=(LinkList)malloc(sizeof(struct LNode));pd->next=NULL;pa_2=pd;k=total;for(i=0;i<total;i++){pa_1=pc->next;for(j=1;j<k;j++)pa_1=pa_1->next;pb_1=(LinkList)malloc(sizeof(struct LNode));pa_2->next=pb_1;pa_2=pa_2->next;pa_2->data=pa_1->data;k--;}pa_2->next=NULL;return pd;}2.流程图(实验要求1和3)图1 主函数流程图图2创建线性表La流程图图3判断La是否为空表流程图图4 插入元素(La)流程图图5删除元素(La)流程图图6定位元素(La)流程图图7取元素(La)流程图图8输出线性表流程图图9输出线性表流程图流程图(实验要求2和4)图10主函数流程图图11创建线性表La流程图图12判断是否为空表流程图图13插入元素流程图图14删除元素流程图图15定位元素流程图图图16取元素流程图图17创建Lb流程图图18归并两表流程图六、运行结果1. (实验要求1和3)点击运行，首先出现的是菜单界面，选择菜单选项进行操作，如图所示。
