北京信息科技大学 数据结构 实验一 顺序表和单链表的操作

数据结构实验一顺序表实验报告
数据结构是计算机科学中的一门基础课程，在学习数据结构的过程中，顺序表是我们必须深入了解和掌握的重要数据结构之一。

在实验一中，我们对顺序表进行了一系列的操作，实现了增删改查等基本操作。

我们先来介绍一下顺序表的基本概念。

顺序表是将线性表中的数据存储在一段连续的存储空间中的数据结构，其查找效率高，但插入和删除操作效率较低。

顺序表需要预先分配一定的存储空间，当存储空间不足时需要进行动态扩容，即重新申请更大的存储空间并将原有数据复制到新的存储空间中。

在实验中，我们首先学习了顺序表的实现方式，包括顺序表的结构体定义、创建顺序表、插入元素、删除元素、修改元素以及查询元素等基本操作。

我们通过 C 语言来实现了这些操作，并将其封装成一个顺序表的 API，使其更加易于使用和维护。

在实验过程中，我们还发现顺序表中数据的存储顺序非常重要，因为顺序表中元素的存储顺序与元素的下标是一一对应的，如果存储的顺序错误，可能会导致元素的下标与我们想象中的不一致，从而造成一些意想不到的结果。

总的来说，实验一帮助我们更深入地了解了顺序表的实现方式和基本操作，同时也挖掘出了一些潜在问题，这对于我们今后的学习和实践都起到了很大的帮助。

实验一线性表操作一、实验目的1熟悉并掌握线性表的逻辑结构、物理结构。

2熟悉并掌握顺序表的存储结构、基本操作和具体的函数定义。

3熟悉VC++程序的基本结构，掌握程序中的用户头文件、实现文件和主文件之间的相互关系及各自的作用。

4熟悉VC++操作环境的使用以及多文件的输入、编辑、调试和运行的全过程。

二、实验要求1实验之前认真准备，编写好源程序。

2实验中认真调试程序，对运行结果进行分析，注意程序的正确性和健壮性的验证。

3不断积累程序的调试方法。

三、实验内容基本题:1对元素类型为整型的顺序存储的线性表进行插入、删除和查找操作。

加强、提高题：2、编写一个求解Josephus问题的函数。

用整数序列1, 2, 3, ……, n表示顺序围坐在圆桌周围的人。

然后使用n = 9, s = 1, m = 5，以及n = 9, s = 1, m = 0，或者n = 9, s = 1, m = 10作为输入数据，检查你的程序的正确性和健壮性。

最后分析所完成算法的时间复杂度。

定义JosephusCircle类，其中含完成初始化、报数出圈成员函数、输出显示等方法。

（可以选做其中之一）加强题：（1）采用数组作为求解过程中使用的数据结构。

提高题：（2）采用循环链表作为求解过程中使用的数据结构。

运行时允许指定任意n、s、m数值，直至输入n = 0退出程序。

实验二栈、队列、递归应用一、实验目的1熟悉栈、队列这种特殊线性结构的特性2熟练掌握栈、队列在顺序存储结构和链表存储结构下的基本操作。

二、实验要求1实验之前认真准备，编写好源程序。

2实验中认真调试程序，对运行结果进行分析，注意程序的正确性和健壮性的验证。

3不断积累程序的调试方法。

三、实验内容基本题（必做）：1分别就栈的顺序存储结构和链式存储结构实现栈的各种基本操作。

2、假设以带头结点的循环链表表示队列，并且只设一个指针指向对尾结点，不设头指针，试设计相应的置队空、入队和出队的程序。

加强题：3设线性表A中有n个字符，试设计程序判断字符串是否中心对称，例如xyzyx和xyzzyx都是中心对称的字符串。

实验一顺序表和单链表的基本操作一、实验目的a)掌握线性顺序存储结构的形式与特点;b)熟练利用顺序存储结构实现线性表的基本操作;c)熟练掌握顺序存储结构中的算法实现;d)掌握线性表链式存储结构的特点;e)熟练利用链式存储结构实现线性表的基本操作;f)熟练掌握链式存储结构中的算法实现。

二、知识准备a)线性表顺序结构的表示;b)顺序表的基本操作:顺序表的建立、查找、插入、删除;c)线性表链式存储结构的表示;d)链式表的基本操作:链式表的建立、查找、插入、删除;链式存储结构表不能随机存取,只能设置一个指针变量,从表头逐步向后移动来实现插入或删除数据的位置,找到后再进行具体操作。

三、实验内容1、下面提供的程序实现的是:设有两个按元素值递增有序的顺序表la和lb,编写程序将la表和lb表归并成一个新的递增有序的顺序表lc(值相同的元素均保留在lc表中)。

*/# include "datastru.h"# include <stdio.h>void merge_sqlist(SEQUENLIST la,SEQUENLIST lb,SEQUENLIST *lc){/*两有序表合并*/int i , j , k ;i = j = k = 1 ;while( ____i<=st && j<=st___)//la没有到达链表尾部并且lb 也没有到达链表尾部if( la.datas[i] <= lb.datas[j])//如果la的数据小于lb的数据{ _____ lc->datas[k]=la.datas[i]____ ;//就把la的数据放到lc中;注意lc是地址变量 k++ ; i++ ;}else{ ____lc->datas[k]=lb.datas[j]____; //否则就把lb的数据放到lc中k++ ; j++ ;}while( _____i<=st____ ) //如果la没有到达尾部{ _____lc->datas[k]=la.datas[i] ____ ; //就把剩余的la数据放到lc后面k++ ; i++;}while( ____ j<=st ______ ) //如果lb没有到达尾部{ ___lc->datas[k]=lb.datas[j]__ ; //就把剩余的lb数据放到lc后面k++; j++;}lc->last =st+st;return;}main( ){ SEQUENLIST la, lb, lc;int i, k, m;printf("请输入la顺序表元素,元素为整型量,用空格分开,-99为结束标志: ");st = 0; i = 0; scanf("%d",&i);while (i != -99) {/*输入la顺序表元素,建立有序表*/k = st;while((k>=1) && ( i<la.datas[k])) k--;for(m = st; m >= k+1; m--) la.datas[m + 1] = la.datas[m];la.datas[k + 1] = i; st++;scanf("%d",&i);}printf("\n\n请输入lb顺序表元素,元素为整型量,用空格分开,-99为结束标志:");st = 0; i = 0; scanf("%d",&i);while (i != -99) {/*输入lb顺序表元素,建立有序表*/k = st;while((k>=1) && ( i<lb.datas[k])) k--;for(m = st; m >= k+1; m--) lb.datas[m + 1] = lb.datas[m];lb.datas[k + 1] = i; st++;scanf("%d",&i); }printf("\nla有序表元素列表:");for (i = 1; i <= st; i++)printf("% d",la.datas[i]);printf("\n");printf("\nlb有序表元素列表:");for (i = 1; i <= st; i++)printf("% d",lb.datas[i]);printf("\n");merge_sqlist (la, lb, &lc);printf("\n合并后lc有序表元素列表:");for (i = 1; i <= st; i++)printf(" %d",lc.datas[i]);printf("\n");}在做的过程中我所遇到的问题:发现头文件【# include "datastru.h"】无法被系统识别?在同学的帮助下得出答案:需要将目标程序“另存为”存储为【*.cpp】格式的文件。

