实验一.顺序表验证实验

顺序表实验报告

顺序表实验报告
摘要：
一、实验背景及目的
二、实验对象与方法
三、实验结果与分析
四、实验总结与建议
正文：
一、实验背景及目的
随着科技的不断发展，顺序表在各种领域的应用越来越广泛。

为了进一步了解顺序表的性能和特点，本实验对顺序表进行了相关测试。

实验旨在通过对比分析，评估顺序表在不同条件下的表现，为后续研究与应用提供参考依据。

二、实验对象与方法
1.实验对象：某品牌顺序表产品
2.实验方法：
（1）根据实验需求，制定实验方案，明确实验步骤与评价标准；
（2）将顺序表产品置于不同环境下，如高温、低温、湿度等，观察其性能变化；
（3）通过数据记录与分析，评估顺序表在不同环境下的稳定性、可靠性和适用性。

三、实验结果与分析
1.顺序表在不同环境下的性能表现：
（1）在高温环境下，顺序表表现稳定，数据传输速率较快；
（2）在低温环境下，顺序表仍能正常工作，性能略有下降；
（3）在湿度较大的环境下，顺序表出现一定程度的性能波动，但整体表现良好。

2.分析：
（1）顺序表在不同环境下性能表现差异较小，说明产品具有较强的适应性；
（2）在湿度较大环境下，性能略有波动，可能与产品内部结构有关，需进一步优化；
（3）实验结果符合预期，顺序表产品具备较好的稳定性和可靠性。

实验报告一顺序表的操作

《数据结构》实验报告一系别：班级：学号：姓名：日期：指导教师：一、上机实验的问题和要求：顺序表的查找、插入与删除。

设计算法，实现线性结构上的顺序表的产生以及元素的查找、插入与删除。

具体实现要求：从键盘输入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、实验目的∙掌握线性表的逻辑特征∙掌握线性表顺序存储结构的特点，熟练掌握顺序表的基本运算2、实验内容：建立顺序表，完成顺序表的基本操作：初始化、插入、删除、逆转、输出、销毁, 置空表、求表长、查找元素、判线性表是否为空；1．问题描述：利用顺序表,设计一组输入数据（假定为一组整数），能够对顺序表进行如下操作：∙创建一个新的顺序表，实现动态空间分配的初始化；∙根据顺序表结点的位置插入一个新结点(位置插入)，也可以根据给定的值进行插入(值插入)，形成有序顺序表；∙根据顺序表结点的位置删除一个结点(位置删除)，也可以根据给定的值删除对应的第一个结点，或者删除指定值的所有结点(值删除)；∙利用最少的空间实现顺序表元素的逆转；∙实现顺序表的各个元素的输出；∙彻底销毁顺序线性表，回收所分配的空间；∙对顺序线性表的所有元素删除，置为空表；∙返回其数据元素个数；∙按序号查找，根据顺序表的特点，可以随机存取，直接可以定位于第i 个结点，查找该元素的值，对查找结果进行返回；∙按值查找，根据给定数据元素的值，只能顺序比较，查找该元素的位置，对查找结果进行返回；∙判断顺序表中是否有元素存在，对判断结果进行返回；.编写主程序，实现对各不同的算法调用。

2．实现要求：∙“初始化算法”的操作结果：构造一个空的顺序线性表。

对顺序表的空间进行动态管理，实现动态分配、回收和增加存储空间；∙“位置插入算法”的初始条件：顺序线性表L 已存在，给定的元素位置为i，且1≤i≤ListLength(L)+1 ；操作结果：在L 中第i 个位置之前插入新的数据元素e，L 的长度加1；∙“位置删除算法”的初始条件：顺序线性表L 已存在，1≤i≤ListLength(L) ；操作结果：删除L 的第i 个数据元素，并用e 返回其值，L 的长度减1 ；∙“逆转算法”的初始条件：顺序线性表L 已存在；操作结果：依次对L 的每个数据元素进行交换，为了使用最少的额外空间，对顺序表的元素进行交换；∙“输出算法”的初始条件：顺序线性表L 已存在；操作结果：依次对L 的每个数据元素进行输出；∙“销毁算法”初始条件：顺序线性表L 已存在；操作结果：销毁顺序线性表L；∙“置空表算法”初始条件：顺序线性表L 已存在；操作结果：将L 重置为空表；∙“求表长算法”初始条件：顺序线性表L 已存在；操作结果：返回L 中数据元素个数；∙“按序号查找算法”初始条件：顺序线性表L 已存在，元素位置为i，且1≤i≤ListLength(L)操作结果：返回L 中第i 个数据元素的值∙“按值查找算法”初始条件：顺序线性表L 已存在，元素值为e；操作结果：返回L 中数据元素值为e 的元素位置；∙“判表空算法”初始条件：顺序线性表L 已存在；操作结果：若L 为空表，则返回TRUE，否则返回FALSE；分析: 修改输入数据，预期输出并验证输出的结果，加深对有关算法的理解。

