实验1 顺序表存储与操作实现(1)
数据结构实验一顺序表实验报告
数据结构实验一顺序表实验报告
数据结构是计算机科学中的一门基础课程，在学习数据结构的过程中，顺序表是我们必须深入了解和掌握的重要数据结构之一。
在实验一中，我们对顺序表进行了一系列的操作，实现了增删改查等基本操作。
我们先来介绍一下顺序表的基本概念。
顺序表是将线性表中的数据存储在一段连续的存储空间中的数据结构，其查找效率高，但插入和删除操作效率较低。
顺序表需要预先分配一定的存储空间，当存储空间不足时需要进行动态扩容，即重新申请更大的存储空间并将原有数据复制到新的存储空间中。
在实验中，我们首先学习了顺序表的实现方式，包括顺序表的结构体定义、创建顺序表、插入元素、删除元素、修改元素以及查询元素等基本操作。
我们通过 C 语言来实现了这些操作，并将其封装成一个顺序表的 API，使其更加易于使用和维护。
在实验过程中，我们还发现顺序表中数据的存储顺序非常重要，因为顺序表中元素的存储顺序与元素的下标是一一对应的，如果存储的顺序错误，可能会导致元素的下标与我们想象中的不一致，从而造成一些意想不到的结果。
总的来说，实验一帮助我们更深入地了解了顺序表的实现方式和基本操作，同时也挖掘出了一些潜在问题，这对于我们今后的学习和实践都起到了很大的帮助。
实验一 线性表的顺序存储及其操作
实验一线性表的顺序存储及其操作一、实验目的与基本要求1．掌握数据结构中的一些基本概念。
数据、数据项、数据元素、数据类型和数据结构，以及它们之间的关系。
2．了解数据的逻辑结构和数据的存储结构之间的区别与联系；数据的运算与数据的逻辑结构的关系。
3．掌握线性表的基本操作：插入、删除、查找等运算。
4．掌握运用C语言上机调试线性表的基本方法。
二、实验条件1．硬件：一台微机2．软件：操作系统和C语言系统三、实验方法确定存储结构后，上机调试实现线性表的基本运算。
四、实验内容在你自己的文件下，建立一个C语言程序SL.C，完成下列要求：（1）定义一个长度为10的数组A，即顺序表的形式，并输入数据1,3,4,5,7,9,12,20,28九个数据，然后输出这九个数组元素的存储单元地址和相应的数值；（2）建立一个数组元素的插入函数，能够按照数据从小到大的次序自动找到插入位置完成插入元素的操作，调用此函数插入数据15，然后输出数值元素的存储单元地址和相应的数值；（3）建立一个数组元素的删除函数，能够按照数据自动删除指定元素的操作，调用此函数删除数据值为9的数组元素，然后输出数组元素的存储单元地址和相应的数值。
程序清单如下：#include <stdio.h>#include<stdlib.h>#include<string.h>void outsl( int n, int a[]){int i;for (i=0;i<=n-1;i++)printf("No.=%d ADD=%x DATA=%d\n", i+1, &a[i], a[i]);getch();}int inssl(int n, int a[], int x){int i=n-1;while (x<a[i]&&i>0){ a[i+1]=a[i];i--;}a[i+1]=x;n++;return(n);}int dlsl( int n, int a[], int x){ int i, m, ok=0;for (i=0;i<=n-1;i++){ if (x==a[i]){ m=i; ok=1; break;}}if (ok==0)printf("No this element %d\n", x); else{ for (i=m; i<=n-1; i++)a[i]=a[i+1];n--;}return(n);main(){int a[10]={1,3,4,5,7,9,12,20,28},n=9; outsl(n,a);printf("==output==\n");n=inssl(n,a,15);printf("==insert==\n");outsl(n,a);printf("==output==\n");n=dlsl(n,a,9);printf("==delete==\n");outsl(n,a);printf("==output==\n");}在“文件”选项（file）里选“新建”（new）,在出来的选项卡中选择win32 console application,然后在右上方“工程名称”（progect name）中随便起个名字，下面选一个保存地址。
实验1：线性表的顺序存储
实验1：顺序表基本操作一、实验目的1.学会定义线性表的顺序存储类型，实现C++程序的基本结构，对线性表的一些基本操作和具体的函数定义。
2.掌握顺序表的基本操作，实现顺序表的插入、删除、查找以及求并集等运算。
3.掌握对多函数程序的输入、编辑、调试和运行过程。
二、实验要求1．预习C++语言中结构体的定义与基本操作方法。
2．对顺序表的每个基本操作用单独的函数实现。
3．编写完整程序完成下面的实验内容并上机运行。
4．整理并上交实验报告。
三、实验内容：★1．编写程序实现顺序表的下列基本操作：(1)初始化顺序表La。
(2)将La置为空表。
(3)销毁La。
(4)在La中插入一个新的元素。
(5)删除La中的某一元素。
(6)在La中查找某元素，若找到，则返回它在La中第一次出现的位置，否则返回0。
（7）遍历顺序表La.(8)打印输出La中的元素值。
主函数见课本P61，各函数具体定义参考P53-60.源程序：//以为例a[12]={3,6,9,12,15,18,21,24,27,30,33,36}为例#include<iostream.h>#include<stdlib.h>typedef int ElemType;struct List {ElemType *list;int size;int MaxSize;};void InitList(List &L) //初始化顺序表La{L.MaxSize=10;L.list=new ElemType[L.MaxSize];if(L.list==NULL){cout<<"动态可分配的存储空间用完，退出运行!"<<endl;exit(1);}L.size=0; //将La置为空表}void ClearList(List &L) //销毁La{if(L.list!=NULL){delete []L.list;L.list=NULL;}L.MaxSize=0;L.size=0;}int LenthList(List &L){return L.size;}bool EmptyList(List &L){return L.size==0;}ElemType GetList(List &L,int pos){if(pos<1 || pos>L.size){cerr<<"pos is out range!"<<endl;exit(1);}return L.list[pos-1];}void TraverseList(List &L) //遍历顺序表la{for(int i=0; i<L.size; i++)cout<<L.list[i]<<' ';cout<<endl;}//在La中查找某元素，若找到，则返回它在La中第一次出现的位置，否则返回0。
数据结构实验报告1-线性结构的顺序存储
教师签名： 2008 年 月 日
第2页共2页
2、参照课本，定义一个向量类模板，编写它的成员函数模板，对类模板加以实现；编写向量的并、 交运算功能函数；编写主程序，对两个向量进行分别进行合并、交运算。
3、通过阅读课本栈类板代码，理解栈类操作特点；编写一个借助于栈，将二进制数转换为十进制数 字串的程序；编写汉诺塔问题程序，理解函数的递归调用。
4、参照课本，定义一个顺序队列类模板，编写它的成员函数模板 ，对类模板加以实现；编写主程序， 对队列进行各种基本操作，理解队列的操作特性。
五、 实验总结（包括心得体会、问题回答及实验改进意见，可附页）
通过本次实验，基本上能够理解线性结构的顺序存储方式及各种不同线性结构的操作方式；顺序存 储方式主要用于线性的数据结构，它把逻辑上相邻的数据元素存储在物理上相邻的存储单元里结点之间 的关系由存储单元的邻接关系来体现。线性表、向量、栈、队列都属于线性结构的顺序存储，各结点的 物理地址是相邻的，每一次插入、删除运算会引起相应结点物理地址的重新排列；栈的操作特点是先进 后出，而队列的操作特点是先进先出。
2、 对两个向量进行合并、交运算，结果如下： 输入向量 La 的结点元素：1 2 3 4 5，输入 Lb 的结点元素：1 2 3 4 5 6，则两向量的交集为：1 2 3 4 5；并集为：1 2 3 4 5 6。
3、（1）将二进制数转换为十进制数字串的程序，结果如下： 输入要转换的带符号整数 x:+3;则 x 转换成十进制数字串输出为：+3
Байду номын сангаас
第1页共2页
四、 实验结果（包括程序或图表、结论陈述、数据记录及分析等，可附页）
1、 对线性表进行插入、删除、定位等操作，结果如下： 输入线性表元素：1 2 3 4 5，（1）选择插入，输入插入位置 2，插入值 9，则新的线性表为：1 2 9 3 4 5；（2）选择删除，输入删除元素序号 5，则新的线性表为：1 2 9 3 4；（3）选择取值，输入要求 值元素序号 2，则屏幕输出：第２个元素的值为 9；（4）选择查找，输入要查找的元素值 9，则屏幕输 出：要查找元素的序号为 2。
顺序表的基本操作和实现实验报告(一)
顺序表的基本操作和实现实验报告(一)顺序表的基本操作和实现实验报告1. 引言顺序表是计算机科学中一种常用的数据结构，用于存储一组元素并支持快速的随机访问。
本实验旨在探究顺序表的基本操作和实现方法。
2. 实验目的•理解顺序表的概念和特性。
•学习顺序表的基本操作，包括插入、删除、查找和修改等。
•掌握顺序表的实现方法，包括静态分配和动态分配两种方式。
•培养对数据结构的抽象思维和编程能力。
3. 实验内容1.了解顺序表的定义，及其与数组的关系。
2.掌握插入操作的实现方法，包括在表头、表中和表尾插入元素。
3.掌握删除操作的实现方法，包括按索引删除和按值删除。
4.掌握查找操作的实现方法，包括按索引查找和按值查找。
5.掌握修改操作的实现方法，包括按索引修改和按值修改。
6.实现顺序表的静态分配和动态分配两种方式。
4. 实验步骤1.定义顺序表的结构体，包括数据存储区和长度属性。
2.实现插入操作，根据需要选择插入位置和移动元素。
3.实现删除操作，根据需要选择删除方式和更新长度。
4.实现查找操作，根据需要选择查找方式和返回结果。
5.实现修改操作，根据需要选择修改方式和更新元素。
6.实现顺序表的静态分配和动态分配方法。
5. 实验结果经过多次实验和测试，顺序表的基本操作都能够正确实现。
在插入操作中，能够将元素正确插入指定位置，并保持顺序表的有序性。
在删除操作中，能够按需删除指定位置或值的元素，并正确更新顺序表的长度。
在查找操作中，能够根据索引或值查找到对应的元素，并返回正确的结果。
在修改操作中，能够按需修改指定位置或值的元素，并更新顺序表的内容。
6. 实验总结本实验通过对顺序表的基本操作和实现方法的学习和实践，进一步巩固了对数据结构的理解和编程能力的培养。
顺序表作为一种常用的数据结构，对于解决实际问题具有重要的作用。
通过本次实验，我对顺序表的插入、删除、查找和修改等操作有了更深入的了解，并学会了如何实现这些操作。
通过本次实验，我还学会了顺序表的静态分配和动态分配方法，了解了它们的区别和适用场景。
实验一 顺序表操作实现
实验一顺序表操作实现实验日期：2017 年 3 月 6 日实验目的及要求1. 熟练掌握线性表的基本操作在顺序存储上的实现；2. 以线性表的各种操作（建立、插入、删除、遍历等）的实现为重点；3. 掌握线性表的顺序存储结构的定义和基本操作的实现；4. 通过本实验加深对C语言的使用（特别是函数调用的参数传递、指针类型的应用）。
实验内容已知程序文件seqlist.cpp已给出学生身高信息顺序表的类型定义和基本运算函数定义。
（1）顺序表类型定义typedef struct {int xh; /*学号*/float sg; /*身高*/int sex; /*性别，0为男生，1为女生*/} datatype;typedef struct{datatype data[MAX]; /*存放顺序表元素的数组*/int last; /*表示data中实际存放元素个数*/}Seqlist;（2）基本运算函数原型void initList(Seqlist *lp);/*置一个空表*/void createList(Seqlist *lp);/*建一个学生顺序表*/void sort_xh(Seqlist *lp);/*按学号排序*/void Error(char *s);/*自定义错误处理函数*/void pntList(Seqlist *lp);/*输出学生表*/void save(Seqlist *lp,char strname[]);/*保存学生顺序表到指定文件*/任务一创建程序文件seqlist.cpp，其代码如下所示，理解顺序表类型Seqlist和基本运算函数后回答下列问题。
/*seqlist.cpp程序文件代码*/#include <stdio.h>#include <stdlib.h>#define MAX 50typedef struct {int xh; /*学号*/float sg; /*身高*/int sex; /*性别，0为男生，1为女生*/} datatype;typedef struct{datatype data[MAX]; /*存放顺序表元素的数组*/int last; /*表示data中实际存放元素个数*/}Seqlist;void initList(Seqlist *lp);/*置一个空表*/void createList(Seqlist *lp);/*建一个学生顺序表*/void sort_xh(Seqlist *lp);/*按学号排序*/void Error(char *s);/*自定义错误处理函数*/void pntList(Seqlist *lp);/*输出学生表*/void save(Seqlist *lp,char strname[]);/*保存学生顺序表到指定文件*//*置一个空表*/void initList(Seqlist *lp){ lp->last=0; }/*建一个学生顺序表*/void createList(Seqlist *lp){ FILE *fp;int xh ,sex;float sg;if((fp=fopen("records.txt","r"))==NULL){ Error("can not open file !");}while(!feof(fp)){ fscanf(fp,"%d%f%d",&xh,&sg,&sex);lp->data[lp->last].xh=xh;lp->data[lp->last].sg=sg;lp->data[lp->last].sex=sex;lp->last++;}fclose(fp);/*按学号排升序*/void sort_xh(Seqlist *lp){ int i,j,k;datatype st;for(i=0;i<lp->last-1;i++){k=i;for(j=i+1;j<lp->last;j++)if(lp->data[j].xh<lp->data[k].xh )k=j;if(k!=i){st=lp->data[k];lp->data[k]=lp->data[i];lp->data[i]=st;}}}/*自定义错误处理函数*/void Error(char *s){ printf("\n %s", s);exit(1); /*返回OS,该函数定义在stdlib.h中*/}/*输出学生顺序表*/void pntList(Seqlist *lp){ int i;for(i=0;i<lp->last ;i++)printf("%2d: %.2f %d\n",lp->data [i].xh,lp->data [i].sg,lp->data[i].sex); }/*保存学生顺序表到指定文件*/void save(Seqlist *lp,char strname[]){ FILE *fp;int i;if((fp=fopen(strname,"w"))==NULL){ Error("can not open file !");}for(i=0;i<lp->last ;i++){fprintf(fp,"%2d %5.2f %2d\n",lp->data[i].xh,lp->data[i].sg,lp->data[i].sex);}fclose(fp);}请回答下列问题：（1）由顺序表类型定义可知，该顺序表类型名为Seqlist ，其中存放的元素为学生信息，学生信息定义的类型名为datatype ，包含xh 、sg 、sex 三个成员（写出成员变量名），学生信息存储于data 数组，顺序表的表长变量为MAX 。
实习01_线性表的顺序存储和操作(有序表的合并)
实验一线性表的顺序存储和操作(有序表的合并)1.目的用顺序表(SqList)类型实现书上算法2.1和2.2,了解线性表及在计算机中的两类不同的存储结构;熟练掌握线性表的查找、插入和删除等算法并灵活运用这些算法。
2.要求用C语言编写程序,其中Lb={2,4,6,8,10} La={1,2,3,4,5},①算法2.1执行后,得到的new La = 1,2,3,4,5,6,8,10②修改Lb=2,6,8,9,11,15,20,并利用新生成的La,得到合并后的Lc,Lc= 1,2,2,3,4,5,6,6,8,8,9,10,11,15,203、预习要求:1、复习书上第20页的例2-1和例2-2;2、复习算法2.3,理解如何构造线性表;3、复习算法2.7,理解算法的执行步骤和含义;4、项目介绍:前面的课程已经学习了如何用C语言描述顺序表、如何初始化顺序表、以及如何在顺序表中插入和删除数据元素。
现在通过两个顺序表的合并的实验,加深对顺序表的理解,熟悉如何将逻辑上的数学模型转化为计算机能够理解的指令代码。
该实验是数据结构课程的第一个实验,实验的目标除了加深理解课堂内容外,还对学生的动手能力提出了更高的要求,锻炼学生动手的能力。
5、算法设计#include <stdio.h>#include <stdlib.h>#include <malloc.h># define TRUE 1# define ERROR 0# define OK 1# define OVERFLOW -2# define FALSE 0# define LIST_INIT_SIZE 10# define LISTINCREMENT 5void main(){List La,Lb,Lc;int j,b[7]={2,6,8,9,11,15,20};InitList(La); // 创建空表La。
如不成功,则会退出程序的运行for(j=1;j<=5;j++) // 在表La中插入5个元素,依次为1、2、3、4、5 ListInsert(La,j,j);printf("La= ");ListTraverse(La,printer); // 输出表La的内容InitList(Lb); // 创建空表Lbfor(j=1;j<=5;j++) // 在表Lb中插入5个元素,依次为2、4、6、8、10 ListInsert(Lb,j,2*j);printf("Lb= ");ListTraverse(Lb,printer); // 输出表Lb的内容Union(La,Lb); // 调用算法2.1,将Lb中满足条件的元素插入La(不改变Lb) printf("new La= ");ListTraverse(La,printer); // 输出新表La的内容ClearList(Lb); // 清空表Lbfor(j=1;j<=7;j++) // 在表Lb中重新依次插入数组b[]的7个元素ListInsert(Lb,j,b[j-1]);printf("Lb= ");ListTraverse(Lb,printer); // 输出表Lb的内容MergeList(La,Lb,Lc); // 调用算法2.2,生成新表Lc(不改变表La和表Lb)printf("Lc= ");ListTraverse(Lc,printer); // 输出表Lc的内容}6.小结线性表是软件设计中最基础的数据结构。
顺序表的基本操作和实现实验报告
顺序表的基本操作和实现实验报告顺序表的基本操作和实现实验报告引言顺序表是一种常用的数据结构，它能够在连续的存储空间中存储元素，并通过索引来访问和修改这些元素。
本实验旨在通过实现基本操作，包括插入、删除、获取等，来深入理解顺序表的原理和实现方式。
实验目的1.掌握顺序表的基本操作2.理解顺序表的实现原理3.学习使用编程语言实现顺序表实验过程1.创建顺序表–使用数组作为底层存储结构，设置一个指针指向数组的起始位置，并初始化顺序表的长度为0。
2.插入元素–通过移动元素的方式，在指定位置插入一个新元素。
–更新顺序表的长度。
3.删除元素–通过覆盖元素的方式，删除指定位置的元素。
–更新顺序表的长度。
4.获取元素–根据指定位置，返回对应的元素。
5.更新元素–根据指定位置，修改对应的元素的值。
–不改变顺序表的长度。
6.打印顺序表–遍历顺序表中的元素，并输出到控制台。
实验结果根据以上操作，我们成功实现了一个顺序表，并在各基本操作上进行了测试和验证。
实验结果表明，顺序表能够高效地支持元素的插入、删除、获取和更新等操作，并能够正确地保存和展示数据。
实验总结通过本次实验，我们深入学习了顺序表的基本操作和实现方式。
顺序表作为一种简单而有用的数据结构，在实际应用中有着广泛的应用。
同时，我们也体会到了数据结构与算法的设计和实现的重要性，它们对于程序性能和可读性都有着关键的影响。
参考文献1.《数据结构与算法分析》2.《算法导论》3.《C++ Primer》实验环境•编程语言: C++•开发环境: Visual Studio Code•操作系统: Windows 10实验步骤1.创建顺序表的类SeqList，并定义私有属性int* data和intlength。
2.定义构造函数SeqList(int size)，用于初始化顺序表的大小。
3.实现插入元素的方法void insert(int pos, int value)，根据指定位置和值，在顺序表中插入新元素。
实验一顺序表的基本操作实验报告
元素之后的所有数据都前移一个位置，最将线性表长减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、2掌握将算法在VC++6.0语言环境下实现的过程。
二、实验原理利用线性表的顺序存储结构完成一个班级的一个学期的所有课程成绩的管理，要求实现增加、删除学生的成绩记录等运算。
三、实验仪器和设备1、PC微机２、Microsoft VC++6.0四、预习要求1、复习线性表的定义、线性表的顺序存储结构的定义以及顺序存储线性表的增加、删除元素的算法。
2、掌握顺序存储线性表的C语言的实现。
五、实验内容及步骤编写程序如下：#include <stdio.h>#include <stdlib.h>#include <string.h>#define Max_length 3typedef struct{int xh; /*学号*/char name[35]; /*姓名*/int c1,c2,c3; /*三门课程成绩*/} Element;/*删除第i个学生的记录算法*/int Delete_list(int i,Element s[ ] ,int *n_pointer){int j,n;n=*n_pointer;if((i<1) ||(i>n))return(0);for (j=i+1;j<=n;j++){/*移动*/s[j-1].xh=s[j].xh;// strcopy(s[j-1].name,s[j].name);s[j-1].name,s[j].name;s[j-1].c1=s[j].c1;s[j-1].c2=s[j].c2;s[j-1].c3=s[j].c3;}n--;*n_pointer=n;return (1);}/*查找学号为x的算法*/int Locate_list (Element s[ ], int n, int x){int i;for(i=1;i<=n;i++)if (s[i].xh==x)return (i);return (0);}/*修改学号为i的学生的记录函数*/int Change_list (int i, Element s[ ] ){if( (i<1) || (i>Max_length +1) ) return (0);printf ("Input data for updating :\n");scanf ("%d%s%d%d%d",s[i].xh,s[i].name,s[i].c1,s[i].c2,s[i].c3);return (1);}/*打印已建立的数据记录，n是记录总数*/void printf_list (Element s[ ],int n){int i;if(n>Max_length) return ;printf ("XH Name C1 C2 C3 \n");printf("--------------------------------------------\n");for(i=1;i<=n;i++)printf ("%4d%10s%7d%7d%7d\n",s[i].xh,s[i].name,s[i].c1,s[i].c2,s[i].c3); }/*在第i个记录的后面插入一个学生的记录算法*/int Insert_list (int i,Element s[ ],int *n_pointer){/*n_pointe存放已输入的最大记录数*/int j,n;n=*n_pointer;if((n== Max_length) || (i<1) || (i>n+1)) return (0);for(j=n;j>=1;j--) s[j+1]=s[j]; /*移动*/printf("Input Data for inserting (XH Name C1 C2 C3) \n");scanf("%d%s%d%d%d",&s[i].xh,&s[i].name,&s[i].c1,&s[i].c2,&s[i].c3);n++;*n_pointer=n;return (1);}void main ( ){int i, records=0;Element s[Max_length];/*创建线性表*/for (i=1;i<=Max_length;i++)Insert_list ( i, s, &records);/*创建线性表*/printf_list (s, records); /*显示学生记录内容*/}上机调试、运行源程序。
实验1-顺序表的实现
程序代码编写的要求
• 请首先建立project • 然后创建一个头文件×××.h，其中有你的程 序中要用的数据类型，以及实现各种操作的函 数的声明（不包括函数体）。 • 再创建一个×××.cpp，其中有各个函数的函 数体（具体实现）。 • 最后创建主函数（程序入口） ×××.cpp ，其 中有用于输入、输出的语句，和一些必要的测 试数据。它来调用上述的函数。
实验（1）顺序表的实现
实验目的
•熟悉使用C编写代码实现算法。 • 掌握结构体的使用。 • 熟悉在顺序表上进行的各种操作。
实验要求
• 编写C（C＋＋）应用程序，实现顺序表 上的各自操作：初始化，销毁，插入， 删除，定位，求表长、“判空”以及 “存取第 i 个数据元素”。
实验报告的书写要求
• • • • • 实验目的 实验要求 实验环境 程序代码 程序的调试与分析
数据结构实验报告-实验一顺序表、单链表基本操作的实现
数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现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）顺序表的基本操作实践。
1. 建立4个元素的顺序表list[]={2，3，4，5}，实现顺序表建立的基本操作。
2. 在list[]={2，3，4，5}的元素4和5之间插入一个元素9，实现顺序表插入的基本操作。
3. 在list[]={2，3，4，9，5}中删除指定位置（i=3）上的元素9，实现顺序表的删除的基本操作。
（2）请编写求两个集合A、B的交集A∩B的程序。
集合A、B用顺序表存储。
例如A={2，3，4，1，5，6，7}，B={3，2，9，8，7，6}，输出A∩B的结果={2,3,7,6}例如：四、【源程序及运行结果】参考：顺序表的存储结构定义typedefstruct{ElemType data[MAXSIZE]; /*存放顺序表的元素*/int length; /*顺序表的实际长度*/} SqList;#include<stdio.h>#include<stdlib.h>#define NULL 0typedefstruct element//集合元素的结构体{char data;struct element *next;}element;element init_element(element *head)//初始化集合（集合是用单链表存储结构存储的）{head=(element*)malloc(sizeof(struct element));head->next=NULL;return *head;}void readdata_element(element *head)//键盘输入每个集合的元素{char c;printf("请输入集合中的数据元素（以“F”为结束标志，结束输入）：\n");scanf("%c",&c);while(c!='F'){if((c>'a' && c<'z') ||( c>'0' && c<'9')){element *p;p=(element*)malloc(sizeof(struct element));p->data=c;p->next=head->next;head->next=p;scanf("%c",&c);}elseprintf("输入错误！必须是小写字母或者0~9的数字！请重新输入：\n");}}void display_element(element * head)//输出集合中的所有元素{element *p;p=head->next;while(p!=NULL){printf("%c",p->data);p=p->next;}printf("\n");}void bing_element(element *head1,element * head2,element * head3)//求两个集合的并集{element *p1,*p2,*p3;p1=head1->next;while(p1!=NULL){p3=(element*)malloc(sizeof(struct element));p3->data=p1->data;p3->next=head3->next;head3->next=p3;p1=p1->next;}p2=head2->next;while(p2!=NULL){p1=head1->next;while((p1!=NULL) && (p1->data!=p2->data))p1=p1->next;if(p1==NULL){p3=(element*)malloc(sizeof(struct element));p3->data=p2->data;p3->next=head3->next;head3->next=p3;}p2=p2->next;}}void jiao_element(element *head1,element *head2,element *head3)//求两个集合的交集{element *p1,*p2,*p3;p1=head1->next;while(p1!=NULL){p2=head2->next;while((p2!=NULL) && (p2->data!=p1->data))p2=p2->next;if(p2->data==p1->data){p3=(element*)malloc(sizeof(struct element));p3->data=p1->data;p3->next=head3->next;head3->next=p3;}p1=p1->next;}}void cha_element(element *head1,element *head2,element *head3)//求两个集合的差集{element *p1,*p2,*p3;p1=head1->next;while(p1!=NULL){p2=head2->next;while((p2!=NULL) && (p2->data!=p1->data))p2=p2->next;if(p2==NULL){p3=(element*)malloc(sizeof(struct element));p3->data=p1->data;p3->next=head3->next;head3->next=p3;}p1=p1->next;}}void bu_element(element *head1,element *head2,element *head3)//求集合的补集{element *p1,*p2,*p3;p1=head1->next;p2=head2->next;while(p1!=NULL){while((p2!=NULL) && (p1->data!=p2->data)){p2=p2->next;}if(p2==NULL){p3->data=p1->data;p3->next=head3->next;head3->next=p3;p3=head3->next;}p1=p1->next;}}void main(){element *head1,*head2,*head3,*head4;init_element(head1);init_element(head2);init_element(head3);init_element(head4);printf("请输入集合1：\n");readdata_element(head1);printf("请输入集合2：\n");readdata_element(head2);printf("请输入集合3（全集）：\n");readdata_element(head3);printf("集合1为：\n");display_element(head1);printf("集合2为：\n");display_element(head2);printf("集合3(全集)为：\n");display_element(head3);char c1;printf("运算目录\nA、集合1与集合2的并集\nB、集合1与集合2的交集\nC、集合1与集合2的差集\nD、集合1的补集\nE、集合2的补集\n");scanf("%c",&c1);if(c1=='A'){printf("集合1与集合2的并集为：\n");bing_element(head1,head2,head4);display_element(head4);head4->next=NULL;}if(c1=='B'){printf("集合1与集合2的交集为：\n");bing_element(head1,head2,head4);display_element(head4);head4->next=NULL;}if(c1=='C'){printf("集合1与集合2的差集为：\n");bing_element(head1,head2,head4);display_element(head4);head4->next=NULL;}if(c1=='D'){printf("集合1的补集为：\n");bing_element(head3,head1,head4);display_element(head4);head4->next=NULL;}if(c1=='E'){printf("集合2的补集为：\n");bing_element(head3,head2,head4);display_element(head4);head4->next=NULL;}}******************************************************************************* *******落实单位姓名性别民族年龄党龄学历职业曾任党内职务与党组织失去联系时间（失联填）失去联系情形（失联填）党组织类别联系电话备注（任填，未注明的必填）是否落实学长学姐，你们好，我是江理信息学院党建小组成员，由于学校开展党员组织梳理排查，需要填好以下信息如果对所填信息有不明白的请尽快联系我，所填信息于明天晚上7点之前发给我，麻烦了，谢谢落实单位姓名性别民族年龄党龄学历职业曾任党内职务与党组织失去联系时间（失联填）失去联系情形（失联填）党组织类别（①国有企业；②非公有制企业：③农村；④党政机关；⑤学校；⑥其他事业单位；⑦街道社区；⑧社会组织；⑨其他。
数据结构实验一顺序表实验报告
数据结构实验一顺序表实验报告数据结构实验一顺序表实验报告一、实验目的顺序表是一种基本的数据结构，本次实验的目的是通过实现顺序表的基本操作，加深对顺序表的理解，并掌握顺序表的插入、删除、查找等操作的实现方法。
二、实验内容1. 实现顺序表的创建和初始化操作。
2. 实现顺序表的插入操作。
3. 实现顺序表的删除操作。
4. 实现顺序表的查找操作。
5. 实现顺序表的输出操作。
三、实验步骤1. 创建顺序表的数据结构，包括数据存储数组和记录当前元素个数的变量。
2. 初始化顺序表，将当前元素个数置为0。
3. 实现顺序表的插入操作：- 判断顺序表是否已满，若已满则输出错误信息。
- 将插入位置之后的元素依次后移一位。
- 将要插入的元素放入插入位置。
- 当前元素个数加一。
4. 实现顺序表的删除操作：- 判断顺序表是否为空，若为空则输出错误信息。
- 判断要删除的位置是否合法，若不合法则输出错误信息。
- 将删除位置之后的元素依次前移一位。
- 当前元素个数减一。
5. 实现顺序表的查找操作：- 遍历顺序表，逐个比较元素值与目标值是否相等。
- 若找到目标值，则返回该元素的位置。
- 若遍历完整个顺序表仍未找到目标值，则返回错误信息。
6. 实现顺序表的输出操作：- 遍历顺序表，逐个输出元素值。
四、实验结果经过实验，顺序表的各项操作均能正确实现。
在插入操作中，可以正确将元素插入到指定位置，并将插入位置之后的元素依次后移。
在删除操作中，可以正确删除指定位置的元素，并将删除位置之后的元素依次前移。
在查找操作中，可以正确返回目标值的位置。
在输出操作中，可以正确输出顺序表中的所有元素。
五、实验总结通过本次实验，我深入了解了顺序表的原理和基本操作，并通过实际编程实现了顺序表的各项功能。
在实验过程中，我遇到了一些问题，如如何判断顺序表是否已满或为空，如何处理插入和删除位置的合法性等。
通过查阅资料和与同学讨论，我解决了这些问题，并对顺序表的操作有了更深入的理解。
实验一 顺序表的基本操作1
实验一：顺序表的基本操作一、实验目的1．掌握线性表的顺序存储结构的表示和实现方法。
2．掌握顺序表基本操作的算法实现。
3．了解顺序表的应用。
二、实验环境硬件环境要求：PC 机（单机）使用的软件名称、版本号以及模块：Visual C++ 6.0 或 Turbo C 或 Win-TC 等。
三、实验内容编写一个程序，实现顺序表的各种基本运算（假设顺序表的元素类型为 char），并在此基础上设计一个主程序完成如下功能：（1）初始化顺序表L;（2）依次采用尾插法插入a、b、c、d、e元素;（3）输出顺序表L;（4）输出顺序表L的长度；（5）判断顺序表L是否为空；（6）输出顺序表L的第3个元素；（7）输出元素a的位置；（8）在第4个元素位置上插入f元素；（9）输出顺序表L；（10）删除L的第3个元素；（11）输出顺序表L；（12）释放顺序表L;四、实验要求1、用 Visual C++ 6.0 或 Turbo C 或 Win-TC 工具创建文件或程序，输入代码后，进行编译运行或在控制台执行。
2、观看程序运行结果，并根据结果进行思考，对程序进行修改和总结。
3、请在实验报告上写上实验要求、规范的程序代码、运行结果和你的总结体会。
【核心算法提示】1．顺序表插入操作的基本步骤：要在顺序表中的第 i 个数据元素之前插入一个数据元素 x，首先要判断插入位置 i 是否合法，假设线性表的表长为 n，则 i 的合法值范围：1≤i≤n+1，若是合法位置，就再判断顺序表是否满，如果满，则增加空间或结束操作，如果不满，则将第 i 个数据元素及其之后的所有数据元素都后移一个位置，此时第 i 个位置已经腾空，再将待插入的数据元素 x 插入到该位置上，最后将线性表的表长增加 1。
2．顺序表删除操作的基本步骤：要删除顺序表中的第 i 个数据元素，首先仍然要判断i 的合法性，i 的合法范围是1≤i≤n，若是合法位置，则将第i 个数据元素之后的所有数据元素都前移一个位置，最后将线性表的表长减 1。
实验1_实现顺序表的基本操作
实验一：线性表的顺序存储结构课程名称：数据结构姓名：班级：学号：指导教师评定：一、实验目的：1.熟练掌握线性表的基本操作在顺序存储和链式存储上的实现；2.以线性表的各种操作（建立、插入、删除等）的实现为重点；3.掌握线性表的动态分配顺序存储结构的定义和基本操作的实现；二、实验内容：1．输入一组整型数据，建立顺序表。
2．实现该线性表的删除。
3、实现该线性表的插入。
4．实现线性表中数据的显示。
5．实现线性表数据的查找和定位6、编写一个主函数,调试上述算法。
三、实验原理、方法和手段1.根据实验内容编程，上机调试、得出正确的运行程序。
2.编译运行程序，观察运行情况和输出结果。
3.写出实验报告（包括源程序和运行结果）。
四、实验条件运行Visual c++的微机一台五、实验步骤（程序清单）：（一）、程序代码：#include<iostream>using namespace std;typedef int ElemType;typedef int Status;const OVERFLOW = -2;const ERROR = -1;const OK = 1;const LIST_INIT_SIZE = 100; //线性表的初始存储空间const LISTINCREMENT =10; //线性表的增量空间typedef struct SqList{ElemType *base;int length;int ListSize;}SqList;void CreatSqList(int n,SqList &L){L.length = n;L.ListSize = n+15;L.base = new ElemType[L.ListSize];if(!L.base) cout<<OVERFLOW<<endl;cout<<"input "<<L.length<<" elements:"<<endl;for(int k=1; k<=L.length; k++)cin>>L.base[k-1];}void display1(SqList L1){if(L1.length == 0){cout<<"empty list found!"<<endl;return;}cout<<"您输入的线性表数据为：\n";for(int k=0; k < L1.length; k++)cout<<L1.base[k]<<" ";}//定位Status LocateSqList(SqList L,ElemType x){cout<<endl;cout<<"****************表中数字定位********************"<<endl;if(L.length == 0) return 0;cout<<"input a int number x: ";cin>>x;for(int k=0; k<L.length; k++)if(x == L.base[k])cout<<"x locate is "<<k<<endl;return k;return -1;}//查找Status SearchSqlist(SqList L,int x){//顺序查找cout<<endl;cout<<"*********************线性查找*********************"<<endl;cout<<"input x:";cin>>x;for(int i=0; i < L.length; i++)if(L.base[i] == x)cout<<"the index of x is the list is:"<<i;return i;return -1;}//排序void bubbleSort1(SqList L){cout<<endl;cout<<"****************冒泡排序*************************"<<endl;cout<<"顺序表的排序结果为：";bool flag = true; //标记某趟冒泡排序是否有过交换，初始化位true ElemType temp;//从上向下依次比较相邻气泡的重量。
实验1 顺序表基本操作
实验1 顺序表基本操作【实验目的】<1>熟悉C语言的上机环境，掌握C语言的基本结构<2>会定义线性表的顺序存储结构<3>熟悉对顺序表的一些基本操作<4>熟悉与线性表相关的函数的定义和使用【实验内容】[实验任务一]顺序表的基本操作1.顺序表的插入操作【操作步骤】<1>启动辅助教学软件<2>选择“C语言”<3>选择“顺序表”<4>选择“顺序表插入”<5>输入建立表的数据<6>输入插入数据元素<7>输入插入位置<8>选择单步执行2.顺序表的删除操作【操作步骤】<1>启动辅助教学软件<2>选择“C语言”<3>选择“顺序表”<4>选择“顺序表插入”<5>输入建立表的数据<6>输入删除位置<7>选择单步执行[实验任务二]编写C语言程序1. 编程实现顺序表的插入操作。
2.编程实现顺序表的删除操作。
实验2 链表的基本操作【实验目的】<1>学会定义单链表的结点类型<2>熟悉单链表的一些基本操作，依据这些操作函数定义<3>掌握线性表的链式存储结构的特点<4>掌握循环链表和双向链表的定义、构造方法等。
【实验内容】[实验任务一]验证单链表的基本操作<1>单链表的插入操作<2>单链表的删除操作[实验任务二]编写C语言程序<1>用C语言实现构造单链表<2>用C语言实现输出单链表实验3 二叉树的基本操作【实验目的】<1>熟悉二叉树的结点结构<2>熟悉二叉树的基本操作<3>学会利用递归方法编写二叉树的遍历算法【实验内容】[实验任务一]二叉树的遍历<1>先序遍历<2>中序遍历<3>后续遍历[实验任务二]编写算法<1>根据二叉树的任一遍历算法，编写求二叉树中结点个数的算法。
实验一顺序表的基本操作
实验一顺序表的基本操作一、实验目的1．掌握线性表的顺序存储结构的表示和实现方法。
2．掌握顺序表基本操作的算法实现。
3．了解顺序表的应用。
4．学会用Java语言编写算法并上机调试通过。
二、实验内容1．建立顺序表。
2．在顺序表上实现插入、删除和查找操作（验证性内容）。
3．删除有序顺序表中的重复元素（设计性内容）。
4．完成一个简单学生成绩管理系统的设计（应用性设计内容）。
三、实验要求1. 验证性实验要求编程实现如下功能：（1）根据输入顺序表的长度n和各个数据元素值建立一个顺序表，并输出顺序表中各元素值，观察输入的内容与输出的内容是否一致。
（2）在顺序表的第i个元素之前插入一个值为x的元素，并输出插入后的顺序表中各元素值。
（3）删除顺序表中第i个元素，并输出删除后的顺序表中各元素值。
（4）在顺序表中查找第i个元素，如果查找成功，则显示“查找成功”和该元素在顺序表中的位置，否则显示“查找失败”。
2. 设计性实验要求编程实现删除有序顺序表中的所有重复元素，即使有序顺序表中相同的元素只保留一个：(1) 根据输入的n个非递减的有序数据建立一个有序顺序表，并输出有序顺序表中各元素值。
(2) 删除有序顺序表中所有的重复元素，并显示删除后的有序顺序表中各元素值。
3. 应用性设计实验要求编程实现一个简单学生成绩表的操作,此系统的功能包括：(1) 查询：按特定的条件查找学生(2) 修改：按学号对某个学生的某门课程成绩进行修改(3) 插入：增加新学生的信息(4) 删除：按学号删除已退学的学生的信息。
要求采用顺序存储结构来实现对上述成绩表的相关操作。
四、源程序代码/**** 验证性实验的源程序代码**/import java.util.Scanner;public class SX1_SqList {private Object[] listElem; // 线性表存储空间private int curLen; // 当前长度// 顺序表的构造函数，构造一个存储空间容量为maxSize的线性表public SX1_SqList(int maxSize) {curLen = 0; // 置顺序表的当前长度为0listElem = new Object[maxSize];// 为顺序表分配maxSize个存储单元}// 在线性表的第i个数据元素之前插入一个值为x的数据元素。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验1 顺序表存储与操作实现
一、实验目的
1. 理解线性表的概念。
2. 掌握顺序表的定义和操作。
3. 掌握利用顺序表解决实际问题的方法。
二、实验内容和要求
1.根据教材中内容，建立顺序表的完整程序（包括定义以及11个基本操作）
2.根据以下步骤进行验证实验：
（1）定义数组:
a[10]={45,53,18,36,72,30,48,93,15,32};
（2）定义顺序表L，并调用InsertList函数将数组a中的元素按照原顺序插入到L中，并利用TraverseList函数遍历L。
（3）调用SortList函数对L进行排序，并遍历L
（4）按照有序方式插入元素27，并遍历L
（5）删除元素36，并遍历L
3.根据以下要求设计实验：
编写函数
void MergeList(List L1,List L2,List &L3)
实现功能：将有序表L1，L2中的元素按照有序的方式合并到L3中。
（注：禁止采用InsertList和SortList函数）
（1）定义有序表：
L1：6,12 21,27,35,38
L2：8,15,18,23
利用MergeList函数将L1,L2合并到有序表L3中，并遍历L3。
（2）定义有序表：
L4：1,3,5,10,14
L5：2,4,8,15,18,24,26,27
利用MergeList函数将L4,L5合并到有序表L6中，并遍历L6。
4.程序运行结果如下：
命名格式：数学X班XXX.cpp。