元素之后的所有数据都前移一个位置，最将线性表长减1。

3．顺序表查找操作的基本步骤：要在顺序表中查找一个给定值的数据元素则可以采用顺序查找的方法，从表中第 1 个数据元素开始依次将值与给定值进行比较，若相等则返回该数据元素在顺序表中的位置，否则返回0 值。

线性表的动态分配顺序存储结构—C语言实现#define MaxSize 50//存储空间的分配量Typedef char ElemType；Typedef struct{ElemType data[MaxSize];int length; //表长度（表中有多少个元素）}SqList;动态创建一个空顺序表的算法：void InitList(SqList *&L) //初始化线性表{L=(SqList *)malloc(sizeof(SqList)); //分配存放线性表的空间L->length=0; //置空线性表长度为0}线性表的插入：status Sqlist_insert(Sqlist &L,int i,Elemtype x)/*在顺序表L中第i个元素前插入新元素x*/{ if (i<1||i>L.length+1) return ERROR; /*插入位置不正确则出错*/if (L.length>=MAXLEN)return OVERFLOW;/*顺序表L中已放满元素，再做插入操作则溢出*/for(j=L.length-1;j>=i-1;j--)L.elem[j+1]=L.elem[j]; /*将第i个元素及后续元素位置向后移一位*/L.elem[i-1]=x; /*在第i个元素位置处插入新元素x*/L.length++; /*顺序表L的长度加1*/return OK;}线性表的删除：status Sqlist_delete(Sqlist &L,int i,Elemtype &e)/*在顺序表L中删除第i个元素*{ if (i<1||i>L.length) return ERROR; /*删除位置不正确则出错*/for(j=i;j<=L.length-1;j++)L.elem[j-1]=L.elem[j]; /*将第i+1个元素及后继元素位置向前移一位*/L.length--;/*顺序表L的长度减1*/return OK；}线性表元素的查找：int LocateElem(SqList *L, ElemType e) //按元素值查找{int i=0;while (i<L->length && L->data[i]!=e)i++; //查找元素eif (i>=L->length) //未找到时返回0return 0;elsereturn i+1; //找到后返回其逻辑序号}输出线性表：void DispList(SqList *L) //输出线性表{int i;if (ListEmpty(L)) return;for (i=0;i<L->length;i++)printf("%c ",L->data[i]);printf("\n");}输出线性表第i个元素的值：bool GetElem(SqList *L,int i,ElemType &e)//求线性表中某个数据元素值{if (i<1 || i>L->length)return false; //参数错误时返回falsee=L->data[i-1]; //取元素值return true; //成功找到元素时返回true}代码：#include <stdio.h>#include <malloc.h>#define MaxSize 50typedef char ElemType;typedef struct{ElemType data[MaxSize];int length;} SqList;void InitList(SqList *&L);void DestroyList(SqList *L);bool ListEmpty(SqList *L);int ListLength(SqList *L);void DispList(SqList *L);bool GetElem(SqList *L,int i,ElemType &e);int LocateElem(SqList *L, ElemType e);bool ListInsert(SqList *&L,int i,ElemType e);bool ListDelete(SqList *&L,int i,ElemType &e);void InitList(SqList *&L)//初始化线性表{L=(SqList *)malloc(sizeof(SqList));//分配存放线性表的空间L->length=0;//置空线性表长度为0 }void DestroyList(SqList *L)//销毁线性表{free(L);}bool ListEmpty(SqList *L)//判线性表是否为空表{return(L->length==0);}int ListLength(SqList *L)//求线性表的长度{return(L->length);}void DispList(SqList *L)//输出线性表{int i;if (ListEmpty(L)) return;for (i=0;i<L->length;i++)printf("%c ",L->data[i]);printf("\n");}bool GetElem(SqList *L,int i,ElemType &e)//求线性表中某个数据元素值{if (i<1 || i>L->length)return false;//参数错误时返回falsee=L->data[i-1];//取元素值return true;//成功找到元素时返回true}int LocateElem(SqList *L, ElemType e)//按元素值查找{int i=0;while (i<L->length && L->data[i]!=e)i++;//查找元素eif (i>=L->length)//未找到时返回0return 0;elsereturn i+1;//找到后返回其逻辑序号}bool ListInsert(SqList *&L,int i,ElemType e)//插入数据元素{int j;if (i<1 || i>L->length+1)return false;//参数错误时返回falsei--;//将顺序表逻辑序号转化为物理序号for (j=L->length;j>i;j--)//将data[i]及后面元素后移一个位置L->data[j]=L->data[j-1];L->data[i]=e;//插入元素eL->length++;//顺序表长度增1return true;//成功插入返回true}bool ListDelete(SqList *&L,int i,ElemType &e)//删除数据元素{int j;if (i<1 || i>L->length)//参数错误时返回falsereturn false;i--;//将顺序表逻辑序号转化为物理序号e=L->data[i];for (j=i;j<L->length-1;j++)//将data[i]之后的元素前移一个位置L->data[j]=L->data[j+1];L->length--;//顺序表长度减1return true;//成功删除返回true}void main(){SqList *L;ElemType e;printf("顺序表的基本运算如下:\n");printf(" (1)初始化顺序表L\n");InitList(L);printf(" (2)依次采用尾插法插入a,b,c,d,e元素\n");ListInsert(L,1,'a');ListInsert(L,2,'b');ListInsert(L,3,'c');ListInsert(L,4,'d');ListInsert(L,5,'e');printf(" (3)输出顺序表L:");DispList(L);printf(" (4)顺序表L长度=%d\n",ListLength(L));printf(" (5)顺序表L为%s\n",(ListEmpty(L)?"空":"非空"));GetElem(L,3,e);printf(" (6)顺序表L的第3个元素=%c\n",e);实验结果：心得体会：通过本次实验，实现了数据结构在程序设计上的作用，了解了数据结构语言，加深了对c语言的认识掌并掌握了线性表的顺序存储结构的表示和实现方法，掌握顺序表基本操作的算法实现，同时了解了顺序表的应用。