实验一顺序表的基本操作实验报告

元素之后的所有数据都前移一个位置，最将线性表长减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-顺序表操作

《数据结构》实验报告实验名称：顺序表的操作专业：计算机科学与技术班级：本1103学号：201108111122 姓名：秦文杰提交日期：2012.10.8一、实验目的熟练掌握线性表的类型定义方法、顺序存储方法及其基本运算（元素的插入、删除等）的实现方法，培养综合运用所学知识，根据具体问题进行数据结构设计和算法设计的能力。

二、实验要求1．在问题分析的基础上选择顺序存储结构，进行算法设计，编制程序并上机调试成功。

2．按要求完成实验报告3．保存和打印出程序的运行结果，并结合程序进行分析。

三、实验内容设计实现一个顺序表操作的综合应用程序。

要求：实现顺序表的构造、插入、删除、显示以及查找功能。

（基本要求）四、实验设计及测试结果1.数据结构typedef struct {int *elem;int length;int listsize;}SqList;2.函数调用层次结构图1 函数调用层次结构3.函数功能说明Createlist函数：创建一个顺序表；Printlist函数：输出顺序表；listinsert函数：在顺序表的第i个元素之前插入一个元素；listdelete函数：在顺序表中删除第i个元素；locatelem函数：在顺序表中查找与e等值的元素；4. 测试结果与分析上述程序在Visual C++ 6.0环境下加以实现。

经过多次测试，程序运行正确。

运行结果如图2所示。

图2 运行结果五、收获与体会通过这次课程设计:a)我进一步巩固了C语言的基础，尤其是编写C语言的结构及算法转化程序的方法。

b)做实验达到了理论与实践结合的目的，提高了自己的编程能力，c)程序由算法和数据结构组成，一个好的程序不仅算法重要，数据结构的设计也很重要。

d)程序不够简洁，还有待改进，功能还有待更完善，下一步需要改进程序为菜单形式！六、源程序#include <iostream.h>#include <malloc.h>//如需要用到其它头文件请加入。

实验一顺序表实验报告

顺序表实验报告一、实验内容和目的实验目的：掌握顺序表的建立、查找、插入和删除操作。

掌握有序表的建立、合并、插入操作。

实验内容：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已存在。

数据结构实验(使用版)

实验一顺序表的应用一．实验目的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

数据结构实验报告顺序表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。

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.顺序表验证实验

线性表实验一顺序表操作验证1. 实验目的⑴掌握线性表的顺序存储结构；⑵验证顺序表及其基本操作的实现；⑶掌握数据结构及算法的程序实现的基本方法。

2. 实验内容⑴建立含有若干个元素的顺序表；⑵对已建立的顺序表实现插入、删除、查找等基本操作。

3. 实现提示首先定义顺序表的数据类型——顺序表类SeqList，包括题目要求的插入、删除、查找等基本操作，为便于查看操作结果，设计一个输出函数依次输出顺序表的元素。

const int MaxSize=10;template <class T> //定义模板类SeqListclass SeqList{public:SeqList( ){length=0;} //无参构造函数SeqList(T a[ ], int n);//有参构造函数void Insert(int i, T x); //在线性表中第i个位置插入值为x的元素T Delete(int i); //删除线性表的第i个元素int Locate(T x ); //按值查找，求线性表中值为x的元素序号void PrintList( ); //遍历线性表，按序号依次输出各元素private:T data[MaxSize]; //存放数据元素的数组int length; //线性表的长度};其次，建立含有n个数据元素的顺序表，即设计构造函数。

算法如下：最后，对建立的顺序表设计插入、删除、查找等基本操作的算法。

顺序表⑴插入算法⑵删除算法⑶查找算法线性表班级：_________ 学号：_____________ 姓名：___________ 成绩：_________实验一顺序表操作验证一、实验目的二、实验内容三、设计与编码a)本实验用到的理论知识实验用到的理论知识，实现理论与实践相结合。

总结尽量简明扼要，并与本次实验密切相关。

b)算法设计对本次实验内容设计c++类定义，设计算法完成每个成员函数。

c)编码将算法转化为c++程序，设计主函数完成对各成员函数的调用。

数据结构实验报告-实验一顺序表、单链表基本操作的实现

数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现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）掌握链表的概念，学会对链表进⾏操作。

顺序表的操作实验报告

顺序表的操作实验报告一、实验目的。

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. 实现顺序表的输出操作：- 遍历顺序表，逐个输出元素值。

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

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

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

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

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

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

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

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

实验一顺序表的实现和应用

