数据结构实验一顺序表实验报告
数据结构实验报告1线性表的顺序存储结构
数据结构实验报告1线性表的顺序存储结构数据结构实验报告1线性表的顺序存储结构第一章引言线性表是计算机中最常见的数据结构之一，它是一种有序的数据元素集合，其中的数据元素之间具有一对一的关系。
线性表的存储结构有多种方式，其中顺序存储结构是最简单的一种，它使用一段连续的存储单元来存储线性表中的元素。
第二章顺序存储结构的定义顺序存储结构是将线性表中的元素按照其逻辑顺序依次存储在一块连续的存储空间中。
顺序存储结构的特点是可以快速地访问任意位置的元素，但插入和删除操作需要移动大量的元素。
第三章顺序存储结构的实现1.存储空间的分配顺序存储结构通常使用数组来实现，数组的长度应该大于等于线性表的长度，以防止溢出。
存储空间的分配可以使用静态分配或动态分配两种方式来实现。
2.线性表的初始化初始化线性表时，需要设置线性表的长度和当前元素的个数。
3.线性表的增删改查操作●插入操作：________在指定位置插入一个元素时，需要将插入位置之后的元素依次后移，给待插入的元素腾出位置。
●删除操作：________删除指定位置的元素时，需要将删除位置之后的元素依次前移，覆盖删除位置上的元素。
●修改操作：________修改指定位置的元素时，直接对该位置上的元素进行修改即可。
●查找操作：________根据指定的元素值，查找其在顺序存储结构中的位置。
4.线性表的遍历操作遍历操作可以按照顺序访问线性表中的每个元素，可以使用循环结构实现遍历操作。
第四章顺序存储结构的优缺点分析1.优点：________可以快速地访问任意位置的元素，节省存储空间。
2.缺点：________插入和删除操作需要移动大量的元素，不适用于频繁插入和删除的场景。
第五章实验过程和结果分析在本次实验中，我们以顺序存储结构为基础，实现了线性表的增删改查操作，并进行了遍历操作。
通过实验，我们发现顺序存储结构在查询操作上有较好的性能，但在插入和删除操作上的性能较差。
第六章附件本文档涉及的附件详见附件文件。
数据结构实验：顺序表设计与应用-精简
实验报告实验名称：实验一：顺序表设计与应用（实验报告）一．实验目的：1.熟悉顺序表的概念，加深对顺序表的理解；2.掌握对顺序表的设计与运用，包括顺序表的初始化，遍历，删除，查找，插入等基本操作。
二．实验内容：1.在顺序表制定位置增加数据元素；2.删除顺序表指定位置的数据元素；3.修改顺序表指定位置的数据元素值；（选作）4.查找顺序表中是否存在某一数据元素；（选作）三．实验方法：1.将顺序表的基本操作如初始化，插入，删除，查找，删除重复元素等基本操作以函数调用的方式来做成函数，然后封装在formate1.h文件中；2.在主函数中调用formate1.h文件，就可以实现对顺序表的基本操作。
四．实验源程序：1.formate1.h/*顺序表基本操作*//*初始化顺序表*/int InitList(SqList *L){L->length=0;return 1;}/*求顺序表长*/int ListLength(SqList L){return L.length;}/*判断顺序表是否为空*/int ListEmpty(SqList L){if(L.length<=0)return 1;elsereturn 0;}/*插入指定位置上数据元素*/int ListInsert(SqList *L,int pos,DataType item){int i;if(L->length>=LISTSIZE){printf("顺序表已满，无法进行插入操作！");return 0;}if(pos<=0 || pos>L->length+1){printf("插入位置不合法，其取值范围应该是[1,length+1]"); return 0;}for(i=L->length-1; i>=pos-1; i--)L->items[i+1]=L->items[i];L->items[pos-1]=item;L->length++;return 1;}/*删除指定位置上的数据元素*/int ListDelete(SqList *L,int pos,DataType *item){int i;if(ListEmpty(*L)){printf("顺序表为空表，无法进行删除操作！");return 0;}if(pos<1 || pos>L->length){printf("删除位置不合法，其取值范围应该是[1,length]"); return 0;}*item=L->items[pos-1];for(i=pos;i<L->length;i++)L->items[i-1]=L->items[i];L->length--;return 1;}/*查找指定元素在顺序表中的位置*/int Find(SqList L,DataType item){int pos=0;if(ListEmpty(L)){printf("顺序表为空表，无法进行查找操作！"); return 0;}while(pos<L.length && L.items[pos]!=item)pos++;if(pos<L.length)return pos+1;elsereturn 0;}/*获取顺序表中指定位置上的数据元素*/int GetElem(SqList L,int pos,DataType *item){if(ListEmpty(L))return 0;if(pos<=0 || pos>L.length){printf("位置信息输入不合法，请重新输入"); return 0;}*item=L.items[pos-1];return 1;}/*遍历顺序表*/int TraverseList(SqList L){int i;for(i=0;i<L.length;i++)printf("%d\t",L.items[i]);printf("\n");return 1;}/*修改指定位置上的数据元素*/int ListChange(SqList *L,int pos,DataType item){ int i;if(ListEmpty(*L)){printf("顺序表为空表，无法进行删除操作！");return 0;}if(pos<1 || pos>L->length){printf("删除位置不合法，其取值范围应该是[1,length]");return 0;}for(i=1;i<L->length;i++)if(i==pos)L->items[i]=item;L->items[i-1]=L->items[i];return 1;}/*删除表中重复的元素*/void Repetition(Sqlist *L)int i,j;DataType item;for(i=0;i<l->length;i++){j=i+1;while(j<L->length)if(L->item[j]==L->item[i])ListDelete(L,j+1,&item);else j++;}3.主函数：#include<stdio.h>#include<i:\vc\format1.h>#define LISTSIZE 100typedef int DataType;/*顺序表C语言描述*/typedef struct{DataType items[LISTSIZE];int length;}SqList;/*主函数*/int main(void){int i;int data[]={1,2,3,5,7,13,15,22,33,44};DataType item;SqList Test;printf("\n建立顺序表\n");InitList(&Test);for(i=0;i<10;i++){if(!ListInsert(&Test,i+1,data[i])) {printf("\n结果未找到\n");return 0;}}printf("\n顺序表中的元素\n");TraverseList(Test);ListInsert(&Test,3,0);printf("\n插入后的顺序表中的元素\n");TraverseList(Test);if(!ListDelete(&Test,6,&item)){printf("\n未成功删除\n");return 0;}printf("\n删除后的顺序表中的元素\n");TraverseList(Test);printf("\n查找顺序表中的元素\n");printf("\n结果显示\n");Find(Test,15);return 1;}五．实验结果：结果分析：由实验结果可知，成功的完成了对顺序表的一些基本操作，包括在顺序表的第三个位置插入0，删除顺序表的第6个元素，并且成功的输出了删除后的元素，只是查找元素不成功。
实验一顺序表的基本操作实验报告
元素之后的所有数据都前移一个位置，最将线性表长减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实验报告
南京工程学院实验报告<班级>_<学号>_<实验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六、收获，体会及问题(写得越详细、越个性化、越真实越好，否则我不知道你做这个实验的心路历程，也就无法充分地判断你是否是独立完成的这个实验、你是否在做这个实验时进行了认真仔细地思考、通过这个实验你是否在实践能力上得到了提高)这次试验刚开始做时完全不知道从哪下手，才刚上了几节课，对于线性表、链式表都不是理解的很透彻，不知道用哪个软件编写程序。
顺序表实验报告
顺序表实验报告1. 简介顺序表是一种常用的数据结构，它在计算机科学中有着重要的应用。
本实验旨在通过实践操作顺序表，深入理解其原理和实现方式。
2. 实验目的本次实验有以下几个目的：- 学习使用顺序表来存储和操作数据；- 掌握顺序表的插入、删除、查找等基本操作；- 理解顺序表的实现原理，并分析其优缺点。
3. 实验环境和工具本实验所用环境为Windows系统，编程语言为C++。
编程工具可以选择Visual Studio或者其他C++开发工具。
4. 实验步骤4.1 实验准备首先，我们需要定义顺序表的数据结构。
例如，我们可以定义一个结构体，其中包含一个数组和一个指示当前表中元素个数的变量。
4.2 插入操作接下来，我们可以编写插入操作的函数。
插入操作的目的是将一个元素插入到指定位置，并保持表中其他元素的顺序。
可以使用循环将需要移动的元素逐个后移，然后将新元素插入到指定位置。
4.3 删除操作与插入操作类似，删除操作也需要保持表中其他元素的顺序。
可以使用循环将需要删除的元素之后的元素逐个前移，然后将最后一个元素的位置置为空。
4.4 查找操作查找操作可以通过循环遍历表中的元素，并与目标元素进行比较，直到找到相等的元素或者遍历到表尾。
5. 实验结果与分析经过实验，我们可以发现使用顺序表存储数据的效率较高。
顺序表的插入和删除操作时间复杂度为O(n)，其中n为表中元素个数。
这是因为插入或删除一个元素后，需要移动其他元素以保持顺序。
而查找操作的时间复杂度为O(n)，在最坏的情况下需要遍历整个表才能找到目标元素。
此外，顺序表还具有便于随机访问的优点。
由于顺序表中元素在内存中连续存储，可以直接通过索引访问表中的任意元素，因此查找效率较高。
然而，顺序表也有一些缺点。
首先，插入和删除操作需要移动大量元素，当表中元素个数较大时，操作的时间复杂度会较高。
其次，由于顺序表必须预先分配一定大小的连续空间，因此当表中元素个数超过初始大小时，需要进行动态扩容操作。
数据结构实验一 实验报告
班级：姓名：学号：实验一线性表的基本操作一、实验目的1、掌握线性表的定义；2、掌握线性表的基本操作;如建立、查找、插入和删除等..二、实验内容定义一个包含学生信息学号;姓名;成绩的顺序表和链表二选一;使其具有如下功能：1 根据指定学生个数;逐个输入学生信息；2 逐个显示学生表中所有学生的相关信息；3 根据姓名进行查找;返回此学生的学号和成绩；4 根据指定的位置可返回相应的学生信息学号;姓名;成绩；5 给定一个学生信息;插入到表中指定的位置；6 删除指定位置的学生记录；7 统计表中学生个数..三、实验环境Visual C++四、程序分析与实验结果#include<stdio.h>#include<malloc.h>#include<stdlib.h>#include<string.h>#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status; // 定义函数返回值类型typedef struct{char num10; // 学号char name20; // 姓名double grade; // 成绩}student;typedef student ElemType;typedef struct LNode{ElemType data; // 数据域struct LNode *next; //指针域}LNode;*LinkList;Status InitListLinkList &L // 构造空链表L {L=struct LNode*mallocsizeofstruct LNode; L->next=NULL;return OK;}Status GetElemLinkList L;int i;ElemType &e // 访问链表;找到i位置的数据域;返回给 e{LinkList p;p=L->next;int j=1;whilep&&j<i{p=p->next;++j;}ifp||j>i return ERROR;e=p->data;return OK;}Status SearchLNode L;char str;LinkList &p // 根据名字查找{p=L.next;whilep{ifstrcmpp->;str==0return OK;p=p->next;}return ERROR;}Status ListInsertLinkList L;int i;ElemType e // 在i个位置插入某个学生的信息{LinkList p;s;p=L;int j=0;whilep&&j<i-1{p=p->next;++j;}ifp||j>i-1 return ERROR;s=struct LNode*mallocsizeofLNode;s->data=e;s->next=p->next;p->next=s;return OK;}Status ListDeleteLinkList p;int i // 删除i位置的学生信息{int j=0;whilep->next&&j<i-1{p=p->next;++j;}ifp->next||j>i-1 return ERROR;LinkList q;q=p->next;p->next=q->next;delete q;return OK;}void InputElemType *e{printf"姓名:"; scanf"%s";e->name;printf"学号:"; scanf"%s";e->num;printf"成绩:"; scanf"%lf";&e->grade;printf"输入完成\n\n";}void OutputElemType *e{printf"姓名:%-20s\n学号:%-10s\n成绩:%-10.2lf\n\n";e->name;e->num;e->grade;}int main{LNode L;LinkList p;ElemType a;b;c;d;printf"\n********************************\n\n";puts"1. 构造链表";puts"2. 录入学生信息";puts"3. 显示学生信息";puts"4. 输入姓名;查找该学生";puts"5. 显示某位置该学生信息";puts"6. 在指定位置插入学生信息";puts"7. 在指定位置删除学生信息";puts"8. 统计学生个数";puts"0. 退出";printf"\n********************************\n\n"; int x;choose=-1;whilechoose=0{puts"请选择:";scanf"%d";&choose;switchchoose{case 1:ifInitListpprintf"成功建立链表\n\n";elseprintf"链表建立失败\n\n";break;case 2:printf"请输入要录入学生信息的人数:";scanf"%d";&x;forint i=1;i<=x;i++{printf"第%d个学生:\n";i;Input&a;ListInsert&L;i;a;}break;case 3:forint i=1;i<=x;i++{GetElem&L;i;b;Output&b;}break;case 4:char s20;printf"请输入要查找的学生姓名:";scanf"%s";s;ifSearchL;s;pOutput&p->data;elseputs"对不起;查无此人";puts"";break;case 5:printf"请输入要查询的位置:";int id1;scanf"%d";&id1;GetElem&L;id1;c;Output&c;break;case 6:printf "请输入要插入的位置:";int id2;scanf"%d";&id2;printf"请输入学生信息:\n";Input&d;ifListInsert&L;id2;d{x++;puts"插入成功";puts"";}else{puts"插入失败";puts"";}break;case 7:printf"请输入要删除的位置:";int id3;scanf"%d";&id3;ifListDelete&L;id3{x--;puts"删除成功";puts"";}else{puts"删除失败";puts"";}break;case 8:printf"已录入的学生个数为:%d\n\n";x;break;}}printf"\n\n谢谢您的使用;请按任意键退出\n\n\n"; system"pause";return 0;}用户界面:(1)根据指定学生个数;逐个输入学生信息：(2)逐个显示学生表中所有学生的相关信息：(3)根据姓名进行查找;返回此学生的学号和成绩：(4)根据指定的位置可返回相应的学生信息学号;姓名;成绩：(5)给定一个学生信息;插入到表中指定的位置：(6)删除指定位置的学生记录：(7)统计表中学生个数：五、实验总结数据结构是一门专业技术基础课..它要求学会分析研究计算机加工的数据结构的特性;以便为应用涉及的数据选择适当的逻辑结构;存储结构及相应的算法;并初步掌握算法的时间分析和空间分析技术..不仅要考虑具体实现哪些功能;同时还要考虑如何布局;这次的实验题目是根据我们的课本学习进程出的;说实话;我并没有真正的读懂书本的知识;所以刚开始的时候;感到很棘手;于是又重新细读课本;这一方面又加强了对书本的理解;在这上面花费了一些心血;觉得它并不简单;是需要花大量时间来编写的....在本次实验中;在程序构思及设计方面有了较大的锻炼;能力得到了一定的提高..。
数据结构实验报告-顺序表的创建、遍历及有序合并操作
数据结构实验报告-顺序表的创建、遍历及有序合并操作二、实验内容与步骤实现顺序表的创建、遍历及有序合并操作，基本数据结构定义如下：typedef int ElemType;#define MAXSIZE 100#define FALSE 0#define TRUE 1typedef struct{ElemType data[MAXSIZE];int length;}seqlist;创建顺序表，遍历顺序表#include<stdio.h>#include<stdlib.h>#define MAXSIZE 100#define Icreament 20#define FALSE 0#define TRUE 1typedef int ElemType; //用户自定义数据元素类型// 顺序表结构体的定义typedef struct{ElemType *elem; //顺序表的基地址int length; //顺序表的当前长度int listsize; //预设空间容量}SqList; //线性表的顺序存储结构SqList* InitList() //创建空的顺序表{SqList* L = (SqList*)malloc(sizeof(SqList));//定义顺序表Lif(!L){printf("空间划分失败，程序退出\n");return NULL;}L->elem=(ElemType *)malloc(MAXSIZE*sizeof(ElemType));if(!L->elem){printf("空间划分失败，程序退出\n");return NULL;}L->length=0;L->listsize=MAXSIZE;return L;}int CreateList(SqList* L) //创建顺序表（非空）{int number; //顺序表中元素的个数int i; //循环变量printf("请输入顺序表中元素的个数：");scanf("%d",&number);if(number > MAXSIZE) //一定要判断输入的个数是否大于顺序表的最大长度{printf("输入个数大于顺序表的长度\n");return 0;}for(i=0;i<number;i++){printf("输入第%d个数: ",i+1);scanf("%d",L->elem+i); //L->elem+i：每次的输入都保存在顺序表元素中的下一个地址，而不是一直放在元素的首地址}//给顺序表中每个数据元素赋值L->length=number; //当前顺序表的长度return 1;}void print(SqList* L) //遍历顺序表{int i;printf("\n开始遍历顺序表\n");for(i=0;i<L->length;i++){printf("%d",*(L->elem + i)); //L->elem+i：和输入是一个道理}printf("\n遍历结束\n");printf("\n");}int main(){SqList* L = InitList(); //申请一个指向顺序表的指针，并对其初始化if(!L) //判断申请是否成功{printf("初始化线性表失败\n");return 1;}if(!CreateList(L)) //判断创建顺序表是否成功{printf("创建顺序表失败\n");return 1;}print(L); //打印顺序表与上面遍历顺序表相对应，若没有就不遍历free(L->elem); //释放申请的顺序表元素的内存free(L); //释放申请的顺序表内存return 0;}表的有序合并#include <stdio.h>#include <stdlib.h>#define MAXSIZE 100typedef int ElemType;//顺序表结构体的定义typedef struct{ElemType data[MAXSIZE] ;int size;}seqlist;//函数声明void init(seqlist *slt) ;void display(seqlist slt) ;void sort(seqlist *s) ;void combine( seqlist *s1 ,seqlist *s2 ,seqlist *s3) ;//顺序表的初始化函数void init(seqlist *slt){slt->size=0 ;}//顺序表的显示函数void display(seqlist slt){int i;if(!slt.size){printf("\n顺序表为空") ;}else{for(i=0;i<slt.size;i++)printf("\n%d\n",slt.data[i]) ;}}//顺序表排序void sort(seqlist *s){int i ;int j ;int temp ;for(i=0;i<s->size-1;i++){for(j=i+1;j<s->size;j++){if(s->data[i]>=s->data[j]){temp=s->data[i];s->data[i]=s->data[j];s->data[j]=temp;}}}}//两个有序顺序表连接函数void combine(seqlist *s1 , seqlist *s2 , seqlist *s3 ) {int i=0 ;int j=0 ;int k=0 ;while( i < s1->size && j < s2->size) {if(s1->data[i]<=s2->data[j]){s3->data[k]=s1->data[i];i++;}else{s3->data[k]=s2->data[j];j++;}k++;}if(i==s1->size){while(j<s2->size){s3->data[k]=s2->data[j];k++;j++;}}if(j==s2->size){while(i<s1->size){s3->data[k]=s1->data[i];k++;i++;}}s3->size=k;}//主函数int main(){int i ;int j ;int x ;int n ;seqlist list1 ;seqlist list2 ;seqlist list3 ;init(&list1);printf("第一个顺序表元素个数：\n"); scanf("%d" ,&n) ;printf("第一个顺序表输入：\n");for(i=0 ; i<n ; i++){scanf("%d",&list1.data[i]) ;list1.size++ ;}sort(&list1);//第一个表排序init(&list2);printf("第二个顺序表元素个数：\n"); scanf("%d" ,&n) ;printf("第二个顺序表输入：\n");for(i=0 ; i<n ; i++){scanf("%d",&list2.data[i]) ;list2.size++ ;}sort(&list2);//第二个表排序init(&list3) ;combine(&list1 ,&list2 ,&list3) ;printf("表一与表二连接后:\n") ;display(list3) ;return 0;}。
顺序表的基本操作和实现实验报告(一)
顺序表的基本操作和实现实验报告(一)顺序表的基本操作和实现实验报告1. 引言顺序表是计算机科学中一种常用的数据结构，用于存储一组元素并支持快速的随机访问。
本实验旨在探究顺序表的基本操作和实现方法。
2. 实验目的•理解顺序表的概念和特性。
•学习顺序表的基本操作，包括插入、删除、查找和修改等。
•掌握顺序表的实现方法，包括静态分配和动态分配两种方式。
•培养对数据结构的抽象思维和编程能力。
3. 实验内容1.了解顺序表的定义，及其与数组的关系。
2.掌握插入操作的实现方法，包括在表头、表中和表尾插入元素。
3.掌握删除操作的实现方法，包括按索引删除和按值删除。
4.掌握查找操作的实现方法，包括按索引查找和按值查找。
5.掌握修改操作的实现方法，包括按索引修改和按值修改。
6.实现顺序表的静态分配和动态分配两种方式。
4. 实验步骤1.定义顺序表的结构体，包括数据存储区和长度属性。
2.实现插入操作，根据需要选择插入位置和移动元素。
3.实现删除操作，根据需要选择删除方式和更新长度。
4.实现查找操作，根据需要选择查找方式和返回结果。
5.实现修改操作，根据需要选择修改方式和更新元素。
6.实现顺序表的静态分配和动态分配方法。
5. 实验结果经过多次实验和测试，顺序表的基本操作都能够正确实现。
在插入操作中，能够将元素正确插入指定位置，并保持顺序表的有序性。
在删除操作中，能够按需删除指定位置或值的元素，并正确更新顺序表的长度。
在查找操作中，能够根据索引或值查找到对应的元素，并返回正确的结果。
在修改操作中，能够按需修改指定位置或值的元素，并更新顺序表的内容。
6. 实验总结本实验通过对顺序表的基本操作和实现方法的学习和实践，进一步巩固了对数据结构的理解和编程能力的培养。
顺序表作为一种常用的数据结构，对于解决实际问题具有重要的作用。
通过本次实验，我对顺序表的插入、删除、查找和修改等操作有了更深入的了解，并学会了如何实现这些操作。
通过本次实验，我还学会了顺序表的静态分配和动态分配方法，了解了它们的区别和适用场景。
数据结构顺序表链表试验报告
数据结构顺序表链表试验报告数据结构试验报告一、引言数据结构是计算机科学中非常重要的一个概念，它用于组织和存储数据，以便能够高效地进行检索和操作。
顺序表和链表是两种常见的数据结构，它们在实际应用中都有各自的优势和局限性。
本报告将对顺序表和链表进行试验比较，以评估它们在不同场景下的性能和适合性。
二、实验目的本次试验的目的是比较顺序表和链表在插入、删除和查找操作上的性能差异，并分析其时间复杂度和空间复杂度。
通过实验结果，可以对不同场景下选择合适的数据结构提供参考。
三、实验内容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。
数据结构 顺序表 实验报告
重庆交通大学计算机与信息学院数据结构实验报告实验名称：顺序表操作实验性质：课程安排实验所属课程：数据结构指导教师：班级： 2008级3班学号：姓名：完成时间： 2010年 4 月 7 日目录封面 (1)目录 (2)一、实验目的 (3)二、实验内容及要求................................................. (3)（1）实验内容（2）实现功能（3）上交内容三、实验设备及软件 (4)四、设计方案 (5)（一）题目：顺序表及其相关操作（二）设计的主要思路 (5)（三）主要功能 (5)（四）程序大致流程图 (6)五、主要代码（略） (7)六、测试结果及说明 (7)七、实验体会 (10)一、实验目的培养学生在程序设计方面知识的综合应用能力及程序设计能力（包括编制能力及程序调试能力）二、实验内容及要求（1）以顺序存储方式实现线性表进行简单的图书管理，图书信息由学生自行定义。
（2）主要实现以下功能：增加图书、删除图书、修改图书信息、查询与定位（查询方式由学生自行设计）、显示与浏览、图书信息文件的打开与保存等（3）上交内容：1、实验报告：要求内容充实、结构完整、格式规范、说明详细等2、源代码与数据文件：将所有的源代码与测试用数据文件一并压缩后提交注：实验报告、源代码中均需要注明自己的学号、姓名、年级、专业、班级等信息三、实验设备及软件计算机、Visual C++6.0四、设计方案（一）题目：顺序表及其相关操作（二）设计的主要思路1、建立能保存图书信息的数据类型，定义类book1)由于本次实验要求，图书信息自己定义，所以本次选用双精度型作为编号，字符串类型的名称和作者以及整型的页数；2)根据原来定义类的经验，本次程序同样定义了比较完善的共有成员函数，其中包括设置私有成员的值（含有函数重载，包括有参函数和无参函数）、私有成员数据的获取、book数据类型赋值符号的重载、输入、输出，以及文件操作的读入数据函数。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据结构实验一顺序表实验报告
数据结构实验一顺序表实验报告
一、实验目的
顺序表是一种基本的数据结构，本次实验的目的是通过实现顺序表的基本操作，加深对顺序表的理解，并掌握顺序表的插入、删除、查找等操作的实现方法。
二、实验内容
1. 实现顺序表的创建和初始化操作。
2. 实现顺序表的插入操作。
3. 实现顺序表的删除操作。
4. 实现顺序表的查找操作。
5. 实现顺序表的输出操作。
三、实验步骤
1. 创建顺序表的数据结构，包括数据存储数组和记录当前元素个数的变量。
2. 初始化顺序表，将当前元素个数置为0。
3. 实现顺序表的插入操作：
- 判断顺序表是否已满，若已满则输出错误信息。
- 将插入位置之后的元素依次后移一位。
- 将要插入的元素放入插入位置。
- 当前元素个数加一。
4. 实现顺序表的删除操作：
- 判断顺序表是否为空，若为空则输出错误信息。
- 判断要删除的位置是否合法，若不合法则输出错误信息。
- 将删除位置之后的元素依次前移一位。
- 当前元素个数减一。
5. 实现顺序表的查找操作：
- 遍历顺序表，逐个比较元素值与目标值是否相等。
- 若找到目标值，则返回该元素的位置。
- 若遍历完整个顺序表仍未找到目标值，则返回错误信息。
6. 实现顺序表的输出操作：
- 遍历顺序表，逐个输出元素值。
四、实验结果
经过实验，顺序表的各项操作均能正确实现。
在插入操作中，可以正确将元素插入到指定位置，并将插入位置之后的元素依次后移。
在删除操作中，可以正确删除指定位置的元素，并将删除位置之后的元素依次前移。
在查找操作中，可以正确返回目标值的位置。
在输出操作中，可以正确输出顺序表中的所有元素。
五、实验总结
通过本次实验，我深入了解了顺序表的原理和基本操作，并通过实际编程实现了顺序表的各项功能。
在实验过程中，我遇到了一些问题，如如何判断顺序表是否已满或为空，如何处理插入和删除位置的合法性等。
通过查阅资料和与同学讨论，我解决了这些问题，并对顺序表的操作有了更深入的理解。
顺序表作为一种基本的数据结构，在实际应用中有着广泛的用途。
掌握了顺序表的基本操作，对于进一步学习和应用其他数据结构，如链表、栈、队列等，都具有重要的意义。
在以后的学习和实践中，我将继续加深对数据结构的理解
和应用，不断提升自己的编程能力。