实验报告课程名称数据结构实验项目实验一线性表的生成与操作题目一顺序表和链表的创建与基本操作系别___ _计算机学院 _ ______专业__ __计算机大类_ __班级/学号__(1406/2014011288)_____学生 _______(文学)_________实验日期_（2015年10月19日）成绩_______________________指导教师黄改娟实验题目：实验一线性表的生成与操作------顺序表和链表的创建与基本操作（自己所选择实验题目，必填）一、实验目的1)掌握线性表的顺序存储和链式存储结构；2)验证顺序表及链表的基本操作的实现；(验证)3)理解算法与程序的关系，能够将算法转换为对应程序；4)体会线性表在实际应用中能够解决的问题。

（设计、综合）二、实验容1)根据实验一题目列表，选定题目，说明题目的主要需求；2)结合所选定的题目，定义存储结构，并完成对应应用的线性表创建、插入、删除、查找等基本操作的算法描述；3)程序编码实现，并获得运行结果。

三、报告容1)实验题目及主要存储结构定义（提示：请根据所选定题目，描述存储结构）题目：顺序表和链表的创建及基本操作顺序表我是采用数组存储的，链表是采用结构体存储的2)结合题目，说明对相应线性表的基本操作算法描述（提示：可用自然语言、流程图、伪代码等均可，要求对每一个操作，都给出具体的算法描述）基本操作：#顺序表#（1）插入：在线性表中的x位置插入y----将x位置及之后的元素都往后挪一位，将y的值赋给a[x].（2）删除：删除位置为x的元素----另y=a[x],然后x之后的元素都往前挪一位。

（3）查找：寻找值为y的元素----从a[0]开始，若a[i]==y，则返回i，否则i++。

#链表#（1）插入：当i小于要插入的位置x时，i++，插入p->data------p->next=s->next;s->next=p;（2）删除：当p->data不等于要删除的值x时，p=p->next；q=p->next;p->next=q->next;free(q);（3）查找：当p->data!=x时，p=p->next，找到之后返回p->data3)程序源码（提示：列出所编写程序的代码。

实验一顺序表和单链表的基本操作的实现一、顺序表实验内容：1.编写函数,通过数组,建立一个顺序表。

2.编写函数,实现对该顺序表的遍历。

3.编写函数,在顺序表中进行顺序查找某一元素,查找成功则返回其存储位置i,否则返回错误信息。

4.编写函数,实现在顺序表的第i个位置上插入一个元素e的算法。

5.编写函数,实现删除顺序表中第i个元素的算法。

6.编写函数,实现输入一个元素data,把它插入到有序表中,使顺序表依然有序。

7.编写一个主函数,在主函数中设计一个简单的菜单,分别调试上述算法。

实验目的及要求：1.掌握顺序表的存储结构形式及其描述2.掌握顺序表的建立、查找、插入和删除操作。

实验程序：#include <stdio.h>#include <stdlib.h>#define M 100 //最大限void creat_list(int a[], int n); //建立顺序表void datafind_list(int a[],int d); //按值查找元素void find_list(int a[],int i); //按位查找元素void in(int a[], int i,int e); //插入接点void delet(int a[], int i); //删除接点void print_list(int a[] ); //打印顺序表int main(){int a[M];int data;int num;int place; int ch;printf("输入数据个数：");scanf("%d",&num);creat_list(a, num);print_list(a);while(1){printf("请选择操作：\n");printf("***************************************************************\n") ;printf("1.按值查找 2.按位查找 3.插入接点 4.删除接点 \n");printf("***************************************************************\n") ;scanf("%d",&ch);switch(ch){case 1:printf("Pleae enter the data you want to find:\n"); //按值查找scanf("%d",&data);datafind_list(a,data);break;case 2:printf("Pleae enter where you want to find:\n"); //按位查找scanf("%d",&place);printf("The place is :%d\n",place);find_list(a, place);break;case 3:printf("Pleae enter where you want to insert:\n"); //插入接点scanf("%d",&place);printf("input a data what you want to insert");scanf("%d",&data);in(a,place,data);print_list(a); break;case 4:printf("Pleae enter where you want to delet:\n"); //删除接点scanf("%d",&place);printf("The place is :%d\n",place);printf("Pleae enter where you want to delet:\n");scanf("%d",&place);printf("The place is :%d\n",place);delet(a, place);print_list(a);break;default: printf("输入错误，请重新选择");break;}}return 0;}void creat_list(int a[], int n) //建立顺序表{ int i;int j;int x;printf("输入数据：");scanf("%d",&a[1]);for (i = 2; i <= n; i++){ scanf("%d",&x);for (j = 1; j <= i - 1; j++){ if (x == a[j]){break;} }if (j > i - 1){a[i] = x;}elsei--;}a[0] = n;}void datafind_list(int a[],int d) //按值查找元素{ int i;int j=0;for(i=1;i<=a[0];i++){if(d==a[i])printf("the data is %d and its place is %d\n",d,i);else j++;}if (j==a[0]){printf("error\n");}}void find_list(int a[],int i) //按位查找{if (i < 1 || i > a[0] + 1){printf("error");}else printf("%5d",a[i]);}void in(int a[], int i,int e) //插入表中某个元素{ int j;if (i < 1 || i > a[0] + 1){printf("error");}else{ a[0] = a[0] + 1;for (j = a[0]; j >i; j--) //后移插入位置后的数{a[j] = a[j-1];}a[i]=e;}}void delet(int a[], int i) //删除表中某个元素{ int j;if (i < 1 || i > a[0] + 1){printf("error");exit(0);}for (j = i + 1; j <= a[0]; j++) //前移被删数的位置 {a[j - 1] = a[j];}a[0] = a[0] - 1;}void print_list(int a[] ) //打印顺序表{ int i;printf("\n");printf("顺序表是：");for (i = 1; i <= a[0]; i++){printf("%5d",a[i]);}printf("\n");}实验结果：实验分析：实验成功实现顺序表的基本操作！成功完成本实验，需要掌握顺序表的结构和理解顺序表结构的实验原理。

