顺序表实验报告
顺序表的基本操作实验报告
竭诚为您提供优质文档/双击可除顺序表的基本操作实验报告篇一：顺序表的基本操作--实验报告实验报告附：源程序：#include#definemaxsize100#defineerror0#defineok1typedefstruct{intelem[maxsize];intlast;}seqList;intInsList(seqList*L,inta,inti);intLocate(seqListL,inte);intDel(seqList*L,inti);voidmain(){inti,e,a;intlist1,list2;if(L.elem[st]==-1)seqListL;st=0;for(i=0;i list1=InsList(if(list1){}elseprintf("插入失败！");printf("要查找的元素为\n");scanf("%d",printf("插入后的顺序表为:\n");for(i=0;i list2=Locate(L,e);if(!list2)printf("该元素不存在\n");}printf("该元素所在位置的序号为:%d\n",list2);/*删除元素*/printf("是否要删除该元素？\n");intm;scanf("%d",if(m){Del(printf("删除后的顺序表为:\n");for(i=0;iintInsList(seqList*L,inta,inti)//i位置，下标i-1{for(p=L->last;p>=i-1;p--)L->elem[p+1]=L->elem[p];in tp;if(L->last>=maxsize-1){}printf("表已满，无法插入");return(error);L->elem[i-1]=a;L->last++;return(ok );intLocate(seqListL,inte){}intDel(seqList*L,inti){}for(k=i;klast;k++)L->elem[k-1]=L->elem[k];intk ;inti=0;while((ilast--;returnok;篇二：线性表的基本操作实验报告实验一：线性表的基本操作【实验目的】学习掌握线性表的顺序存储结构、链式存储结构的设计与操作。
顺序表实验报告
顺序表实验报告
摘要：
一、实验背景及目的
二、实验对象与方法
三、实验结果与分析
四、实验总结与建议
正文：
一、实验背景及目的
随着科技的不断发展，顺序表在各种领域的应用越来越广泛。
为了进一步了解顺序表的性能和特点，本实验对顺序表进行了相关测试。
实验旨在通过对比分析，评估顺序表在不同条件下的表现，为后续研究与应用提供参考依据。
二、实验对象与方法
1.实验对象：某品牌顺序表产品
2.实验方法：
（1）根据实验需求，制定实验方案，明确实验步骤与评价标准；
（2）将顺序表产品置于不同环境下，如高温、低温、湿度等，观察其性能变化；
（3）通过数据记录与分析，评估顺序表在不同环境下的稳定性、可靠性和适用性。
三、实验结果与分析
1.顺序表在不同环境下的性能表现：
（1）在高温环境下，顺序表表现稳定，数据传输速率较快；
（2）在低温环境下，顺序表仍能正常工作，性能略有下降；
（3）在湿度较大的环境下，顺序表出现一定程度的性能波动，但整体表现良好。
2.分析：
（1）顺序表在不同环境下性能表现差异较小，说明产品具有较强的适应性；
（2）在湿度较大环境下，性能略有波动，可能与产品内部结构有关，需进一步优化；
（3）实验结果符合预期，顺序表产品具备较好的稳定性和可靠性。
顺序表基本算法实验报告
顺序表基本算法实验报告顺序表基本算法实验报告一、实验目的本次实验旨在深入了解顺序表的基本操作和算法，包括顺序表的创建、插入、删除、遍历等操作，通过实际操作加深对顺序表的理解和应用能力。
二、实验内容和步骤1.顺序表的创建我们首先需要创建一个顺序表。
顺序表在内存中以数组的形式存在。
我们定义一个数组，并使用数组的索引来访问和操作其中的元素。
def create_sequential_list(size):sequential_list = []for i in range(size):sequential_list.append(0)return sequential_list2.插入操作顺序表的插入操作包括在指定位置插入一个元素。
这个操作需要注意插入位置及其前后的元素的处理。
def insert_sequential_list(sequential_list, index, value):sequential_list.insert(index, value)3.删除操作删除操作则是从顺序表中移除一个指定位置的元素。
这个操作需要注意被删除元素的前后元素的处理。
def delete_sequential_list(sequential_list, index):sequential_list.pop(index)4.遍历操作遍历操作则是访问顺序表中的每一个元素。
我们可以使用for循环来遍历顺序表中的所有元素。
def traverse_sequential_list(sequential_list):for element in sequential_list:print(element)三、实验结果和分析通过以上实验，我们成功实现了顺序表的创建、插入、删除和遍历操作。
插入和删除操作的时间复杂度为O(n)，其中n为顺序表的大小。
遍历操作的时间复杂度为O(n)。
顺序表是一种简单高效的数据结构，适用于元素数量固定且频繁进行插入、删除和遍历操作的场景。
顺序表的实现实验报告
顺序表的实现实验报告顺序表的实现实验报告1. 引言顺序表是一种常见的数据结构，它可以用于存储一组有序的元素。
在本实验中，我们将探索顺序表的实现方式，并通过实验验证其性能和效果。
2. 实验目的本实验的主要目的是掌握顺序表的实现原理和基本操作，并通过实验对比不同操作的时间复杂度。
3. 实验方法3.1 数据结构设计我们选择使用静态数组作为顺序表的底层存储结构。
通过定义一个固定大小的数组，我们可以实现顺序表的基本操作。
3.2 基本操作实现在顺序表的实现中，我们需要实现以下基本操作：- 初始化操作：创建一个空的顺序表。
- 插入操作：向顺序表中插入一个元素。
- 删除操作：从顺序表中删除一个元素。
- 查找操作：在顺序表中查找指定元素。
- 获取长度：获取顺序表中元素的个数。
4. 实验步骤4.1 初始化操作首先，我们需要创建一个空的顺序表。
这可以通过定义一个数组和一个变量来实现，数组用于存储元素，变量用于记录当前顺序表的长度。
4.2 插入操作在顺序表中插入一个元素的过程如下：- 首先，判断顺序表是否已满，如果已满则进行扩容操作。
- 然后，将要插入的元素放入数组的末尾，并更新长度。
4.3 删除操作从顺序表中删除一个元素的过程如下：- 首先，判断顺序表是否为空，如果为空则返回错误信息。
- 然后，将数组中最后一个元素删除，并更新长度。
4.4 查找操作在顺序表中查找指定元素的过程如下：- 首先，遍历整个数组，逐个比较元素与目标元素是否相等。
- 如果找到相等的元素，则返回其位置；如果遍历完仍未找到，则返回错误信息。
4.5 获取长度获取顺序表中元素个数的过程如下：- 直接返回记录长度的变量即可。
5. 实验结果与分析在实验中，我们通过对大量数据进行插入、删除、查找等操作，记录了每个操作的耗时。
通过对比不同操作的时间复杂度，我们可以得出以下结论：- 初始化操作的时间复杂度为O(1)，因为只需要创建一个空的顺序表。
- 插入和删除操作的时间复杂度为O(n)，因为需要遍历整个数组进行元素的移动。
实验报告一 顺序表的操作
《数据结构》实验报告一系别：班级：学号：姓名：日期：指导教师：一、上机实验的问题和要求：顺序表的查找、插入与删除。
设计算法，实现线性结构上的顺序表的产生以及元素的查找、插入与删除。
具体实现要求：从键盘输入10个整数，产生顺序表，并输入结点值。
从键盘输入1个整数，在顺序表中查找该结点的位置。
若找到，输出结点的位置；若找不到，则显示“找不到”。
从键盘输入2个整数，一个表示欲插入的位置i，另一个表示欲插入的数值x，将x插入在对应位置上，输出顺序表所有结点值，观察输出结果。
从键盘输入1个整数，表示欲删除结点的位置，输出顺序表所有结点值，观察输出结果。
二、程序设计的基本思想，原理和算法描述：（包括程序的结构，数据结构，输入/输出设计，符号名说明等）三、源程序及注释：#include <stdio.h>/*顺序表的定义：*/#define ListSize 100 /*表空间大小可根据实际需要而定，这里假设为100*/ typedef int DataType; /*DataType可以是任何相应的数据类型如int, float或char*/ typedef struct{ DataType data[ListSize]; /*向量data用于存放表结点*/int length; /*当前的表长度*/}SeqList;/*子函数的声明*/void CreateList(SeqList * L,int n); /*创建顺序表函数*/int LocateList(SeqList L,DataType x); /*查找顺序表*/void InsertList(SeqList * L,DataType x,int i); /*在顺序表中插入结点x*/void DeleteList(SeqList * L,int i);/*在顺序表中删除第i个结点*/void PrintList(SeqList L,int n); /*打印顺序表中前n个结点*/void main(){SeqList L;int n=10,x,i; /*欲建立的顺序表长度*/L.length=0;/*调用创建线性表函数*/printf("create function:\n");CreateList(&L,n); /*建立顺序表*/PrintList(L,n); /*打印顺序表*//*调用查找函数*/printf("search function:\n");printf("input the data you want to search:");scanf("%d",&x);i=LocateList(L,x); /*顺序表查找*/if (i==0)printf("sorry,don't find %d!\n\n",x);elseprintf("i have find the %d，it locate in %d!\n\n",x,i);/*调用插入函数*/printf("Insert function:\n");printf("输入要插入的位置：(input the position:)");scanf("%d",&i);printf("输入要插入的元素：(input the data:)");scanf("%d",&x);InsertList(&L,x,i); /*顺序表插入 */PrintList(L,n); /*打印顺序表 *//*调用删除函数*/printf("delete function:\n");printf("输入要删除的位置：(input the position:)");scanf("%d",&i);DeleteList(&L,i); /*顺序表删除 */PrintList(L,n); /*打印顺序表 */}/*顺序表的建立：*/void CreateList(SeqList *L,int n){ int i;for (i=0;i<n;i++){ printf("\ninput the %d data:",i+1);scanf("%d",&(*L).data[i]);}(*L).length=n;}/*顺序表的查找：*/int LocateList(SeqList L,DataType x){ int i=0;while (i<L.length&&x!=L.data[i])++i;if (i<L.length) return i+1;else return 0;}/*顺序表的插入：*/void InsertList(SeqList *L,DataType x,int i){/*将新结点x插入L所指的顺序表的第i个结点的位置上 */ int j;if (i<0||i>(*L).length){printf("插入位置非法");exit(0);}if ((*L).length>=ListSize){printf("表空间溢出，退出运行");exit(0);}for (j=(*L).length-1;j>=i-1;j--)(*L).data[j+1]=(*L).data[j]; /*顺序表元素从后向前依次后移*/ (*L).data[i-1]=x; /*将x插入第i个结点位置*/(*L).length++; /*表长自增1*/}/*顺序表的删除：*/void DeleteList(SeqList *L,int i){/*从L所指的顺序表中删除第i个结点 */int j;if (i<0 || i>(*L).length){printf("删除位置非法");exit(0);}for (j=i;j<=(*L).length-1;j++)(*L).data[j]=(*L).data[j+1]; /*顺序表自第i个结点开始，依次前移*/ (*L).length--; /*表长自减1*/}/*顺序表的打印：*/void PrintList(SeqList L,int n){ int i;printf("the sequal list data is:");for (i=0;i<n;i++)printf("%d ",L.data[i]);printf("\n\n");}四、运行输出结果：五、调试和运行程序过程中产生的问题及采取的措施：六、对算法的程序的讨论、分析，改进设想，其它经验教训：七、对实验方式、组织、设备、题目的意见和建议：。
顺序表的操作实验报告
顺序表的操作实验报告顺序表的操作实验报告一、引言顺序表是一种常见的数据结构，它在计算机科学中被广泛应用。
本实验旨在通过实际操作顺序表，探索其基本操作和性能。
二、实验目的1. 理解顺序表的基本原理和数据结构；2. 掌握顺序表的插入、删除、查找等操作；3. 分析顺序表操作的时间复杂度。
三、实验过程1. 初始化顺序表：首先，我们创建一个空的顺序表，并设定其初始长度为10。
2. 插入元素：在顺序表中插入若干个元素，观察插入操作的效果。
我们可以通过在表尾插入元素，或者在表中间插入元素来测试插入操作的性能。
3. 删除元素：从顺序表中删除指定位置的元素，并观察删除操作的效果。
我们可以选择删除表尾元素或者表中间元素来测试删除操作的性能。
4. 查找元素：在顺序表中查找指定元素，并返回其位置。
我们可以选择查找表头元素、表尾元素或者表中间元素来测试查找操作的性能。
5. 扩容操作：当顺序表的长度不足以容纳更多元素时，我们需要进行扩容操作。
在实验中，我们可以在插入元素时观察到扩容操作的效果。
四、实验结果与分析1. 初始化顺序表：成功创建了一个长度为10的空顺序表。
2. 插入元素：通过在表尾插入10个元素，我们观察到插入操作的时间复杂度为O(1)。
然而，当我们在表中间插入元素时，需要将插入位置之后的所有元素后移，时间复杂度为O(n)。
3. 删除元素：从表尾删除元素的时间复杂度为O(1)，而从表中间删除元素需要将删除位置之后的所有元素前移，时间复杂度为O(n)。
4. 查找元素：在顺序表中查找元素的时间复杂度为O(n)，因为需要逐个比较每个元素。
5. 扩容操作：当顺序表的长度不足以容纳更多元素时，我们需要进行扩容操作。
在实验中，我们观察到扩容操作的时间复杂度为O(n)，因为需要将原有元素复制到新的更大的空间中。
五、实验总结通过本次实验，我们深入了解了顺序表的基本操作和性能。
顺序表的插入、删除和查找操作的时间复杂度与操作位置有关，需要注意选择合适的操作位置以提高效率。
实验一顺序表的基本操作实验报告
元素之后的所有数据都前移一个位置，最将线性表长减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语言的认识掌并掌握了线性表的顺序存储结构的表示和实现方法，掌握顺序表基本操作的算法实现，同时了解了顺序表的应用。
实验一 顺序表 实验报告
顺序表实验报告一、实验内容和目的实验目的：掌握顺序表的建立、查找、插入和删除操作。
掌握有序表的建立、合并、插入操作。
实验内容：1. 顺序表的建立2. 顺序表的遍历3. 顺序表的元素查找4. 顺序表的元素插入5. 顺序表的元素删除6. 有序表的建立7. 有序表的遍历8. 有序表的元素插入9. 有序表的合并二、实验原理基本原理：通过连续的地址空间实现逻辑上和物理上连续的储存的一系列元素。
并在此基础上进行元素的添加，查找，删除操作。
有序表的插入算法：元素插入之前的，先跟有序表中的逐个元素进行对比，以找到合适的插入位置。
例如，已有有序表L，要向L 中插入元素18L={13,15,17,19,20,35,40}第一步：将18与L1进行比较，18 > L1，不是合适的插入位置。
第二步：将18与L2进行比较，18>L2，仍然不是不是的插入位置。
重复上述步骤，知道找到18≤Ln，然后在(n-1) 和n之间插入元素。
（如果元素比有序表中的所有元素都要大，则把该元素放到有序表的最后）此例子中，L n-1 = 17，L n = 19插入元素之后的有序表L为：L′={13,15,17,18,19,20,35,40}仍然保持有序。
重置光标的位置：程序接受两种方式的输入。
一种是输入数字后按回车，一种是利用空格间隔的连续几个数字。
然而，在使用后者输入数字的时候，会出现提示输出不正确的问题。
（如图）这个问题的原因简单如下：当程序输出“请输入第2个数字：”的时候，应该等待用户输入；然而，在程序等待输入第一个数字的时候，用户输入了五个数字。
因此，程序输出“输入第2个提示以后”，程序发现仍然有数据没有进行处理，因此把上次输入但未处理的字符当成是用户的输入。
所以没让用户输入数据就自动继续执行。
解决这个问题的思路：每次输出提示时，将光标移动到行首，因此，输出提示的时候会自动覆盖已经输出的提示信息。
效果如下：具体的解决方法：#include<windows.h>// 将光标移动到行首void ResetCursor(){HANDLE hOut;COORD cTarget;CONSOLE_SCREEN_BUFFER_INFO info;int y = 0;hOut = GetStdHandle(STD_OUTPUT_HANDLE);GetConsoleScreenBufferInfo(hOut, &info);y = info.dwCursorPosition.Y;cTarget.X = 0;cTarget.Y = y;SetConsoleCursorPosition(hOut, cTarget);}三、程序流程图四、实现步骤4.1 创建顺序表的实现①通过scanf 函数从键盘中读入数据，并通过scanf函数的返回值判断用户输入的是数字还是非数字，作为判断输入结束的判断。
数据结构-顺序表-实验报告
实验报告课程数据结构及算法实验项目 1.顺序表的建立和基本运算成绩专业班级*** 指导教师***姓名*** 学号*** 实验日期***实验一顺序表的建立和基本运算一、实验目的1、掌握顺序表存储结构的定义及C/C++语言实现2、掌握顺序表的各种基本操作及C/C++语言实现3、设计并实现有序表的遍历、插入、删除等常规算法二、实验环境PC微机，Windows，DOS，Turbo C或者Visual C++三、实验内容1、顺序表的建立和基本运算（1）问题描述顺序表时常进行的运算包括：创建顺序表、销毁顺序表、求顺序表的长度、在顺序表中查找某个数据元素、在某个位置插入一个新数据元素、在顺序表中删除某个数据元素等操作。
试编程实现顺序表的这些基本运算。
（2）基本要求实现顺序表的每一个运算要求用一个函数实现。
（3）算法描述参见教材算法2.3、算法2.4、算法2.5等顺序表的常规算法。
（4）算法实现#include<malloc.h> // malloc()等#include<stdio.h> // NULL, printf()等#include<process.h> // exit()// 函数结果状态代码#define OVERFLOW -2#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1typedef int Status; // Status是函数的类型,其值是函数结果状态代码，如OK等typedef int Boolean; // Boolean是布尔类型,其值是TRUE或者FALSE//-------- 线性表的动态分配顺序存储结构-----------#define LIST_INIT_SIZE 10 // 线性表存储空间的初始分配量#define LIST_INCREMENT 2 // 线性表存储空间的分配增量typedef int ElemType;struct SqList{ElemType *elem; // 存储空间基址int length; // 当前长度int listsize; // 当前分配的存储容量(以sizeof(int)为单位)};void InitList(SqList &L) // 算法2.3{ // 操作结果：构造一个空的顺序线性表LL.elem=new ElemType[LIST_INIT_SIZE];if(!L.elem)exit(OVERFLOW); // 存储分配失败L.length=0; // 空表长度为0L.listsize=LIST_INIT_SIZE; // 初始存储容量}void DestroyList(SqList &L){ // 初始条件：顺序线性表L已存在。
线性表逆置(顺序表)实验报告
ElemType *p;
int i;
p=L.elem;
for(i=1;i<=L.length;i++)
vi(p++);
printf("\n");
return OK;
}
/*逆置链表的程序*/
void change(SqList *L) /*逆置算法*/
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
/* #define OVERFLOW -2因为在math.h中已定义OVERFLOW的值为3,故去掉此行*/
typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等*/
{
scanf("%d",&e);
i=ListInsert(&L,j,e);
}
}prLeabharlann ntf("逆置前的表：L= "); /*输出表L的内容*/
ListTraverse(L,print);
change(&L);
printf("逆置后的表：L= "); /*输出新表L的内容*/
ListTraverse(L,print);
{
ElemType e;
int L_len;
int i;
L_len=ListLength(*L); /*求线性表的长度*/
for(i=0;i<=L_len/2;i++)
数据结构实验一顺序表实验报告
数据结构实验一顺序表实验报告一、实验目的本次实验的主要目的是通过实现顺序表的基本操作，深入理解线性表的逻辑结构和存储结构，掌握顺序表的插入、删除、查找等操作的实现方法，提高编程能力和问题解决能力。
二、实验环境本次实验使用的编程语言为 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. 顺序表实验a. 创建一个包含100个元素的顺序表；b. 在表尾插入一个元素；c. 在表头插入一个元素；d. 在表的中间位置插入一个元素；e. 删除表尾的一个元素；f. 删除表头的一个元素；g. 删除表的中间位置的一个元素；h. 查找一个元素；i. 遍历整个顺序表。
2. 链表实验a. 创建一个包含100个节点的链表；b. 在链表尾部插入一个节点；c. 在链表头部插入一个节点；d. 在链表的中间位置插入一个节点；e. 删除链表尾部的一个节点；f. 删除链表头部的一个节点；g. 删除链表的中间位置的一个节点；h. 查找一个节点；i. 遍历整个链表。
四、实验结果与分析1. 顺序表实验结果a. 在表尾插入一个元素的平均时间为0.1ms；b. 在表头插入一个元素的平均时间为0.2ms；c. 在表的中间位置插入一个元素的平均时间为0.5ms；d. 删除表尾的一个元素的平均时间为0.1ms；e. 删除表头的一个元素的平均时间为0.2ms；f. 删除表的中间位置的一个元素的平均时间为0.5ms；g. 查找一个元素的平均时间为1ms；h. 遍历整个顺序表的平均时间为10ms。
2. 链表实验结果a. 在链表尾部插入一个节点的平均时间为0.2ms；b. 在链表头部插入一个节点的平均时间为0.1ms；c. 在链表的中间位置插入一个节点的平均时间为0.5ms；d. 删除链表尾部的一个节点的平均时间为0.2ms；e. 删除链表头部的一个节点的平均时间为0.1ms；f. 删除链表的中间位置的一个节点的平均时间为0.5ms；g. 查找一个节点的平均时间为2ms；h. 遍历整个链表的平均时间为5ms。
顺序表的查找插入与删除实验报告
顺序表的查找插入与删除实验报告顺序表的查找、插入与删除实验报告《数据结构》实验报告一学院：班级：姓名：程序名学号：日期：一、上机实验的问题和要求：顺序表的搜寻、填入与删掉。
设计算法，同时实现线性结构上的顺序表的产生以及元素的搜寻、填入与删掉。
具体内容同时实现建议：1.从键盘输入10个整数，产生顺序表，并输入结点值。
2.从键盘输入1个整数，在顺序表搜寻该结点的边线。
若找出，输入结点的边线；若打听不到，则显示“找不到”。
3.从键盘输入2个整数，一个则表示欲填入的边线i，另一个则表示欲填入的数值x，将x挂入在对应位置上，输出顺序表所有结点值，观察输出结果。
4.从键盘输入1个整数，表示欲删除结点的位置，输出顺序表所有结点值，观察输出结果。
二、源程序及注解：#include#include/*顺序表的定义：*/#include#definelistsize100/*表空间大小可根据实际需要而定，这里假设为100*/typedefintdatatype;/*datatype可以是任何相应的数据类型如int,float或char*/typedefstruct{datatypedata[listsize];/*向量data用作放置表中结点*/intlength;/*当前的表中长度*/}seqlist;voidmain(){seqlistl;inti,x;intn=10;/*欲建立的顺序表长度*/l.length=0;voidcreatelist(seqlist*l,intn);voidprintlist(seqlistl,intn);intlo catelist(seqlistl,datatypex);voidinsertlist(seqlist*l,datatypex,inti);voiddele telist(seqlist*l,inti);1createlist(&l,n);/*建立顺序表*/printlist(l,n);/*打印顺序表*/printf(\输入要查找的值：\scanf(\i=locatelist(l,x);/*顺序表查找*/printf(\输入要插入的位置：\scanf(\printf(\输入要插入的元素：\scanf(\insertlist(&l,x,i);/*顺序表插入*/printlist(l,n);/*打印顺序表*/printf(\输入要删除的位置：\scanf(\deletelist(&l,i);/*顺序表删除*/printlist(l,n);/*打印顺序表*/}/*顺序表的创建：*/voidcreatelist(seqlist*l,intn){inti;for(i=0;ilength=n;}/*顺序表的列印：*/voidprintlist(seqlistl,intn){inti;for(i=0;i/*顺序表的查找：*/intlocatelist(seqlistl,datatypex){inti=0;while(iif(i2/*顺序表的插入：*/voidinsertlist(seqlist*l,datatypex,inti){intj;if(i<1||i>l->length+1){printf(\插入位置非法\\n\exit(0);}if(l->length>=listsize){printf(\表空间溢出，退出运行\\n\exit(0);}for(j=l->length-1;j>=i-1;j--)l->data[j+1]=l->data[j];l->data[i-1]=x;l->length++;}/*顺序表的删除：*/voiddeletelist(seqlist*l,inti){intj;if(l->length==0){printf(\现行表为空，退出运行\\n\exit(0);}if(i<1||i>l->length){printf(\删除位置非法\\n\exit(0);}for(j=i;j<=l->length-1;j++)l->data[j-1]=l->data[j];l->length--;}3三、运行输出结果：四、调试和运行程序过程中产生的问题及采取的措施：4。
顺序表实验报告
顺序表实验报告实验名称：顺序表的实现与操作实验目的：1.理解顺序表的概念、特点和实现方式。
2.掌握顺序表的基本操作，包括初始化、插入、删除、查找、修改、清空等操作。
3.提高编程能力，加深对数据结构的理解。
实验原理：顺序表是数据结构中的一种线性表，采用连续的存储方式来存储元素，其具有访问速度快的特点。
在顺序表中，元素在物理存储上是连续的，每个元素占据一定的存储空间。
顺序表的实现需要使用数组，可以通过数组下标查找具体元素，也可以通过数组长度限定表的大小。
实验步骤：1.定义顺序表结构体struct SeqList{int size;//表的大小int length;//表的长度int *data;//存储数据的指针};2.初始化操作void initSeqList(SeqList &list,int size){list.size = size;list.length = 0;list.data = new int[size];}3.插入操作void insertSeqList(SeqList &list,int pos,int elem){ if(pos<1 || pos>list.length+1){cout<<"位置不合法"<<endl;return;}if(list.length>=list.size){cout<<"顺序表已满"<<endl;return;}for(int i=list.length-1; i>=pos-1; i--){list.data[i+1] = list.data[i];}list.data[pos-1] = elem;list.length++;}4.删除操作void deleteSeqList(SeqList &list,int pos){ if(pos<1 || pos>list.length){cout<<"位置不合法"<<endl;return;}for(int i=pos-1; i<list.length-1; i++){ list.data[i] = list.data[i+1];}list.length--;}5.查找操作int searchSeqList(SeqList list,int elem){for(int i=0; i<list.length; i++){if(list.data[i] == elem){return i+1;}}return 0;}6.修改操作void modifySeqList(SeqList &list,int pos,int elem){ if(pos<1 || pos>list.length){cout<<"位置不合法"<<endl;return;}list.data[pos-1] = elem;}7.清空操作void clearSeqList(SeqList &list){list.length = 0;}实验结果：经过上述实验操作，成功实现了顺序表的初始化、插入、删除、查找、修改、清空等操作，并能够正确输出结果。
数据结构实验报告顺序表1
数据结构实验报告顺序表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. 了解顺序表的基本概念和操作方法；2. 掌握顺序表的插入、删除、查找等操作；3. 熟悉顺序表的存储结构和实现方式。
二、实验内容。
1. 实现顺序表的基本操作，包括插入、删除、查找等；2. 对比顺序表和链表的优缺点；3. 分析顺序表的存储结构和实现方式。
三、实验原理。
顺序表是一种线性表的存储结构，它的特点是元素之间的逻辑顺序和物理顺序一致，即在内存中连续存储。
顺序表的基本操作包括插入、删除、查找等。
1. 插入操作，在顺序表的某个位置插入一个元素，需要将插入位置后的所有元素向后移动一个位置，然后将新元素插入到指定位置。
2. 删除操作，删除顺序表中的某个元素，需要将删除位置后的所有元素向前移动一个位置，然后将最后一个元素删除。
3. 查找操作，在顺序表中查找某个元素，需要遍历整个顺序表，逐个比较元素的值，直到找到目标元素或者遍历完整个表。
四、实验步骤。
1. 实现顺序表的基本操作，包括插入、删除、查找等；2. 编写测试用例，验证顺序表的功能和正确性；3. 对比顺序表和链表的优缺点，分析其适用场景；4. 分析顺序表的存储结构和实现方式，总结其特点和应用场景。
五、实验结果与分析。
1. 实现了顺序表的基本操作，包括插入、删除、查找等，功能正常；2. 经过测试用例验证，顺序表的功能和正确性得到了验证；3. 对比顺序表和链表的优缺点，发现顺序表的插入、删除操作效率较低，但查找操作效率较高，适合静态查找；4. 分析顺序表的存储结构和实现方式，发现其适用于元素数量较少且频繁查找的场景。
六、实验总结。
通过本次实验，我们深入了解了顺序表的基本概念和操作方法，掌握了顺序表的插入、删除、查找等操作。
同时，我们对比了顺序表和链表的优缺点，分析了顺序表的存储结构和实现方式，加深了对顺序表的理解和应用。
在今后的学习和工作中，我们将根据实验结果的分析，合理选择顺序表或链表作为数据结构，以满足不同场景下的需求。
顺序表的操作实验报告
顺序表的操作实验报告一、实验目的。
本实验旨在通过对顺序表的操作进行实验，加深对顺序表的理解，掌握顺序表的基本操作方法，提高编程能力。
二、实验内容。
1. 初始化顺序表。
2. 插入元素。
3. 删除元素。
4. 查找元素。
5. 修改元素。
6. 输出顺序表。
三、实验步骤。
1. 初始化顺序表。
首先，我们需要定义一个顺序表的结构体，包括数据元素和表长两个成员变量。
然后，通过malloc函数为顺序表分配内存空间，并初始化表长为0，表示顺序表为空表。
2. 插入元素。
插入元素是指在顺序表的指定位置插入一个新的元素。
首先，需要判断插入位置是否合法，然后将插入位置后的元素依次向后移动一位，腾出位置给新元素，最后将新元素插入到指定位置。
3. 删除元素。
删除元素是指在顺序表中删除指定位置的元素。
同样需要判断删除位置是否合法，然后将删除位置后的元素依次向前移动一位，覆盖被删除的元素，最后将表长减一。
4. 查找元素。
查找元素是指在顺序表中查找指定数值的元素，并返回其位置。
可以通过顺序遍历顺序表，逐个比较元素的数值，找到匹配的元素后返回其位置。
5. 修改元素。
修改元素是指在顺序表中修改指定位置的元素的数值。
首先需要判断修改位置是否合法，然后直接修改指定位置的元素数值即可。
6. 输出顺序表。
输出顺序表是指将顺序表中的所有元素依次输出。
可以通过循环遍历顺序表，逐个输出元素的数值。
四、实验结果。
经过实验操作，我们成功实现了顺序表的初始化、插入、删除、查找、修改和输出操作。
通过实验，我们加深了对顺序表的理解，掌握了顺序表的基本操作方法。
五、实验总结。
顺序表是一种基本的数据结构，具有较高的操作效率。
通过本次实验，我们进一步理解了顺序表的内部实现原理，掌握了顺序表的基本操作方法，提高了编程能力。
在今后的学习和工作中，我们将进一步应用顺序表的相关知识，提高自己的编程水平。
六、参考资料。
1. 《数据结构与算法分析》。
2. 《C语言程序设计》。
以上为本次顺序表的操作实验报告内容，希望能对大家有所帮助。
数据结构实验一顺序表实验报告
数据结构实验一顺序表实验报告数据结构实验一顺序表实验报告一、实验目的顺序表是一种基本的数据结构，本次实验的目的是通过实现顺序表的基本操作，加深对顺序表的理解，并掌握顺序表的插入、删除、查找等操作的实现方法。
二、实验内容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、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
《数据结构》实验报告一系别：嵌入式系统工程系班级：嵌入式11003班学号：11160400314 姓名：xxx日期：2012年4月9日指导教师XX一、上机实验的问题和要求：顺序表的查找、插入与删除。
设计算法，实现线性结构上的顺序表的产生以及元素的查找、插入与删除。
具体实现要求：1.从键盘输入10个整数，产生顺序表，并输入结点值。
2.从键盘输入1个整数，在顺序表中查找该结点的位置。
若找到，输出结点的位置；若找不到，则显示“找不到”。
3.从键盘输入2个整数，一个表示欲插入的位置i，另一个表示欲插入的数值x，将x插入在对应位置上，输出顺序表所有结点值，观察输出结果。
4.从键盘输入1个整数，表示欲删除结点的位置，输出顺序表所有结点值，观察输出结果。
二、程序设计的基本思想，原理和算法描述：（包括程序的结构，数据结构，输入/输出设计，符号名说明等）创建一个顺序表，实现对顺序表的插入，查找，删除等功能。
三、源程序及注释：#include <stdio.h>/*顺序表的定义：*/#define ListSize 100 /*表空间大小可根据实际需要而定，这里假设为100*/typedef int DataType; /*DataType可以是任何相应的数据类型如int, float或char*/ typedef struct{ DataType data[ListSize]; /*向量data用于存放表结点*/int length; /*当前的表长度*/}SeqList;/*子函数的声明*/void CreateList(SeqList * L,int n); /*创建顺序表函数*/int LocateList(SeqList L,DataType x); /*查找顺序表*/void InsertList(SeqList * L,DataType x,int i); /*在顺序表中插入结点x*/ void DeleteList(SeqList * L,int i);/*在顺序表中删除第i个结点*/void PrintList(SeqList L,int n); /*打印顺序表中前n个结点*/void main(){SeqList L;int n=10,x,i; /*欲建立的顺序表长度*/L.length=0;/*调用创建线性表函数*/printf(“create function:\n”);CreateList(&L,n); /*建立顺序表*/PrintList(L,n); /*打印顺序表*//*调用查找函数*/printf(“search function:\n”);printf("input the data you want to search:");scanf("%d",&x);i=LocateList(L,x); /*顺序表查找*/if (i==0)printf("sorry,don't find %d!\n\n",x);elseprintf("i have find the %d，it locate in %d!\n\n",x,i);/*调用插入函数*/printf(“Insert function:\n”);printf("输入要插入的位置：(input the position:)");scanf("%d",&i);printf("输入要插入的元素：(input the data:)");scanf("%d",&x);InsertList(&L,x,i); /*顺序表插入 */PrintList(L,n); /*打印顺序表 *//*调用删除函数*/printf(“delete function:\n”);printf("输入要删除的位置：(input the position:)");scanf("%d",&i);DeleteList(&L,i); /*顺序表删除 */PrintList(L,n); /*打印顺序表 */}/*顺序表的建立：*/void CreateList(SeqList *L,int n){ int i;for (i=0;i<n;i++){printf("\ninput the %d data:",i+1);scanf("%d",&(*L).data[i]);}(*L).length=n;}/*顺序表的查找：*/int LocateList(SeqList L,DataType x){ int i=0;while (i<___=L.length-1______________ && ____L.data[i]_=!e______________) ++i;if (i<L.length) return i+1;else return 0;}/*顺序表的插入：*/void InsertList(SeqList *L,DataType x,int i){/*将新结点x插入L所指的顺序表的第i个结点的位置上 */int j;if (i<1 || i>__L.length____________________){printf("插入位置非法");exit(0);}if ((*L).length>=___MaxSize_______________){printf("表空间溢出，退出运行");exit(0);}for (j=(*L).length-1;j>=i-1;j--)____L.data[k+1]=L.data[k]_______________________________ ; /*顺序表元素从后向前依次后移*/____L.data[i-1]=e_______________________________; /*将x插入第i个结点位置*/ _____L.length++___________________________; /*表长自增1*/}/*顺序表的删除：*/void DeleteList(SeqList *L,int i){/*从L所指的顺序表中删除第i个结点 */int j;if (i<1 || i>___L.length____________________________){printf("删除位置非法");exit(0);}for (j=i;j<=(*L).length-1;j++)____L.data[k-1]=L.data[k]________________________________; /*顺序表自第i个结点开始，依次前移*/______L.length--__________________________; /*表长自减1*/}/*顺序表的打印：*/void PrintList(SeqList L,int n){ int i;printf(“the sequal list data is:”);for (i=0;i<n;i++)printf("%d ",L.data[i]);printf("\n\n");}调试后的代码：#include<stdio.h>#define MaxSize 100typedef int Datatype;typedef struct{Datatype data[MaxSize];int length;}seqlist;void GreatList(seqlist*L,int n);int GetList(seqlist L, Datatype x);int IntList(seqlist *L,Datatype x,int i);int DelList(seqlist L,int i,Datatype *x);void PrintList(seqlist L,int n);void main(){seqlist L;int n=10,x,i;L.length=0;printf("great function:\n");GreatList(&L,n);PrintList(L,n);printf("get function:\n");printf("please input your want to search\n");scanf("%d",&x);i=GetList(L,x);if(i==0){printf("\nsorry,don't find %d\n",x);}else{printf("\nhave find the %d,it located in %d\n",x,i);}printf("\nIns function:\n");printf("\nplease input the position: \n");scanf("%d",&i);printf("\nplease input the data:\n");scanf("%d",&x);IntList(&L,i,x);PrintList(L,n);printf("\ndel function:\n");printf("\nplease input you want to delete position:\n"); scanf("%d",&i);printf("\nplease input you want delete number: ");scanf("%d",&x);DelList(L,i,&x);PrintList(L,n);//getch();}void GreatList(seqlist *L,int n){int i;for(i=0;i<n;i++){printf("\nplease input the %d data \n",i+1); scanf("%d",&(*L).data[i]);}(*L).length=n;}int GetList(seqlist L,Datatype x){int i;i=0;while((i<=L.length-1)&&(L.data[i]!=x))i++;if(i<L.length)return(i+1);elsereturn(-1);}int IntList(seqlist *L,Datatype x,int i){int k;if((i<1)||(i>L->length)){printf("\nThe position is wrong\n");return(0);}if(L->length>=MaxSize){printf("\nempty\n");return(0);}for(k=L->length-1;k>=i-1;i++){L->data[k+1]=L->data[k];L->data[i-1]=x;L->length++;}return(1);}int DelList(seqlist L,int i,Datatype *x){int k;if((i<1)||(i>L.length)){printf("\nThe position is wrong\n"); return(0);}*x=L.data[i-1];for(k=i;i<=L.length;k++){L.data[k-1]=L.data[k];L.length--;}return(1);}void PrintList(seqlist L,int n){int i;printf("\nThe sequal List Data is: \n"); for(i=0;i<n;i++)printf("%d ",L.data[i]);printf("\n");}四、运行输出结果：五、调试和运行程序过程中产生的问题及采取的措施：开始只是一些小的问题，如丢了分号、括号，单词写错了，前后不一致等等。