实验一顺序表的实现和应用一、实验目的⑴熟悉线性表的定义和基本操作；⑵掌握线性表的顺序存储结构设计与基本操作的实现；二、实验内容与要求⑴定义线性表的顺序存储表示；⑵基于所设计的存储结构实现线性表的基本操作；⑶编写一个主程序对所实现的线性表进行测试；⑷线性表的应用：使用菜单方式实现顺序表的各种操作，例如：创建、插入、删除、显示等等。

二、数据结构设计在主函数中实现函数的调用，从而实现线性表的创建（CREATE），插入(INSERT)，删除(DELETE)，显示(DISPLAY).等操作。

利用一个switch函数实现线性表的各种操作。

三、测试结果刚开始测试的时候，有很多报错和警告，有些是语法问题，有些是没定义就使用变量，有些地方是少了括号。

然后慢慢地改，错误越来越少，后来就嫩成功地运行了。

然后根据操作顺序一步步实现了线性表的各种操作。

四、心得体会在写程序时首先要分析怎样来实现目标，设计可行的算法，进行测试。

不要怕报错，只要一步一步地改，就能把所有的错改正过来。

跟重要的是要上机敲代码，不能只看别人写，自己不动手，另外，别人的意见也是非常重要的。

非常感谢指导我的大四学长，对于一个不善于写程序的人来说，耐心的指导是在是非常难得，她告诉我怎样设计整个程序的框架。

MAIN.C 方丽平信计1203班1130112321 修改时间2014/3/24#include<stdio.h>#include<stdlib.h>#define maxsize 1024typedef int datatype;typedef struct{int data[maxsize];int last;}SqList;void main(){int CREATE(SqList *L);int INSERT(SqList *L,int i, int x);int DELETE(SqList *L,int i);int DISPLAY(SqList *L);int i,value,x;SqList List;SqList *p;p = &List;while(1){printf("the program \n");printf("can realize to create,insert,delete,display,etc\n"); printf("1:create the ranked list\n");printf("2:insert a data\n");printf("3:delete a data\n");printf("4:display all the data\n");printf("5:return,end of the program\n");printf("selection of operation\n");scanf("%d",&i);while ( i < 1 || i > 5 ){printf("error,please input again\n");scanf("%d",&i);}switch(i){case 1:CREATE(p);break;case 2:/*INSERT(p);*/printf("error,please input insert place\n");scanf("%d",&value);printf("error,please input insert value\n");scanf("%d",&x);INSERT(p, value, x);break;case 3:printf("error,please input delete value\n");scanf("%d",&value);DELETE(p, value);break;case 4:DISPLAY(p);break;case 5:exit(0);break;}}}int CREATE(SqList *L){int i,n;do{printf("input the data of the number");scanf("%d",&n);if(n<1||n>maxsize)printf("error,please input again");}while(n<1||n>maxsize);(*L).last=n;for(i=0;i<n;i++)(*L).data[i]=1+rand()%100;for(i=0;i<n;i++){printf("%5d",(*L).data[i]);if((i+1)%10==0) printf("\n");}return 0;}int INSERT(SqList *L,int i, int x){int j;if(((*L).last) >= maxsize-1){printf("overflow");return -1;}elseif(i < 1 || i >(*L).last + 2){printf("ERROR");return -1;}else{for( j = (*L).last; j >= i-1; j-- )(*L).data[j+1] = (*L).data[j];(*L).data[i-1] = x;(*L).last = (*L).last+1;}return(1);}int DELETE(SqList *L,int i){int j;if((*L).last<0){printf("Empty");return -1;}elseif(i < 1 || i>(*L).last + 1){printf("ERROR");return -1;}else{for(j=i; j <= (*L).last; j++)(*L).data[j-1] = (*L).data[j];(*L).last --;}return(1);}int DISPLAY(SqList *L){int i;if((*L).last<1)printf("empty??please create the ranked list ");else{for(i=0; i< (*L).last; i++){printf("%5d",(*L).data[i]);if((i+1)%10==0)printf("\n");}}return 0;}。

数据结构实验报告顺序表

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

实验一.顺序表验证实验

顺序表实验报告

实验报告一 顺序表的操作

顺序表的操作实验报告

数据结构实验一顺序表

实验一顺序表的基本操作实验报告

实验报告1-顺序表操作

实验一 顺序表 实验报告

数据结构-顺序表-实验报告

数据结构实验(使用版)

数据结构实验报告顺序表1

实验一顺序表的基本操作实验报告

1.顺序表验证实验

数据结构实验报告-实验一顺序表、单链表基本操作的实现

顺序表的操作实验报告

顺序表的操作实验报告

数据结构实验一顺序表实验报告

实验一 顺序表的实现和应用

数据结构实验报告顺序表

实验报告一顺序表的操作

实验一顺序表实验报告

实验一顺序表的实现和应用