实验一顺序表的应用一．实验目的1、掌握线性表的顺序存储结构的基本操作的实现。

2、设计并实现顺序表的应用程序，提高编程能力。

二．实验内容编写程序实现：1、在原来的顺序表中将顺序表实现逆置。

2、要求顺序表的内容由用户输入，并分别显示出逆置前和逆置后的顺序表。

三．实验设备及实验环境实验设备：微机一台实验环境：C语言运行环境实验二单链表的应用三．实验目的1、掌握线性表的链式存储结构的基本操作的实现。

2、设计并实现单链表的应用程序，提高编程能力。

四．实验内容编写程序实现：1、在原有的单链表中，将单链表实现逆置。

（即不增加新的结点）2、程序要求单链表的内容由用户输入，并分别显示出逆置前和逆置后的单链表。

三．实验设备及实验环境实验设备：微机一台实验环境：C语言运行环境实验三栈和队列的应用一．实验目的1、掌握栈和队列的基本操作的实现。

2、利用栈和队列的特点解决实际问题，提高编程能力。

二．实验内容（1是必做题目，2和3可选其一）编写两个程序分别实现：1、进制之间的转换：如将10进制转换为2进制，10进制数n和要转换的进制d通过键盘输入。

2、利用栈解决火车调度问题，将本来杂乱无章的车厢排成软席（S）在前，硬席（H）在后。

车厢序列通过键盘输入，如HSHSHSSSH，输出SSSSSHHHH。

3、利用队列模拟医院排队系统。

三．实验设备及实验环境实验设备：微机一台实验环境：C语言运行环境实验四二叉树的操作（一）一、实验目的1、熟悉二叉树的概念和存储结构。

2、掌握二叉树的基本操作和实现方法。

二．实验内容1、利用栈并且采用非递归先序算法建立二叉树。

2、要求通过键盘输入二叉树的先序遍历顺序从而建立一棵二叉树。

三．实验设备及实验环境实验设备：微机一台实验环境：C语言运行环境实验五二叉树的基本操作（二）一、实验目的1．熟悉二叉树的遍历方法。

2．掌握非递归中序遍历、先序遍历和后序遍历算法的实现。

二．实验内容（中序非递归遍历必做、先序和后序可选其一）1、在前一实验的基础上，利用栈实现一棵二叉树的非递归遍历。

数据结构实验报告_单链表数据结构实验报告——单链表一、实验目的1.掌握单链表的基本概念和原理。

2.了解单链表在计算机科学中的应用。

3.掌握单链表的基本操作，如插入、删除、遍历等。

4.通过实验，加深对理论知识的理解，提高编程能力。

二、实验内容1.实验原理：单链表是一种线性数据结构，由一系列节点组成，每个节点包含数据域和指针域。

其中，指针域指向下一个节点，最后一个节点的指针域指向空。

单链表的主要操作包括插入、删除、遍历等。

2.实验步骤：（1）创建一个单链表。

（2）实现插入操作，即在链表的末尾插入一个新节点。

（3）实现删除操作，即删除链表中的一个指定节点。

（4）实现遍历操作，即输出链表中所有节点的数据。

3.实验代码：下面是使用Python语言实现的单链表及其基本操作的示例代码。

class Node:def __init__(self, data):self.data = dataself.next = Noneclass LinkedList:def __init__(self):self.head = Nonedef insert(self, data):new_node = Node(data)if self.head is None:self.head = new_nodeelse:current = self.headwhile current.next is not None:current = current.nextcurrent.next = new_nodedef delete(self, data):if self.head is None:returnif self.head.data == data:self.head = self.head.nextreturncurrent = self.headwhile current.next is not None and current.next.data != data:current = current.nextif current.next is None:returncurrent.next = current.next.nextdef traverse(self):current = self.headwhile current is not None:print(current.data)current = current.next4.实验结果：通过运行上述代码，我们可以看到单链表的基本操作得到了实现。

数据结构实验-顺序表的基本操作顺序表是一种线性数据结构，它的元素在内存中是连续存储的。

顺序表具有随机访问的特点，可以通过下标直接访问元素，因此在访问元素时具有较高的效率。

顺序表的基本操作包括插入、删除、查找等，下面将对这些基本操作进行详细介绍。

1. 初始化：初始化顺序表需要为其分配一定的内存空间，以存储元素。

可以使用静态分配或动态分配两种方式来初始化顺序表。

静态分配是在编译时为顺序表分配固定大小的内存空间，而动态分配是在运行时根据需要动态地为顺序表分配内存空间。

2. 插入操作：插入操作是将一个元素插入到顺序表的指定位置上。

在插入元素之前，需要判断顺序表是否已满，如果已满则需要进行扩容操作。

插入元素时，需要将插入位置以及其后的元素向后移动一位，为插入元素腾出位置。

插入操作的时间复杂度为O(n)，其中n为顺序表的长度。

3. 删除操作：删除操作是将顺序表中的一个元素删除。

在删除元素之前，需要判断顺序表是否为空，如果为空则无法进行删除操作。

删除元素时，需要将删除位置后面的元素向前移动一位，覆盖删除位置上的元素。

删除操作的时间复杂度为O(n)，其中n为顺序表的长度。

4. 查找操作：查找操作是根据给定的关键字，在顺序表中查找满足条件的元素。

可以使用顺序查找或二分查找两种方式进行查找。

顺序查找是从顺序表的第一个元素开始，逐个比较关键字，直到找到满足条件的元素或遍历完整个顺序表。

二分查找是在有序顺序表中进行查找，每次将待查找区间缩小一半，直到找到满足条件的元素或待查找区间为空。

查找操作的时间复杂度为O(n)，其中n为顺序表的长度。

5. 修改操作：修改操作是将顺序表中的一个元素修改为新的值。

修改操作需要先进行查找操作，找到待修改的元素，然后将其值修改为新的值。

修改操作的时间复杂度为O(n)，其中n为顺序表的长度。

6. 遍历操作：遍历操作是依次访问顺序表中的每个元素。

可以使用for循环或while循环进行遍历，从第一个元素开始，依次访问每个元素，直到遍历完整个顺序表。

