《数据结构》 实验报告模板(附实例) ---实验一 线性表的基本操作实现
实验 一 线性表的基本操作实现及其应用
一、实验目的
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、程序清单
（程序过长，可附主要部分）
说明：以后每次实验报告均按此格式书写。
我在布置实验室时，仅给出实验名称、实验目的、实验
内容及相关数据结构。
题目一程序参考框架
# include
# include
# include
# include
# include
/* 定义ElemType为int类型 */
typedef int ElemType;
#define TRUE 1
#define FALSE 0
#define NULL 0
#define flag -1
/* 单链表的结点类型 */
typedef struct LNode
{ElemType data;
struct LNode *next;
} LNode,*LinkedList;
/* 初始化单链表 */
LinkedList LinkedListInit()
{ }
/* 清空单链表 */
void LinkedListClear(LinkedList L)
{ }
/* 检查单链表是否为空 */
int LinkedListEmpty(LinkedList L)
{ }
/* 遍历单链表 */
void LinkedListTraverse(LinkedList L)
{ }
int LinkedListLength (LinkedList L)
{ }
LinkedList LinkedListGet (LinkedList L, int i)
{ }
LinkedList LinkedListLocate ( LinkedList L, ElemType
x)
{ }
void LinkedListInsert(LinkedList L, int i, ElemType x)
{LinkedList pre,p,s;int j;
pre=L;j=1;p=L->next;
while(pre&&j
if(pre==NULL)
{printf("给的i值超过了表长");exit(0);}
s=(LNode *)malloc(sizeof(LNode));
s->data=x;
pre->next=s;
s->next=p;
}
void LinkedListDel (LinkedList L,ElemType x)
{ LinkedList pre,p;int j;
pre=L;j=1;p=L->next;
while(p&&p->data!=x)
{pre=p;p=p->next;j++;}
if(p==NULL)
{printf("表中没有值为x的结点");exit(0);}
pre->next=p->next;
free(p);
}
LinkedList LinkedListCreat( )
{ LinkedList L=LinkedListInit(),p,r;
ElemType x;
r=L;
printf("please input data,input -1 is end\n");
scanf("%d",&x);
while (x!=flag)
{p=(LinkedList)malloc(sizeof(LNode));
p->data=x;
r->next=p;
r=p;
scanf("%d",&x);
}
r->next=NULL;
return L;
}
int scan()
{int d;
printf("please input the operation\n");
printf("1.初始化 2.清空3.求链表长度4.检查链表是否为空
\n");
printf("5.检查链表是否为满 6.遍历链表 7.从链表中查找
元素\n");
printf("8.从链表中查找与给定元素值相同的元素在顺序表
中的位置\n");
printf("9.向链表中插入元素10. 从链表中删除元素\n");
printf("其他键退出。。。。。\n");
scanf("%d",&d);
return(d);
}
main()
{int quit=0;
int i;
ElemType e;
LinkedList L;
while(!quit)
switch(scan())
{case 1: ….; break;
case 2: …. ;break;
case 3: ….; break;
case 4: ….; break;
case 5:LinkedListTraverse(L); break;
case 6: ….; break;
case 7: ….; break;
case 8: ….; break;
case 9: ….; break;
case 10: ….; break;
default: quit=1;}
return 0;
}
数据结构实验一实验报告
数据结构实验一实验报告一、实验目的本次数据结构实验一的目的主要在于让我们通过实际操作，深入理解线性表的基本概念和操作方法，掌握顺序表和链表这两种常见的数据结构，并能够运用所学知识解决一些简单的实际问题。
二、实验环境本次实验使用的编程环境为具体编程环境名称，开发工具为具体开发工具名称。
三、实验内容（一）顺序表的实现与操作1、顺序表的定义顺序表是一种用一组地址连续的存储单元依次存储数据元素的线性结构。
2、顺序表的基本操作实现初始化顺序表：创建一个空的顺序表，并为其分配一定的存储空间。
插入元素：在指定位置插入新的元素。
删除元素：删除指定位置的元素。
查找元素：在顺序表中查找指定的元素，并返回其位置。
（二）链表的实现与操作1、链表的定义链表是一种通过指针将各个数据元素链接起来的线性结构。
2、链表的基本操作实现初始化链表：创建一个空的链表。
插入节点：在链表的指定位置插入新的节点。
删除节点：删除链表中指定位置的节点。
查找节点：在链表中查找指定的节点，并返回其位置。
四、实验步骤（一）顺序表的实现1、定义顺序表的数据结构使用数组来存储顺序表的元素，并记录顺序表的当前长度和最大长度。
2、实现顺序表的初始化函数分配初始的存储空间，并将长度初始化为 0 。
3、实现顺序表的插入函数首先判断插入位置是否合法，如果合法，则将插入位置之后的元素依次向后移动一位，然后将新元素插入到指定位置，并更新长度。
4、实现顺序表的删除函数首先判断删除位置是否合法，如果合法，则将删除位置之后的元素依次向前移动一位，并更新长度。
5、实现顺序表的查找函数通过遍历顺序表，逐个比较元素，找到目标元素并返回其位置。
（二）链表的实现1、定义链表的节点结构包含数据域和指针域，指针域用于指向下一个节点。
2、实现链表的初始化函数创建一个空的链表，即头节点的指针为空。
3、实现链表的插入函数根据插入位置的不同，分为在表头、表尾和中间插入三种情况。
在插入时，需要创建新的节点，并正确调整指针的指向。
数据结构实验报告-实验：1线性表的顺序存储和操作实现
}
for(inti=pos-1;i<length;i++)
if(listArray[i].equals(obj))returni+1;
return-1;
}
publicbooleanmodify(Object obj,intpos){
if(pos<1||pos>length){
List sort();
}
publicclasssequenceListimplementsList {
finalintmaxSize=10;
privateintlength;
privateObject[]listArray;
publicsequenceList(){//无参数的构造函数的定义
length=0;//线性表初始为空，即长度为0
System.out.println();
list2.preOrder();
System.out.println("线性表list2长度："+list2.size());
}
}
publicinterfaceList {
Object value(intpos);
booபைடு நூலகம்eanadd(Object obj,intpos);
int[] a={20,16,38,42,29};
for(inti=0;i<a.length;i++) list1.add(a[i], i+1);
intn1=(Integer)list1.remove(2);
list1.add(80, 3);
intn2=(Integer)list1.value(4);
数据结构实验——线性表
7
必做实验要求
输入输出格式要求
如果链表为空，则输出NULL（大写） 例： 输入 512345 0 输出 1,2,3,4,5 NULL 1,2,3,4,5
8
必做实验要求
• 合并有序表的函数名称：MergeSortedList • 函数参数：A集合的单链表头指针与B集合
单链表的头指针， • 函数返回值：合并后的单链表的头指针
9
第二次实验
• 时间确定（14-15） • 星期四晚上？
10
数据结构实验——线性表
A2-412
1
• 17周之前提交报告（19:00） • 报告要求：
– 内容 – 算法思路 – 核心代码 – 测试结果 – 心得体会
2
实验总体要求
• 编程语言
– C语言，C++
3
题目
1. （必做） （合并有序表）已知线性表La
和Lb中元素分别按非递减顺序排列，现要 求将它们合并成一个新的线性表Lc，并使 得Lc中元素也按照非递减顺序排列。 2. （选做）设带头结点的线性表中元素值为 非零正整数，试写出：
– 求线性表中所有元素值之和的递归函数（空表返回0） – 求线性表中元素最大值的递归函数（空表返回0） – 求线性表中元素个数的递归函数（空表返回0）
4
必做实验要求
1. 用带头结点的单链表实现有序表的合并， 不能增加额外的空间存储合并数据
2. 节点定义要求： struct node {
int value; struct node * next; }; typedef struct node Node; typedef struct node *ptrList,*List;
数据结构-实验一 线性表操作
实验一线性表操作
（一）实验内容
单链表的创建、合并和输出。
（二）实验目的
1.熟悉用Visual C++进行程序设计的方法。
2.掌握单链表的创建、查找、插入和合并等运算。
（三）实验题目
本实验要求实现以下功能：
1.从键盘输入顺序任意的5个整数，按有序插入的要求生成第一个有序
单链表，将该链表输出显示。
2.再从键盘输入顺序任意的5个整数，按有序插入的要求生成第二个有
序单链表，将该链表输出显示。
3.将这两个有序单链表合并成一个有序单链表，要求使用两个单链表
的原有空间进行合并，将生成的有序单链表输出显示。
（四）实验仪器设备
1.学生每个一台PC机
2.已安装环境。
《数据结构》实验1实验报告
南京工程学院实验报告<班级>_<学号>_<实验X>.RAR文件形式交付指导老师。
一、实验目的1.熟悉上机环境，进一步掌握语言的结构特点。
2.掌握线性表的顺序存储结构的定义及实现。
3.掌握线性表的链式存储结构——单链表的定义及实现。
4.掌握线性表在顺序存储结构即顺序表中的各种基本操作。
5.掌握线性表在链式存储结构——单链表中的各种基本操作。
二、实验内容1.顺序线性表的建立、插入及删除。
2.链式线性表的建立、插入及删除。
三、实验步骤1.建立含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度。
2.利用前面的实验先建立一个顺序表L={21，23，14，5，56，17，31}，然后在第i个位置插入元素68。
3.建立一个带头结点的单链表，结点的值域为整型数据。
要求将用户输入的数据按尾插入法来建立相应单链表。
四、程序主要语句及作用程序1的主要代码(附简要注释)public struct sequenlist{public const int MAXSIZE=1024; /*最大值为1024*/public elemtype[] vec;public int len; /* 顺序表的长度 */public sequenlist( int n){vec=new elemtype[MAXSIZE ];len = n;}};class Program{static void Main(string[] args){sequenlist list1 = new sequenlist(5);for (int i = 0; i < 5; i++){list1.vec[i] = i;}for (int i = 0; i < 5; i++){Console.Write("{0}---", list1.vec[i]) ;}Console.WriteLine("\n");Console.WriteLine("表长：{0}\n",list1.len );Console.ReadKey();}}程序2的主要代码(附简要注释)public void insertlist(int i, int x){if (len >= MAXSIZE)throw new Exception("上溢"); /*长度大于最大值则抛出异常*/if (i < 1 || i > len + 1)throw new Exception("位置");/插入位置小于1或大于len+1则抛出插入位置错误的异常for (int j = len; j >= i; j--)vec[j] = vec[j - 1]; //注意第j个元素存在数组下标为j-1处vec[i - 1] = x;len++;}};class Program{static void Main(string[] args){sequenlist list2 = new sequenlist(7);list2.vec[0] = 21;list2.vec[1] = 23;list2.vec[2] = 14;list2.vec[3] = 5;list2.vec[4] = 56;list2.vec[5] = 17;list2.vec[6] = 31;Console.Write("请输入第i个位置插入元素：");int loc =Convert.ToInt32( Console.ReadLine());Console.Write("请输入第{0}个位置插入的元素：", loc);int ele = Convert.ToInt32(Console.ReadLine());Console.WriteLine("插入前的线性表：");for (int i = 0; i < list2.len ; i++){Console.Write("{0}---", list2.vec[i]);}Console.WriteLine("\n");list2.insertlist(loc, ele);Console.WriteLine("插入后的线性表：");for (int i = 0; i < list2.len ; i++){Console.Write("{0}---", list2.vec[i]);}Console.WriteLine("\n");Console.ReadKey();}}程序3的主要代码(附简要注释)class Node{private int num;public int Num{set { num = value; }/输入值get { return num; }/获得值}private Node next;public Node Next{set { next = value; }get { return next; }}}class Pp{static void Main(string[] args){Node head;Node tempNode, tempNode1;int i;head = new Node();Console.WriteLine("输入六项数据：\n");Console.Write("输入第1项数据:");head.Num = Convert.ToInt32(Console.ReadLine());head.Next = null;tempNode = head;for (i = 1; i < 6; i++){tempNode1 = new Node();Console.Write("输入第{0}项数据:",i+1);tempNode1.Num = Convert.ToInt32(Console.ReadLine());/插入项转换为整形数值 tempNode1.Next = null;tempNode.Next = tempNode1;tempNode = tempNode.Next;}Console.WriteLine("线性表:");tempNode = head;for (i = 0; i < 6; i++){Console.Write("{0}", tempNode.Num);if (i < 5){Console.Write("--");}tempNode = tempNode.Next;}Console.ReadKey();}}五、程序运行结果截图程序1程序2程序3六、收获，体会及问题(写得越详细、越个性化、越真实越好，否则我不知道你做这个实验的心路历程，也就无法充分地判断你是否是独立完成的这个实验、你是否在做这个实验时进行了认真仔细地思考、通过这个实验你是否在实践能力上得到了提高)这次试验刚开始做时完全不知道从哪下手，才刚上了几节课，对于线性表、链式表都不是理解的很透彻，不知道用哪个软件编写程序。
数据结构实验一实验报告——线性表
实验报告课程名称：数据结构实验名称：线性表班级：学生姓名：学号：指导教师评定：签名:题目：有两张非递增有序的线性学生表A，B，采用顺序存储结构，两张表合并用c表存，要求C为非递减有序的，然后删除C表中值相同的多余元素。
一、需求分析⒈本演示程序根据已有的两张表的信息，实现两张表的合并及删除值相同元素的操作，需要用户输入学生的信息。
⒉在演示过程序中，用户输入需要合并的顺序表，即可观看合并结果。
⒊程序执行的命令包括：（1）构造线性表A （2）构造线性表B （3）求两张表的并（4）删除C中值相同的元素二、概要设计⒈为实现上述算法，需要线性表的抽象数据类型：ADT Stack {数据对象：D={a i:|a i∈ElemSet,i=1…n,n≥0}数据关系：R1={<a i-1,a i>|a i-1,a i∈D,i=2,…n≥0}基本操作:init(list *L)操作结果：构造一个空的线性表L。
ListLength(List *L)初始条件：线性表L已经存在操作结果：返回L中数据元素的个数。
GetElem(List L, int i, ElemType *e)初始条件：线性表L已经存在，1≤i≤ListLength(&L)操作结果：用e返回L中第i个数据元素的值。
EqualList(ElemType *e1,ElemType *e2)初始条件：数据元素e1,e2存在操作结果：以e1,e2中的姓名项作为判定e1,e2是否相等的依据。
Less_EquaList(ElemType *e1,ElemType *e2)初始条件：数据元素e1,e2存在操作结果：以e1,e2中的姓名项(为字符串)的≤来判定e1,e2是否有≤的关系。
LocateElem(List *La,ElemType e,int type)初始条件：线性表La已经存在操作结果：判断La中是否有与e相同的元素。
MergeList(List *La,List *Lb,List *Lc)初始条件：非递减线性表La，Lb已经存在操作结果：合并La，Lb得到Lc，Lc仍按非递减有序排列。
C语言数据结构线性表的基本操作实验报告
实验一线性表的基本操作一、实验目的与基本要求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)点击运行，首先出现的是菜单界面，选择菜单选项进行操作，如图所示。
数据结构实验报告（一）线性表的应用
数据结构实验报告（⼀）线性表的应⽤实验说明数据结构实验⼀ 线性表的实验——线性表的应⽤⼀、实验⽬的通过本实验使学⽣了解线性表的⼀种简单应⽤，熟悉线性表顺序存储与链式存储的特性，特别训练学⽣编程灵活控制链表的能⼒，为今后编程控制更为复杂的数据结构奠定基础。
⼆、实验内容1.⽤顺序表和链表分别分别编程实现教材中例⼦2-1与2-2。
要求：（1）只能⽤C语⾔编程实现；（2）完全保持书中算法2.1与算法2.2形式，不允许有任何变化，除⾮语法上不允许;所调⽤各函数参照书中19页的功能描述，其中函数名、参数个数及性质、函数功能必须与书中完全⼀致，不能有变化。
2.利⽤线性表表⽰⼀元多项式完成多项式的加、减、乘、求导、求值运算。
要求：（1）输⼊的⼀元多项式可以采⽤只输⼊各项的系数与指数这种简化的⽅式。
如对于多项式2x2+6x5，输⼊可为： 2,2 6,5 这样的简单形式。
（2）遇到有消项时应当处理，如2x2+6x5与3x2-6x5进⾏相加时，结果为5*x^2。
（3）当给定x的值时，能计算表达式相加或相减的结果。
（4）操作的结果放⼊⼀个新线性表中，原来的两个表达式存储表⽰不变，也可以不是产⽣新的线性表，⽽是将两上线性表合并为⼀个。
（5）要求程序功能模块划分合理（每个函数功能单⼀、可重⽤性好），使⽤空间尽可能少，算法尽可能⾼效。
实验报告1.实现功能描述使⽤线性表表⽰⼀元多项式完成多项式的加、减，乘，求导、求值运算。
2.⽅案⽐较与选择（1）因为使⽤的是线性表，所以主要⽅案有数组法和链表法。
（2）从时间复杂度来说，使⽤数组法更优；从空间复杂度来说，链表法更优。
因为数组法是指定好空间的，若式⼦⼤⼩超出设置⼤⼩，那程序必然出错；若式⼦⼤⼩⼩于设置⼤⼩，那就意味着有多余的空间被浪费了。
综合来讲，若计算式⼦较为庞⼤，使⽤链表法更佳；相反，若计算式⼦较⼩，数组法更佳。
3.设计算法描述（1）单个项式的数据存储使⽤了结构体，数组法是在⼀个结构体中定义两个⼀维数组；链表法是通过⼀个结构体作为⼀个节点，通过next指针连接起来。
数据结构线性表实验报告
实验一线性表一、实验目的1.掌握实现线性表的基本操作方法；2.掌握线性表的基本操作:建表、插入、删除、输出等运算在顺序存储结构和链式存储结构上的实现；3.通过本次实习加深对高级语言C语言的使用(特别是函数参数、指针类型、链表的使用)。
熟悉线性表的基本运算在两种存储结构(顺序结构和链式结构)上的实现。
二、实验环境装有VisualC++6.0的普通PC机三、源程序#include"string.h"#include "stdio.h"#include "stdlib.h"#include "conio.h"#define MaxLine 100 /*顺序存储的最大个数*/ typedef int ElemType;typedef struct SqList{ElemType data[MaxLine];/*存放顺序表的数组*/ int length;/*顺序表的长度*/} L;/*初始化顺序表*/void InitList(SqList&L){L.length = 0;//L.length =0;}/*得到顺序表的长度*/int GetLength(SqList &L){return L.length;}/*得到顺序表中的第i个元素*/ElemType GetElem(SqList &L,int i){if(i < 1 || i > L.length) 开始{printf("error");exit(1);}return L.data[i-1];}void ListInsert(SqList &L,int i,ElemType x)/*添加线性表中第i个位置上的元素,i从1开始*/{int j;if(i < 1 || i > L.length+1) /*检查添加位置的合法性*/{printf("error");exit(1);}if(L.length >= MaxLine){printf("overflow!");exit(1);}j = L.length;while(j>=i)/*此处语句相对参考语句有较大改变*/{L.data[j]=L.data[j-1];j--;}L.data[i-1] = x;L.length++;}void ListDelete(SqList &L,int i) /* 删除线性表中第i个位置上的元素*/ {int j;if(i<1 || i>L.length) /* 检查空表及删除位置的合法性*/ {printf ("不存在第i个元素");exit(0);}for(j=i;j<=L.length-1;j++)L.data[j-1]=L.data[j]; /* 向前移动元素*/L.length--;}int main(){FILE *fp;struct SqList A;InitList(A);/*初始化顺序表*/int Judge2=0;printf(" ***线性表操作实验***\n \n\n请输入0对长度为8的线性表输入数据或者其他任意数进行其他操作^_^\n");scanf("%d",&Judge2);if(Judge2==0){int t = 1,d=1;for(t=1;t<=8;t++)/*此处为顺序表首先输入8个元素*/{printf("请输入第%d个线性表元素:",t);scanf("%d",&d);ListInsert(A,t,d);}}int Judge=0;printf("输入0结束程序或者输入其他任意数继续对该表进行操作^_^\n");scanf("%d",&Judge);while(Judge)/*判断是结束程序还是要继续操作该顺序表*/{int a=0;int pos=0;int c=0;int Judge1=0;int P;/*给出顺序表操作选择菜单分别为输入，删除，显示长度，打印顺序表*/printf(" ***************\n *输入1进行插入*\n");printf(" *输入2进行删除*\n");printf(" *输入3显示长度*\n");printf(" *输入4打印该表*\n");printf(" *输入5保存数据*\n");printf(" *输入6进行排序*\n");printf(" *输入7查找数据*\n ***************\n");printf("请选择:");/*选择要进行的操作*/scanf("%d",&P);if(P==0)return 0;else if(P>=1&&P<=7)switch(P){case 1:printf("请输入想进行插入操作的位置:");/*选择待插入位置*/scanf("%d",&pos);int PP;printf("请输入待插入的元素:\n");/*输入要插入的元素*/scanf("%d",&PP);ListInsert(A,pos,PP);c=GetLength(A);printf("该线性表的长度为：%d!\n",c);/*此处选择是重新选择操作还是按顺序进行下一项操作*/printf("请输入0结束操作或者其他任意数继续其他操作^_^\n");scanf("%d",&Judge1);if(Judge1==1)continue;else break;case 2:printf("输入要删除元素的位置:");/*选择要删除的元素位置*/scanf("%d",&a);ListDelete(A,a);c=GetLength(A);printf("该线性表的长度为：%d!\n",c);/*此处选择是重新选择操作还是按顺序进行下一项操作*/printf("请输入0结束操作或者其他任意数继续进行其他操作^_^\n");scanf("%d",&Judge1);if(Judge1==1)continue;else break;case 3:c=GetLength(A);printf("该线性表的长度为：%d!\n",c);printf("请输入0结束操作或者其他任意数继续进行其他操作^_^\n");scanf("%d",&Judge1);if(Judge1==1)continue;else break;case 4:{c=GetLength(A);int d=0;printf("%s"," 该线性表数据记录如下\n");printf("%s","*****************************************************\n");for(int aa=0;aa<c;aa++){printf(" ");printf("%d \t",A.data[aa]); d++;/*打印该线性表*/if( d%4 ==0) printf("\n");}printf("\n");printf("%s","*****************************************************\n");printf("请输入0结束操作或者其他任意数继续进行其他操作^_^\n");scanf("%d",&Judge1);if(Judge1==1)continue;else break;}case 5:{fp=fopen("Test.txt","wt+");int i=0,j=0;fprintf(fp,"%s"," 文件Test数据记录\n");fprintf(fp,"%s","_________________________\n");for(i=0;i<GetLength(A);){fprintf(fp,"%d",A.data[i]);i++;fputc('\t',fp);j++;if(j%4==0) fputc(10,fp);} ;fprintf(fp,"%s","\n_________________________");fclose(fp);printf("相关数据已经存入文件Test.txt中^_^\n");printf("请输入0结束操作或者其他任意数继续进行其他操作^_^\n");scanf("%d",&Judge1);if(Judge1==1)continue;else break;}case 6:{int i,j,temp;for(i=0;i<GetLength(A)-1;i++)for(j=i+1;j<GetLength(A);j++) /*注意循环的上下限*/{if(A.data[i]>A.data[j]){temp=A.data[i];A.data[i]=A.data[j];A.data[j]=temp;}}c=GetLength(A);int d=0;printf("%s","排序后该线性表数据记录如下\n");printf("%s","**************************\n");for(int aa=0;aa<c;aa++){printf("%d \t",A.data[aa]); d++;/*打印该线性表*/if( d%4 ==0) printf("\n");}printf("\n");printf("%s","**************************\n");printf("请输入0结束操作或者其他任意数继续进行其他操作^_^\n");scanf("%d",&Judge1);if(Judge1==1)continue;else break;}case 7:{int value;printf("请输入待查找的数据：\n");scanf("%d",&value);for(int i=0;i<GetLength(A);){if(A.data[i] == value)printf("待查找的是表中第%d个数据%d^_^\n",i+1,value);else if(i>=(GetLength(A)-1)) printf("待查找的数据不存在+_+\n");i++;}printf("请输入0结束操作或者其他任意数继续进行其他操作^_^\n");scanf("%d",&Judge1);if(Judge1==1)continue;else break;}}printf("请输入0 结束程序或者输入其他任意数继续进行操作^_^\n");scanf("%d",&Judge);}return 0;}四、实验数据记录1，生成长度为8的线性表2，选择插入数据3，删除数据4，打印表5，保存数据6，排序7，查找数据五、实验总结实验在编写源程序是由于参考给的参考程序较多，但是参考程序存在一定的问题且相当不完善，走了弯路。
线性表——数据结构实验报告
实验报告题目：编制一个演示集合的并交和差运算的程序班级：姓名：学号：完成日期：年月日一，需求分析1集合的元素限定为小写字母字符[…a‟..‟z‟]。
集合输入的形式为一个以“回车键”为标志的字符串，串中字符顺序不限，不允许出现重复字符。
输出的运算结果字符串中将不含重复字符。
2以对话方式执行。
3程序执行的命令包括：1）构造集合；2）将集合整理为只含小写字符；3）将集合按从小到大排列；4）选择对集合的操作；5）求交集；6）求并集；7）求差集4测试数据（1）Set1=”magzine”, Set2=”paer”,Set1∪Set2=”aegimnprz”, Set1∩Set2=”ae”, Set1-Set2=”gimnz”。
（2）Set1=”012oper4a6tin89”, Set2=”eordta”,Set1∪Set2=”adeinoprt”, Set1∩Set2=”aeort”, Set1-Set2=”inp”。
二，概要设计1基本操作Lnode *InitList(void); //初始化一个集合要求无重复数ListPrint_L(struct Lnode *head); //输出所设定的集合ListDifference(struct Lnode *a,struct Lnode *b);//作集合的差运算Lnode *ListArrange(struct Lnode *head); //使集合中只存在小写字母MergeList_L(struct Lnode *ah,struct Lnode *bh); //将两个集合合并ListSwitch(struct Lnode *La,struct Lnode *Lb); //选择对集合进行的并、交、差操作ListSame(struct Lnode *La,struct Lnode *Lb); //作集合的交集Lnode *ListSort(struct Lnode *La); //进行集合元素的排列三，详细设计1元素类型、结点类型和指针类型typedef char ElemType;typedef int Status;typedef struct Lnode{ElemType data;struct Lnode *next;}Lnode,*LinkList;LinkList InitList(void){ //由p1,p2申请空间，获得数据并组成链表p1=p2=(LinkList)malloc(sizeof(LinkList));while(p1->data!='\n')p2->next=p1;p2=p1;}2根据有序表的基本操作的特点，有序表采用有序链表实现。