数据结构实验报告顺序表1一、实验目的本次实验的主要目的是深入理解和掌握顺序表这种数据结构的基本概念、存储方式和操作方法，并通过实际编程实现，提高对数据结构的实际应用能力和编程技能。

二、实验环境本次实验使用的编程语言为C+＋，开发工具为Visual Studio 2019。

三、顺序表的基本概念顺序表是用一组地址连续的存储单元依次存储线性表中的数据元素。

在顺序表中，逻辑上相邻的元素在物理位置上也相邻。

顺序表可以随机访问表中的任意元素，但插入和删除操作可能需要移动大量元素，效率较低。

四、顺序表的存储结构在 C+＋中，可以使用数组来实现顺序表。

以下是一个简单的顺序表存储结构的定义：｀｀｀cppconst int MAX_SIZE ＝ 100; ／／定义顺序表的最大容量class SeqList ｛private:int dataMAX_SIZE; ／／存储数据元素的数组int length; ／／顺序表的当前长度public:SeqList(）｛ length ＝ 0; ｝／／构造函数，初始化长度为 0／／其他操作函数的声明int GetLength(）；bool IsEmpty(）；bool IsFull(）；int GetElement(int position)；int LocateElement(int element)；void InsertElement(int position, int element)；void DeleteElement(int position)；void PrintList(）；｝；｀｀｀五、顺序表的基本操作实现1、获取顺序表长度｀｀｀cppint SeqList:：GetLength(）｛return length;｝｀｀｀2、判断顺序表是否为空｀｀｀cppbool SeqList:：IsEmpty(）｛return length ＝＝ 0;｝｀｀｀3、判断顺序表是否已满｀｀｀cppbool SeqList:：IsFull(）｛return length ＝＝ MAX_SIZE;｝｀｀｀4、获取指定位置的元素｀｀｀cppint SeqList:：GetElement(int position) ｛if （position ＜ 1 ｜｜ position ＞ length) ｛std:：cout ＜＜＂位置错误！＂＜＜ std:：endl; return －1;｝return dataposition 1;｝｀｀｀5、查找指定元素在顺序表中的位置｀｀｀cppint SeqList:：LocateElement(int element) ｛for （int i ＝ 0; i ＜ length; i+＋）｛if （datai ＝＝ element) ｛return i ＋ 1;｝｝return －1; ／／未找到返回－1｝｀｀｀6、在指定位置插入元素｀｀｀cppvoid SeqList:：InsertElement(int position, int element) ｛if （IsFull(））｛std:：cout ＜＜＂顺序表已满，无法插入！＂＜＜ std:：endl; return;｝if （position ＜ 1 ｜｜ position ＞ length ＋ 1) ｛std:：cout ＜＜＂位置错误！＂＜＜ std:：endl;return;｝for （int i ＝ length; i ＞＝ position; i) ｛datai ＝ datai 1;｝dataposition 1 ＝ element;length+＋；｝｀｀｀7、删除指定位置的元素｀｀｀cppvoid SeqList:：DeleteElement(int position) ｛if （IsEmpty(））｛std:：cout ＜＜＂顺序表为空，无法删除！＂＜＜ std:：endl; return;｝if （position ＜ 1 ｜｜ position ＞ length) ｛std:：cout ＜＜＂位置错误！＂＜＜ std:：endl;return;｝for （int i ＝ position; i ＜ length; i+＋）｛datai 1 ＝ datai;｝length;｝｀｀｀8、打印顺序表中的所有元素｀｀｀cppvoid SeqList:：PrintList(）｛for （int i ＝ 0; i ＜ length; i+＋）｛std:：cout ＜＜ datai ＜＜＂＂；｝std:：cout ＜＜ std:：endl;｝｀｀｀六、实验结果与分析1、对顺序表进行初始化，创建一个空的顺序表。

1 线性表1. 实验题目与环境1.1实验题目及要求（1）顺序表的操作利用顺序存储方式实现下列功能：根据键盘输入数据建立一个线性表，并输出该线性表；对该线性表进行数据的插入、删除、查找操作，并在插入和删除数据后，再输出线性表。

（2）单链表的操作利用链式存储方式实现下列功能：根据键盘输入数据建立一个线性表，并输出该线性表；对该线性表进行数据的插入、删除、查找操作，并在插入和删除数据后，再输出线性表。

（3）线性表的应用约瑟夫环问题。

有n个人围坐一圈，现从某个人开始报数，数到M的人出列，接着从出列的下一个人开始重新报数，数到M的人又出列，如此下去，直到所有人都出列为止。

要求依次输出出列人的编码。

2.问题分析（1）顺序表的操作利用一位数组来描述顺序表，即将所有元素一词储存在数组的连续单元中，要在表头或中间插入一个新元素时，需要将其后的所有元素都向后移动一个位置来为新元素腾出空间。

同理，删除开头或中间的元素时，则将其后的所有元素向前移动一个位置以填补空位。

查找元素时，则需要利用循环语句，一一判断直到找出所要查找的元素（或元素的位置），输出相关内容即可（2）单链表的操作利用若干个结点建立一个链表，每个节点有两个域，即存放元素的数据域和存放指向下一个结点的指针域。

设定一个头指针。

在带头结点的单链表中的第i个元素之前插入一新元素，需要计数找到第i-1个结点并由一指针p指向它，再造一个由一指针s指向的结点，数据为x，并使x的指针域指向第i个结点，最后修改第i-1个结点的指针域，指向x结点。

删除第i个元素时，需要计数寻找到第i个结点，并使指针p指向其前驱结点，然后删除第i个结点并释放被删除结点的空间。

查找第i个元素，需从第一个结点开始计数找到第i个结点，然后输出该结点的数据元素。

（3）线性表的应用程序运行之后，首先要求用户指定初始报数的上限值，可以n<=30,此题中循环链表可不设头结点，而且必须注意空表和"非空表"的界限。

数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现l 实验⽬的1、顺序表（1）掌握线性表的基本运算。

（2）掌握顺序存储的概念，学会对顺序存储数据结构进⾏操作。

（3）加深对顺序存储数据结构的理解，逐步培养解决实际问题的编程能⼒。

l 实验内容1、顺序表1、编写线性表基本操作函数：（1）InitList(LIST *L,int ms)初始化线性表；（2）InsertList(LIST *L,int item,int rc)向线性表的指定位置插⼊元素；（3）DeleteList1(LIST *L,int item)删除指定元素值的线性表记录；（4）DeleteList2(LIST *L,int rc)删除指定位置的线性表记录；（5）FindList(LIST *L,int item)查找线性表的元素；（6）OutputList(LIST *L)输出线性表元素；2、调⽤上述函数实现下列操作：（1）初始化线性表；（2）调⽤插⼊函数建⽴⼀个线性表；（3）在线性表中寻找指定的元素；（4）在线性表中删除指定值的元素；（5）在线性表中删除指定位置的元素；（6）遍历并输出线性表；l 实验结果1、顺序表（1）流程图（2）程序运⾏主要结果截图（3）程序源代码#include<stdio.h>#include<stdlib.h>#include<malloc.h>struct LinearList/*定义线性表结构*/{int *list; /*存线性表元素*/int size; /*存线性表长度*/int Maxsize; /*存list数组元素的个数*/};typedef struct LinearList LIST;void InitList(LIST *L,int ms)/*初始化线性表*/{if((L->list=(int*)malloc(ms*sizeof(int)))==NULL){printf("内存申请错误");exit(1);}L->size=0;L->Maxsize=ms;}int InsertList(LIST *L,int item,int rc)/*item记录值；rc插⼊位置*/ {int i;if(L->size==L->Maxsize)/*线性表已满*/return -1;if(rc<0)rc=0;if(rc>L->size)rc=L->size;for(i=L->size-1;i>=rc;i--)/*将线性表元素后移*/L->list[i+=1]=L->list[i];L->list[rc]=item;L->size++;return0;}void OutputList(LIST *L)/*输出线性表元素*/{int i;printf("%d",L->list[i]);printf("\n");}int FindList(LIST *L,int item)/*查找线性元素，返回值>=0为元素的位置，返回-1为没找到*/ {int i;for(i=0;i<L->size;i++)if(item==L->list[i])return i;return -1;}int DeleteList1(LIST *L,int item)/*删除指定元素值得线性表记录，返回值为>=0为删除成功*/ {int i,n;for(i=0;i<L->size;i++)if(item==L->list[i])break;if(i<L->size){for(n=i;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return i;}return -1;}int DeleteList2(LIST *L,int rc)/*删除指定位置的线性表记录*/{int i,n;if(rc<0||rc>=L->size)return -1;for(n=rc;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return0;}int main(){LIST LL;int i,r;printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.size,LL.Maxsize);printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.list,LL.Maxsize);while(1){printf("请输⼊元素值，输⼊0结束插⼊操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d",&i);if(i==0)break;printf("请输⼊插⼊位置：");scanf("%d",&r);InsertList(&LL,i,r-1);printf("线性表为：");OutputList(&LL);}while(1){printf("请输⼊查找元素值，输⼊0结束查找操作：");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d ",&i);if(i==0)break;r=FindList(&LL,i);if(r<0)printf("没有找到\n");elseprintf("有符合条件的元素，位置为：%d\n",r+1);}while(1){printf("请输⼊删除元素值，输⼊0结束查找操作：");fflush(stdin);/*清楚标准缓存区*/scanf("%d",&i);if(i==0)break;r=DeleteList1(&LL,i);if(i<0)printf("没有找到\n");else{printf("有符合条件的元素，位置为：%d\n线性表为：",r+1);OutputList(&LL);}while(1){printf("请输⼊删除元素位置，输⼊0结束查找操作：");fflush(stdin);/*清楚标准输⼊缓冲区*/scanf("%d",&r);if(r==0)break;i=DeleteList2(&LL,r-1);if(i<0)printf("位置越界\n");else{printf("线性表为：");OutputList(&LL);}}}链表基本操作l 实验⽬的2、链表（1）掌握链表的概念，学会对链表进⾏操作。

淮海工学院计算机科学系实验报告书课程名：《数据结构》题目：线性表数据结构试验班级：软件112学号：姓名：线性表实验报告要求1目的与要求:1）掌握线性表数据结构的基本概念和抽象数据类型描述；2）熟练掌握线性表数据结构的顺序和链式存储存表示；3）熟练掌握线性表顺序存储结构的基本操作算法实现；4）熟练掌握线性表的链式存储结构的基本操作算法实现;5）掌握线性表在实际问题中的应用和基本编程技巧;6）按照实验题目要求独立正确地完成实验内容（提交程序清单及相关实验数据与运行结果）；7）按照报告格式和内容要求，认真书写实验报告，并在试验后的第三天提交电子（全班同学提交到学委，再统一打包提交给老师）和纸质（每班每次5份，学委安排，保证每个同学至少提交一次）；8）积极开展实验组组内交流和辅导，严禁复制和剽窃他人实验成果，一旦发现严肃处理；9）上实验课前，要求每个同学基本写好程序，并存储在自己的U盘上，用于实验课堂操作时调试和运行。

凡不做准备，没有提前编写程序者，拒绝上机试验。

2实验内容或题目一、顺序表的基本操作实现实验要求：数据元素类型ElemType取整型int。

按照顺序存储结构实现如下算法：1）创建任意整数线性表（即线性表的元素值随机在键盘上输入）的顺序存储结构（即顺序表），长度限定在25之内；2）打印/显示（遍历）该线性表（依次打印/显示出表中元素值）；3）在顺序表中查找第i个元素，并返回其值；4）在顺序表第i个元素之前插入一已知元素；5）在顺序表中删除第i个元素；6）求顺序表中所有元素值（整数）之和；二、链表（带头结点）基本操作实验要求：数据元素类型ElemType取字符型char。

按照动态单链表结构实现如下算法：1）按照头插法或尾插法创建一个带头结点的字符型单链表（链表的字符元素从键盘输入），长度限定在10之内；2）打印（遍历）该链表（依次打印出表中元素值，注意字符的输入顺序与链表的结点顺序）；3）在链表中查找第i个元素，i合法返回元素值，否则，返回FALSE；4）在链表中查找与一已知字符相同的第一个结点，有则返回TRUE，否则，返回FALSE；5）在链表中第i个结点之前插入一个新结点；6）在线性表中删除第i个结点；7）计算链表的长度。

实验1 顺序表的操作一、实验要求1.输入一组整型元素序列，建立顺序表。

2.实现该顺序表的遍历。

3.在该顺序表中进行顺序查找某一元素，查找成功返回1，否则返回0。

4.判断该顺序表中元素是否对称，对称返回1，否则返回0。

5.实现把该表中所有奇数排在偶数之前，即表的前面为奇数，后面为偶数。

6.* 输入整型元素序列利用有序表插入算法建立一个有序表。

7.* 利用算法6建立两个非递减有序表并把它们合并成一个非递减有序表。

8.编写一个主函数，调试上述算法。

二、源代码#include"stdio.h"#include"stdlib.h"#define ElemType int//int类型宏定义#define MAXSIZE 100//顺序结构typedef struct{ElemType elem[MAXSIZE]; //元素数组int length; //当前表长}SqList;//建立顺序表void BuildList(SqList &L){int n;printf("请输入建立顺序表的大小。

n=");scanf("%d",&n);L.length=n;printf("\n开始建立顺序表...\n");for(int i=0;i<L.length;i++)//循环建立顺序表{printf("\n请输入第%d个元素：",i+1);scanf("%d",&L.elem[i]);}printf("\n建立顺序表完毕！...\n");}//遍历顺序表void ShowList(SqList &L){int i;printf("\n开始遍历顺序表...\n");for(i=0;i<L.length;i++)printf("%d ",L.elem[i]);printf("\n遍历结束...\n");}//在顺序表中寻找X元素int FindList(SqList &L,int x){int a=0;for(int i=0;i<L.length;i++){if(L.elem[i]==x)a=1;}if(a==1)printf("1\n");elseprintf("0\n");return 0;}//判断是否对称int Duichen(SqList &L){int j,b=1,n;n=L.length;if(n%2==0){for(j=0;j<n/2;j++){if(L.elem[j]!=L.elem[L.length-j-1])b=0;}}elsefor(j=0;j<(n-1)/2;j++){if(L.elem[j]!=L.elem[L.length-j-1])b=0;}if(b==1)printf("1\n");elseprintf("0\n");return 0;}//前面为奇数，后面为偶数void PaixuList(SqList &L){int i,j,a;for(i=1;i<L.length;i++){if(L.elem[i]%2==1){a=L.elem[i];for(j=i;j>0;j--){L.elem[j]=L.elem[j-1];}L.elem[0]=a;i++;}}for(i=0;i<L.length;i++)printf("%d ",L.elem[i]);printf("\n");}int main(){SqList List;int n;while(1){printf("\n 实验一：顺序表\n");printf("\n******************************************************************");printf("\n 1.创建顺序表");printf("\n 2.遍历顺序表");printf("\n 3.在该顺序表中进行顺序查找某一元素，查找成功返回1，否则返回0");printf("\n 4.判断该顺序表中元素是否对称，对称返回1，否则返回0");printf("\n 5.该表中所有奇数排在偶数之前，即表的前面为奇数，后面为偶数");printf("\n 0.退出");printf("\n******************************************************************\n");printf("\n请输入选择序号：");scanf("%d",&n);switch(n){case 0:return 0;case 1:BuildList(List);break;case 2:ShowList(List);break;case 3:int X;printf("请输入要查找值：X=");scanf("%d",&X);FindList(List,X);break;case 4:Duichen(List);break;case 5:PaixuList(List);break;default:printf(" 请输入数字0-5 \n");}}return 0;}三、运行结果1）程序主界面2）选择1建立顺序表3）选择2遍历顺序表4）选择3查询元素X5）选择4判断是否对称6）选择5奇数在前，偶数在后7）选择0退出。

数据结构实验一顺序表实验报告数据结构实验一顺序表实验报告一、实验目的顺序表是一种基本的数据结构，本次实验的目的是通过实现顺序表的基本操作，加深对顺序表的理解，并掌握顺序表的插入、删除、查找等操作的实现方法。

二、实验内容1. 实现顺序表的创建和初始化操作。

2. 实现顺序表的插入操作。

3. 实现顺序表的删除操作。

4. 实现顺序表的查找操作。

5. 实现顺序表的输出操作。

三、实验步骤1. 创建顺序表的数据结构，包括数据存储数组和记录当前元素个数的变量。

2. 初始化顺序表，将当前元素个数置为0。

3. 实现顺序表的插入操作：- 判断顺序表是否已满，若已满则输出错误信息。

- 将插入位置之后的元素依次后移一位。

- 将要插入的元素放入插入位置。

- 当前元素个数加一。

4. 实现顺序表的删除操作：- 判断顺序表是否为空，若为空则输出错误信息。

- 判断要删除的位置是否合法，若不合法则输出错误信息。

- 将删除位置之后的元素依次前移一位。

- 当前元素个数减一。

5. 实现顺序表的查找操作：- 遍历顺序表，逐个比较元素值与目标值是否相等。

- 若找到目标值，则返回该元素的位置。

- 若遍历完整个顺序表仍未找到目标值，则返回错误信息。

6. 实现顺序表的输出操作：- 遍历顺序表，逐个输出元素值。

四、实验结果经过实验，顺序表的各项操作均能正确实现。

在插入操作中，可以正确将元素插入到指定位置，并将插入位置之后的元素依次后移。

在删除操作中，可以正确删除指定位置的元素，并将删除位置之后的元素依次前移。

在查找操作中，可以正确返回目标值的位置。

在输出操作中，可以正确输出顺序表中的所有元素。

五、实验总结通过本次实验，我深入了解了顺序表的原理和基本操作，并通过实际编程实现了顺序表的各项功能。

在实验过程中，我遇到了一些问题，如如何判断顺序表是否已满或为空，如何处理插入和删除位置的合法性等。

通过查阅资料和与同学讨论，我解决了这些问题，并对顺序表的操作有了更深入的理解。

数据结构实验报告顺序表数据结构实验报告：顺序表摘要：顺序表是一种基本的数据结构，它通过一组连续的存储单元来存储线性表中的数据元素。

在本次实验中，我们将通过实验来探索顺序表的基本操作和特性，包括插入、删除、查找等操作，以及顺序表的优缺点和应用场景。

一、实验目的1. 理解顺序表的概念和特点；2. 掌握顺序表的基本操作；3. 了解顺序表的优缺点及应用场景。

二、实验内容1. 实现顺序表的初始化操作；2. 实现顺序表的插入操作；3. 实现顺序表的删除操作；4. 实现顺序表的查找操作；5. 对比顺序表和链表的优缺点；6. 分析顺序表的应用场景。

三、实验步骤与结果1. 顺序表的初始化操作在实验中，我们首先定义了顺序表的结构体，并实现了初始化操作，即分配一定大小的存储空间，并将表的长度设为0，表示表中暂时没有元素。

2. 顺序表的插入操作接下来，我们实现了顺序表的插入操作。

通过将插入位置后的元素依次向后移动一位，然后将新元素插入到指定位置，来实现插入操作。

我们测试了在表中插入新元素的情况，并验证了插入操作的正确性。

3. 顺序表的删除操作然后，我们实现了顺序表的删除操作。

通过将删除位置后的元素依次向前移动一位，来实现删除操作。

我们测试了在表中删除元素的情况，并验证了删除操作的正确性。

4. 顺序表的查找操作最后，我们实现了顺序表的查找操作。

通过遍历表中的元素，来查找指定元素的位置。

我们测试了在表中查找元素的情况，并验证了查找操作的正确性。

四、实验总结通过本次实验，我们对顺序表的基本操作有了更深入的了解。

顺序表的插入、删除、查找等操作都是基于数组的操作，因此在插入和删除元素时，需要移动大量的元素，效率较低。

但是顺序表的优点是可以随机访问，查找效率较高。

在实际应用中，顺序表适合于元素数量不变或变化不大的情况，且需要频繁查找元素的场景。

综上所述，顺序表是一种基本的数据结构，我们通过本次实验对其有了更深入的了解，掌握了顺序表的基本操作，并了解了其优缺点及应用场景。

数据结构实验报告_单链表【实验目的】1、顺序表的基本操作及c语言实现【实验要求】1、用c语言建立自己的线性表结构的程序库，实现顺序表的基本操作。

2、对线性表表示的集合，集合数据由用户从键盘输入（数据类型为整型），建立相应的顺序表，且使得数据按从小到大的顺序存放，将两个集合的并的结果存储在一个新的线性表集合中，并输出。

【实验内容】1、根据教材定义的顺序表机构，用c语言实现顺序表结构的创建、插入、删除、查找等操作；2、利用上述顺序表操作实现如下程序：建立两个顺序表表示的集合（集合中无重复的元素），并求这样的两个集合的并。

【实验结果】[实验数据、结果、遇到的问题及解决]一．statusinsertorderlist(sqlist&va,elemtypex){}二．statusdeletek(sqlist&a,inti,intk){//在非递减的顺序表va中插入元素x并使其仍成为顺序表的算法inti;if(v==ze)return(overflow);for(i=v;i>0,x }//注意i的编号从0开始intj;if(i<0||i>-1||k<0||k>-i)returninfeasible;for(j=0;j<=k;j++)[j+i]=[j+i+k];=-k;returnok;三．//将合并逆置后的结果放在c表中，并删除b表statuslistmergeoppose_l(linklist&a,linklist&b,linklist& c){linklistpa,pb,qa,qb;pa=a;pb=b;qa=pa;qb=pb;//保存pa的前驱指针//保存pb的前驱指针pa=pa->next;pb=pb->next;a->next=null;c=a;while(pa&&pb){}whi le(pa){}qa=pa;pa=pa->next;qa->next=a->next;a->next=qa;if(pa ->datadata){}else{}qb=pb;pb=pb->next;qb->next=a->next;//将当前最小结点插入a表表头a->next=qb;qa=pa;pa=pa->next;qa->next=a->next;//将当前最小结点插入a表表头a->next=qa;}}pb=b;free(pb);returnok;qb=pb;pb=pb->next;qb->next=a->n ext;a->next=qb;顺序表就是把线性表的元素存储在数组中，元素之间的关系直接通过相邻元素的位置来表达。

数据结构实验一顺序表实验报告一、实验目的本次实验的主要目的是通过实现顺序表的基本操作，深入理解线性表的逻辑结构和存储结构，掌握顺序表的插入、删除、查找等操作的实现方法，提高编程能力和问题解决能力。

二、实验环境本次实验使用的编程语言为 C 语言，编程环境为 Visual Studio 2019。

三、实验原理顺序表是一种线性表的存储结构，它使用一组连续的存储单元依次存储线性表中的元素。

在顺序表中，元素的逻辑顺序与物理顺序是一致的。

顺序表的基本操作包括初始化、插入、删除、查找、遍历等。

在实现这些操作时，需要考虑顺序表的存储空间是否已满、插入和删除元素时元素的移动等问题。

四、实验内容（一）顺序表的定义｀｀｀cdefine MAXSIZE 100 ／／定义顺序表的最大长度typedef struct ｛int dataMAXSIZE; ／／存储顺序表的元素int length; ／／顺序表的当前长度｝ SeqList;｀｀｀（二）顺序表的初始化｀｀｀cvoid InitList(SeqList L) ｛L>length ＝ 0;｝｀｀｀（三）顺序表的插入操作｀｀｀cint InsertList(SeqList L, int i, int e) ｛if （L>length ＝＝ MAXSIZE) ｛／／顺序表已满return 0;｝if （i ＜ 1 ｜｜ i ＞ L>length ＋ 1) ｛／／插入位置不合法return 0;｝for （int j ＝ L>length; j ＞＝ i; j) ｛／／移动元素L>dataj ＝ L>dataj 1;｝L>datai 1 ＝ e; ／／插入元素L>length+＋；return 1;｝｀｀｀（四）顺序表的删除操作｀｀｀cint DeleteList(SeqList L, int i, int e) ｛if （L>length ＝＝ 0) ｛／／顺序表为空return 0;｝if （i ＜ 1 ｜｜ i ＞ L>length) ｛／／删除位置不合法｝e ＝ L>datai 1; ／／取出被删除的元素for （int j ＝ i; j ＜ L>length; j+＋）｛／／移动元素L>dataj 1 ＝ L>dataj;｝L>length;return 1;｝｀｀｀（五）顺序表的查找操作｀｀｀cint SearchList(SeqList L, int e) ｛for （int i ＝ 0; i ＜ Llength; i+＋）｛if （Ldatai ＝＝ e) ｛return i ＋ 1;｝｝｝｀｀｀（六）顺序表的遍历操作｀｀｀cvoid TraverseList(SeqList L) ｛for （int i ＝ 0; i ＜ Llength; i+＋）｛printf(＂％d ＂， Ldatai)；｝printf(＂＼n"）；｝｀｀｀五、实验步骤1、打开 Visual Studio 2019，创建一个新的 C 语言项目。

实验一、二：线性表的应用班级学号姓名一、实验预备知识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个位置上的元素，每删除一个元素都要输出一次单链表。

五、实验结果1．给出程序清单及输入/输出结果。

2．实验过程中遇到的问题、解决方法及心得体会。