实验一 顺序表操作实现
顺序表的基本操作实验报告
顺序表的基本操作实验报告一、实验目的本次实验旨在深入理解和掌握顺序表的基本操作，包括顺序表的创建、插入、删除、查找和遍历等功能，并通过实际编程实现，加深对数据结构中顺序存储结构的理解和应用能力。
二、实验环境本次实验使用的编程语言为 C 语言，编程环境为 Visual Studio 2019。
三、实验原理顺序表是一种线性表的顺序存储结构，它使用一组连续的存储单元依次存储线性表中的元素。
在顺序表中，元素的逻辑顺序与物理顺序是一致的。
顺序表的基本操作包括：1、创建顺序表：为顺序表分配存储空间，并初始化相关参数。
2、插入操作：在指定位置插入元素，需要移动后续元素以腾出空间。
3、删除操作：删除指定位置的元素，并将后续元素向前移动。
4、查找操作：在顺序表中查找指定元素，返回其位置或表示未找到。
5、遍历操作：依次访问顺序表中的每个元素。
四、实验步骤1、定义顺序表的数据结构｀｀｀cdefine MAXSIZE 100 ／／定义顺序表的最大长度typedef struct ｛int dataMAXSIZE; ／／存储顺序表元素的数组int length; ／／顺序表的当前长度｝ SeqList;｀｀｀2、顺序表的创建｀｀｀cvoid InitList(SeqList L) ｛L>length ＝ 0; ／／初始化顺序表长度为 0｝｀｀｀3、顺序表的插入操作｀｀｀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+＋；／／顺序表长度增加 1return 1;｝｀｀｀4、顺序表的删除操作｀｀｀cint DeleteList(SeqList L, int i) ｛if （i ＜ 1 ｜｜ i ＞ L>length) ｛／／删除位置不合法return 0;｝for （int j ＝ i; j ＜ L>length; j+＋）｛／／移动元素填补删除位置L>dataj 1 ＝ L>dataj;｝L>length; ／／顺序表长度减少 1return 1;｝｀｀｀5、顺序表的查找操作｀｀｀cint SearchList(SeqList L, int e) ｛for （int i ＝ 0; i ＜ Llength; i+＋）｛if （Ldatai ＝＝ e) ｛／／找到元素return i ＋ 1;｝｝return 0; ／／未找到元素｝｀｀｀6、顺序表的遍历操作｀｀｀cvoid TraverseList(SeqList L) ｛for （int i ＝ 0; i ＜ Llength; i+＋）｛printf(＂％d ＂， Ldatai)；／／输出顺序表中的元素｝printf(＂＼n"）；｝｀｀｀五、实验结果与分析1、测试创建顺序表｀｀｀cSeqList L;InitList(＆L)；｀｀｀创建成功，顺序表初始长度为 0。
顺序表的实现实验报告
顺序表的实现实验报告顺序表的实现实验报告1. 引言顺序表是一种常见的数据结构，它可以用于存储一组有序的元素。
在本实验中，我们将探索顺序表的实现方式，并通过实验验证其性能和效果。
2. 实验目的本实验的主要目的是掌握顺序表的实现原理和基本操作，并通过实验对比不同操作的时间复杂度。
3. 实验方法3.1 数据结构设计我们选择使用静态数组作为顺序表的底层存储结构。
通过定义一个固定大小的数组，我们可以实现顺序表的基本操作。
3.2 基本操作实现在顺序表的实现中，我们需要实现以下基本操作：- 初始化操作：创建一个空的顺序表。
- 插入操作：向顺序表中插入一个元素。
- 删除操作：从顺序表中删除一个元素。
- 查找操作：在顺序表中查找指定元素。
- 获取长度：获取顺序表中元素的个数。
4. 实验步骤4.1 初始化操作首先，我们需要创建一个空的顺序表。
这可以通过定义一个数组和一个变量来实现，数组用于存储元素，变量用于记录当前顺序表的长度。
4.2 插入操作在顺序表中插入一个元素的过程如下：- 首先，判断顺序表是否已满，如果已满则进行扩容操作。
- 然后，将要插入的元素放入数组的末尾，并更新长度。
4.3 删除操作从顺序表中删除一个元素的过程如下：- 首先，判断顺序表是否为空，如果为空则返回错误信息。
- 然后，将数组中最后一个元素删除，并更新长度。
4.4 查找操作在顺序表中查找指定元素的过程如下：- 首先，遍历整个数组，逐个比较元素与目标元素是否相等。
- 如果找到相等的元素，则返回其位置；如果遍历完仍未找到，则返回错误信息。
4.5 获取长度获取顺序表中元素个数的过程如下：- 直接返回记录长度的变量即可。
5. 实验结果与分析在实验中，我们通过对大量数据进行插入、删除、查找等操作，记录了每个操作的耗时。
通过对比不同操作的时间复杂度，我们可以得出以下结论：- 初始化操作的时间复杂度为O(1)，因为只需要创建一个空的顺序表。
- 插入和删除操作的时间复杂度为O(n)，因为需要遍历整个数组进行元素的移动。
顺序表的基本操作和实现实验报告(一)
顺序表的基本操作和实现实验报告(一)顺序表的基本操作和实现实验报告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 。
顺序表的基本操作实验报告
顺序表的基本操作实验报告一、实验目的。
本实验旨在通过对顺序表的基本操作进行实验，加深对顺序表的理解，掌握顺序表的基本操作方法，提高编程实践能力。
二、实验内容。
1. 初始化顺序表，包括建立空的顺序表和建立有元素的顺序表。
2. 插入元素，在指定位置插入元素。
3. 删除元素，删除指定位置的元素。
4. 查找元素，根据元素值查找元素所在位置。
5. 输出顺序表，将顺序表中的元素依次输出。
三、实验步骤。
1. 初始化顺序表。
（1）建立空的顺序表，首先定义一个顺序表的结构体，包括数据存储区和表长两个成员变量。
然后通过动态内存分配为顺序表分配存储空间，并初始化表长为0，即建立了一个空的顺序表。
（2）建立有元素的顺序表，定义一个包含初始元素的数组，然后将数组中的元素依次复制到顺序表的数据存储区中，并更新表长。
2. 插入元素。
在指定位置插入元素时，需要先判断插入位置是否合法，然后将插入位置后的元素依次后移，为插入元素腾出位置，并更新表长。
3. 删除元素。
删除指定位置的元素时，同样需要先判断删除位置是否合法，然后将删除位置后的元素依次前移，覆盖被删除的元素，并更新表长。
4. 查找元素。
根据元素值查找元素所在位置时，需要遍历顺序表中的元素，逐个比较元素值，找到匹配的元素位置后返回位置信息。
5. 输出顺序表。
将顺序表中的元素依次输出时，可以通过循环遍历顺序表中的元素，并逐个输出。
四、实验结果与分析。
经过实验操作，成功实现了顺序表的初始化、插入、删除、查找和输出等基本操作。
通过对顺序表的操作，加深了对顺序表结构和操作方法的理解，掌握了顺序表的基本操作技巧。
在实际编程中，顺序表的基本操作是非常常见的，对于处理线性表数据具有重要意义。
五、实验总结。
通过本次实验，深入理解了顺序表的基本操作方法，掌握了顺序表的初始化、插入、删除、查找和输出等操作技巧。
在今后的学习和工作中，将能更加熟练地运用顺序表的基本操作，提高编程实践能力，为实际问题的解决提供更加有效的数据结构支持。
顺序表的基本操作和实现实验报告
顺序表的基本操作和实现实验报告顺序表的基本操作和实现实验报告引言顺序表是一种常用的数据结构，它能够在连续的存储空间中存储元素，并通过索引来访问和修改这些元素。
本实验旨在通过实现基本操作，包括插入、删除、获取等，来深入理解顺序表的原理和实现方式。
实验目的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．掌握线性表的顺序存储结构的表示和实现方法。
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-顺序表的实现
程序代码编写的要求
• 请首先建立project • 然后创建一个头文件×××.h，其中有你的程 序中要用的数据类型，以及实现各种操作的函 数的声明（不包括函数体）。 • 再创建一个×××.cpp，其中有各个函数的函 数体（具体实现）。 • 最后创建主函数（程序入口） ×××.cpp ，其 中有用于输入、输出的语句，和一些必要的测 试数据。它来调用上述的函数。
实验（1）顺序表的实现
实验目的
•熟悉使用C编写代码实现算法。 • 掌握结构体的使用。 • 熟悉在顺序表上进行的各种操作。
实验要求
• 编写C（C＋＋）应用程序，实现顺序表 上的各自操作：初始化，销毁，插入， 删除，定位，求表长、“判空”以及 “存取第 i 个数据元素”。
实验报告的书写要求
• • • • • 实验目的 实验要求 实验环境 程序代码 程序的调试与分析
实验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;//从上向下依次比较相邻气泡的重量。
数据结构实验报告-实验一顺序表、单链表基本操作的实现
数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现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.输入一组整型元素序列，建立顺序表。
2.实现该顺序表的遍历。
3.在该顺序表中进行顺序查找某一元素，查找成功返回1，否则返回0。
4.判断该顺序表中元素是否对称，对称返回1，否则返回0。
5.实现把该表中所有奇数排在偶数之前，即表的前面为奇数，后面为偶数。
6.* 输入整型元素序列利用有序表插入算法建立一个有序表。
7.* 利用算法6建立两个非递减有序表并把它们合并成一个非递减有序表。
8.编写一个主函数，调试上述算法。
二、源代码#include"stdio.h"#include"stdlib.h"#define ElemType int//int类型宏定义#define MAXSIZE 100//顺序结构typedef struct{ElemType elem[MAXSIZE]; //元素数组int length; //当前表长}SqList;//建立顺序表void BuildList(SqList &L){int n;printf("请输入建立顺序表的大小。
n=");scanf("%d",&n);L.length=n;printf("\n开始建立顺序表...\n");for(int i=0;i<L.length;i++)//循环建立顺序表{printf("\n请输入第%d个元素：",i+1);scanf("%d",&L.elem[i]);}printf("\n建立顺序表完毕！...\n");}//遍历顺序表void ShowList(SqList &L){int i;printf("\n开始遍历顺序表...\n");for(i=0;i<L.length;i++)printf("%d ",L.elem[i]);printf("\n遍历结束...\n");}//在顺序表中寻找X元素int FindList(SqList &L,int x){int a=0;for(int i=0;i<L.length;i++){if(L.elem[i]==x)a=1;}if(a==1)printf("1\n");elseprintf("0\n");return 0;}//判断是否对称int Duichen(SqList &L){int j,b=1,n;n=L.length;if(n%2==0){for(j=0;j<n/2;j++){if(L.elem[j]!=L.elem[L.length-j-1])b=0;}}elsefor(j=0;j<(n-1)/2;j++){if(L.elem[j]!=L.elem[L.length-j-1])b=0;}if(b==1)printf("1\n");elseprintf("0\n");return 0;}//前面为奇数，后面为偶数void PaixuList(SqList &L){int i,j,a;for(i=1;i<L.length;i++){if(L.elem[i]%2==1){a=L.elem[i];for(j=i;j>0;j--){L.elem[j]=L.elem[j-1];}L.elem[0]=a;i++;}}for(i=0;i<L.length;i++)printf("%d ",L.elem[i]);printf("\n");}int main(){SqList List;int n;while(1){printf("\n 实验一：顺序表\n");printf("\n******************************************************************");printf("\n 1.创建顺序表");printf("\n 2.遍历顺序表");printf("\n 3.在该顺序表中进行顺序查找某一元素，查找成功返回1，否则返回0");printf("\n 4.判断该顺序表中元素是否对称，对称返回1，否则返回0");printf("\n 5.该表中所有奇数排在偶数之前，即表的前面为奇数，后面为偶数");printf("\n 0.退出");printf("\n******************************************************************\n");printf("\n请输入选择序号：");scanf("%d",&n);switch(n){case 0:return 0;case 1:BuildList(List);break;case 2:ShowList(List);break;case 3:int X;printf("请输入要查找值：X=");scanf("%d",&X);FindList(List,X);break;case 4:Duichen(List);break;case 5:PaixuList(List);break;default:printf(" 请输入数字0-5 \n");}}return 0;}三、运行结果1）程序主界面2）选择1建立顺序表3）选择2遍历顺序表4）选择3查询元素X5）选择4判断是否对称6）选择5奇数在前，偶数在后7）选择0退出。
数据结构实验一顺序表实验报告
数据结构实验一顺序表实验报告数据结构实验一顺序表实验报告一、实验目的顺序表是一种基本的数据结构，本次实验的目的是通过实现顺序表的基本操作，加深对顺序表的理解，并掌握顺序表的插入、删除、查找等操作的实现方法。
二、实验内容1. 实现顺序表的创建和初始化操作。
2. 实现顺序表的插入操作。
3. 实现顺序表的删除操作。
4. 实现顺序表的查找操作。
5. 实现顺序表的输出操作。
三、实验步骤1. 创建顺序表的数据结构，包括数据存储数组和记录当前元素个数的变量。
2. 初始化顺序表，将当前元素个数置为0。
3. 实现顺序表的插入操作：- 判断顺序表是否已满，若已满则输出错误信息。
- 将插入位置之后的元素依次后移一位。
- 将要插入的元素放入插入位置。
- 当前元素个数加一。
4. 实现顺序表的删除操作：- 判断顺序表是否为空，若为空则输出错误信息。
- 判断要删除的位置是否合法，若不合法则输出错误信息。
- 将删除位置之后的元素依次前移一位。
- 当前元素个数减一。
5. 实现顺序表的查找操作：- 遍历顺序表，逐个比较元素值与目标值是否相等。
- 若找到目标值，则返回该元素的位置。
- 若遍历完整个顺序表仍未找到目标值，则返回错误信息。
6. 实现顺序表的输出操作：- 遍历顺序表，逐个输出元素值。
四、实验结果经过实验，顺序表的各项操作均能正确实现。
在插入操作中，可以正确将元素插入到指定位置，并将插入位置之后的元素依次后移。
在删除操作中，可以正确删除指定位置的元素，并将删除位置之后的元素依次前移。
在查找操作中，可以正确返回目标值的位置。
在输出操作中，可以正确输出顺序表中的所有元素。
五、实验总结通过本次实验，我深入了解了顺序表的原理和基本操作，并通过实际编程实现了顺序表的各项功能。
在实验过程中，我遇到了一些问题，如如何判断顺序表是否已满或为空，如何处理插入和删除位置的合法性等。
通过查阅资料和与同学讨论，我解决了这些问题，并对顺序表的操作有了更深入的理解。
实验一顺序表的基本操作1
实验⼀顺序表的基本操作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。
实验一 顺序表的实现和应用
实验一顺序表的实现和应用一、实验目的⑴熟悉线性表的定义和基本操作；⑵掌握线性表的顺序存储结构设计与基本操作的实现；二、实验内容与要求⑴定义线性表的顺序存储表示；⑵基于所设计的存储结构实现线性表的基本操作；⑶编写一个主程序对所实现的线性表进行测试；⑷线性表的应用：使用菜单方式实现顺序表的各种操作，例如：创建、插入、删除、显示等等。
二、数据结构设计在主函数中实现函数的调用，从而实现线性表的创建（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．掌握利用VC/TC实现数据结构的编程方法。
3．通过上机实践进一步加深对线性表的顺序存储方式理解。
4．通过上机实践加强利用数据结构解决实际应用问题的能力。
二、实验要求1．实验前做好充分准备，包括复习第一章、第二章所学内容，事先预习好本次实验内容。
2．实验时记录实验结果，按要求完成各题。
3．实验结束后，给出实验总结与分析并及时给出本次实验的实验报告。
三、实验内容与要求实验题目：顺序表的定义及其相关操作算法的实现要求：编程实现顺序表的类型定义及顺序表的初始化操作、插入操作、删除操作、取元素操作、输出操作等，并对其进行验证。
四、实验程序示例1、顺序表实验程序示例#include "stdio.h"#include "alloc.h"/*-------------（1）预定义常量及类型-----------------*/#define OK 1#define ERROR 0#define OVERFLOW -2#define TRUE 1#define FALSE 0typedef int Status;/*-------（2）顺序表类型及其基本操作函数的定义---------*/#define InitSize 100#define INCR 20typedef int ElemType; /*定义元素类型为int类型*/typedef struct{ ElemType *Elem;int Length;int ListSize;}SqList; /*SqList类型为顺序表类型*/Status InitList_sq(SqList *L) /*初始化操作函数定义*/{ L->Elem=(ElemType*)malloc(InitSize*sizeof(ElemType));if (!(L->Elem))return(OVERFLOW);L->Length=0; L->ListSize=InitSize;return OK;}Status ListInsert_sq(SqList *L, int i, ElemType e) /*插入操作函数定义*/{/* 写出你的代码*/}Status ListDelete_sq(SqList *L, int i) /*删除第i 个位置的元素*/ {/* 写出你的代码*/}Status LocateElem(SqList *L, ElemType e) /*查找值为e的元素的位置*/{/* 写出你的代码*/}/* 以下为选作的*//*void exchange ( SqList *L,int m ,int n) // 本算法实现顺序表中前m 个元素和后n 个元素的互换void purge(SqList *L ) // 删除顺序表L 中冗余元素v oid ReverseSeqList(SqList &L) //倒置v oid MergeList(SqList la,SqList lb,Sqlist &lc)//有数据类型为整型顺序表La和Lb，其元素均按从小到大升序排列，编写一个算法将它们合并成一个表Lc，且Lc的元素也是按升序排列。
实验一 顺序表和单链表的基本操作的实现
实验一顺序表和单链表的基本操作的实现一、顺序表实验内容：1.编写函数,通过数组,建立一个顺序表。
2.编写函数,实现对该顺序表的遍历。
3.编写函数,在顺序表中进行顺序查找某一元素,查找成功则返回其存储位置i,否则返回错误信息。
4.编写函数,实现在顺序表的第i个位置上插入一个元素e的算法。
5.编写函数,实现删除顺序表中第i个元素的算法。
6.编写函数,实现输入一个元素data,把它插入到有序表中,使顺序表依然有序。
7.编写一个主函数,在主函数中设计一个简单的菜单,分别调试上述算法。
实验目的及要求：1.掌握顺序表的存储结构形式及其描述2.掌握顺序表的建立、查找、插入和删除操作。
实验程序：#include <stdio.h>#include <stdlib.h>#define M 100 //最大限void creat_list(int a[], int n); //建立顺序表void datafind_list(int a[],int d); //按值查找元素void find_list(int a[],int i); //按位查找元素void in(int a[], int i,int e); //插入接点void delet(int a[], int i); //删除接点void print_list(int a[] ); //打印顺序表int main(){int a[M];int data;int num;int place; int ch;printf("输入数据个数：");scanf("%d",&num);creat_list(a, num);print_list(a);while(1){printf("请选择操作：\n");printf("***************************************************************\n") ;printf("1.按值查找 2.按位查找 3.插入接点 4.删除接点 \n");printf("***************************************************************\n") ;scanf("%d",&ch);switch(ch){case 1:printf("Pleae enter the data you want to find:\n"); //按值查找scanf("%d",&data);datafind_list(a,data);break;case 2:printf("Pleae enter where you want to find:\n"); //按位查找scanf("%d",&place);printf("The place is :%d\n",place);find_list(a, place);break;case 3:printf("Pleae enter where you want to insert:\n"); //插入接点scanf("%d",&place);printf("input a data what you want to insert");scanf("%d",&data);in(a,place,data);print_list(a); break;case 4:printf("Pleae enter where you want to delet:\n"); //删除接点scanf("%d",&place);printf("The place is :%d\n",place);printf("Pleae enter where you want to delet:\n");scanf("%d",&place);printf("The place is :%d\n",place);delet(a, place);print_list(a);break;default: printf("输入错误，请重新选择");break;}}return 0;}void creat_list(int a[], int n) //建立顺序表{ int i;int j;int x;printf("输入数据：");scanf("%d",&a[1]);for (i = 2; i <= n; i++){ scanf("%d",&x);for (j = 1; j <= i - 1; j++){ if (x == a[j]){break;} }if (j > i - 1){a[i] = x;}elsei--;}a[0] = n;}void datafind_list(int a[],int d) //按值查找元素{ int i;int j=0;for(i=1;i<=a[0];i++){if(d==a[i])printf("the data is %d and its place is %d\n",d,i);else j++;}if (j==a[0]){printf("error\n");}}void find_list(int a[],int i) //按位查找{if (i < 1 || i > a[0] + 1){printf("error");}else printf("%5d",a[i]);}void in(int a[], int i,int e) //插入表中某个元素{ int j;if (i < 1 || i > a[0] + 1){printf("error");}else{ a[0] = a[0] + 1;for (j = a[0]; j >i; j--) //后移插入位置后的数{a[j] = a[j-1];}a[i]=e;}}void delet(int a[], int i) //删除表中某个元素{ int j;if (i < 1 || i > a[0] + 1){printf("error");exit(0);}for (j = i + 1; j <= a[0]; j++) //前移被删数的位置 {a[j - 1] = a[j];}a[0] = a[0] - 1;}void print_list(int a[] ) //打印顺序表{ int i;printf("\n");printf("顺序表是：");for (i = 1; i <= a[0]; i++){printf("%5d",a[i]);}printf("\n");}实验结果：实验分析：实验成功实现顺序表的基本操作！成功完成本实验，需要掌握顺序表的结构和理解顺序表结构的实验原理。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验一顺序表操作实现实验日期：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 。
（2）seqlist.cpp程序编译连接通过后能执行吗？为什么？其代码的整体结构有哪几个组成部分？答：不能。
因为没有主函数，程序无法运行。
代码的整体结构的组成部分有：typedef struct datatype;typedef struct Seqlist;void initList(Seqlist *lp);/*置一个空表*/void sort_xh(Seqlist *lp);/*按学号排序*/void createList(Seqlist *lp);/*建一个学生顺序表*/void Error(char *s);/*自定义错误处理函数*/void pntList(Seqlist *lp);/*输出学生表*/void save(Seqlist *lp,char strname[]);/*保存学生顺序表到指定文件*/（3）回答下列问题a）initList函数的形参变量lp存放什么值？顺序表置为空表的实质是做什么操作？答：学生信息：学号，身高，性别。
顺序表的初始化即构造一个空表，这对表是一个加工型的运算，因此，将L 设为指针参数，首先动态分配存储空间，然后，将表中last指针置为0，表示表中没有数据元素。
b）在建立顺序表的createList函数中，顺序表的数据元素来自何处？根据已提供的数据建完的顺序表表长是多少？答：顺序表的数据元素来自文件，顺序表表长是：last。
c）sort_xh排序函数采用了什么排序方法？请列举5个学号值写出每趟（5个需排4趟）排序后的结果答：选择排序。
第一次排序1,3,6,4,5第二次排序1,3,6,4,5第三次排序1,3,4,6,5第四次排序1,3,4,5,6d）列举一个调用自定义错误处理函数Error的调用语句，并给出屏幕输出结果can not open file!e）save函数中的形参数组strname中存放什么？答：存放的是学生的学生的信息：学号，身高，性别。
任务二1．题目要求创建一个新的程序文件sy11.cpp，请调用seqlist.cpp提供的功能函数（以#include “seqlist.cpp”方式导入函数库）及自定义的函数完成以下操作：●创建一个包含学生学号、身高、性别的学生身高信息表并输出到屏幕，学生信息从records.txt文件读取；●对已建立的学生身高信息表按学号从小到大排序，并把结果写入到数据文件中（result.txt）；●从键盘输入一位学生的相关信息插入到已排序的学生身高信息表中后仍然保持学号的有序性；●对插入后的学生身高信息表进行倒置，结果输出在屏幕；●从键盘输入一个身高值，统计与该身高相同的学生个数并输出在屏幕；在程序文件sy1.cpp需再定义以下三个功能函数：（1）void insertX(Seqlist *lp, datatype x)功能：在学号从小到大排序的学生表中插入值为x的学生仍保持学号的有序性（2）void reverse(Seqlist *lp)功能：对lp指向的顺序表进行倒置操作（3）int count(Seqlist *lp，float y)功能：统计学生表中身高值为y的学生数并返回2．请根据题目功能要求及程序中的注释填空完整sy1.cpp代码/*sy11.cpp程序文件代码*/#include "seqlist.cpp" //导入自定义类型及函数所在的文件seqlist.cpp,该文件与sy11.cpp存于同一目录中void insertX(Seqlist *lp, datatype x);void reverse(Seqlist *lp);int count(Seqlist *lp,float y);void main(){Seqlist stu; //定义stu为学生顺序表变量datatype x; //x为存储一个学生信息的变量int c;char strname[20]; //strname为存储文件名的数组/*创建一个包含学生学号、身高、性别的学生身高信息表stu并输出到屏幕，学生信息从records.txt文件读取*/initList(&stu) //调用函数initList初始化顺序表stucreateList(&stu) // 调用函数createList创建学生表stuprintf("\nsource list:\n");pntList(&stu) //调用函数pntList打印学生表stugetchar(); //在执行程序能起到暂定的作用，按任意键继续/*对已建立的学生身高信息表按学号从小到大排序，并把结果写入到数据文件中（result.txt）*/sort_xh(stu) //调用函数sort_xh 对学生表stu按学号从小到大排序printf("\nInput new file name to save: ");scanf(“”) //键盘输入文件名字符串存于strname字符数组中save(&stu,strname) //调用函数save把排序后的顺序表stu存于文件中，文件名在strname数组中/*从键盘输入一位学生的相关信息插入到已排序的学生身高信息表中后仍然保持学号的有序性；*/printf("\nInput a student information: \n");scanf("%d%f%d",&x.xh,&x.sg,&x.sex);insertX(&stu,x) //插入printf("\nlist after insert:\n");pntList(&stu);getchar();/*对插入后的学生身高信息表进行倒置，结果输出在屏幕；*/reserve(&stu) //倒置顺序表printf("\nlist after reverse:\n");pntList(&stu);getchar();/*从键盘输入一个身高值，统计与该身高相同的学生个数并输出在屏幕*/printf("\nInput a student height: \n");scanf("%f",&x.sg);c=count(&stu,y) //统计相同身高的学生数存于c中printf("\nThe same height :%d\n",c);getchar();}/*在学号从小到大排序的学生表中插入值为x的学生仍保持学号的有序性*/ void insertX(Seqlist *lp,datatype x){int i,j;if(lp->last>=MAX)Error("list is full");//在学号升序的顺序表中找插入位置后，插入x并使表长增1 elsefor(i=0;i<lp->last;i++)if(lp->last>x)break;for(j=lp->last-1;j>=i;j--) /*从后往前元素后移*/lp-> strname [j+1]=lp-> strname [j];lp-> strname [i]=x; lp->last++; /*插入并表长增1*/}/*对lp指向的顺序表进行倒置操作*/void reverse(Seqlist *lp){ int i,j;datatype temp;//通过前后数据元素交换的方式实现倒置for (i = 0; j = lp->last – 1, j - i >= 0; i++, j--) {temp = lp->data[i].sg;lp->data[i].sg = lp->data[j].sg;lp->data[j].sg = temp;}}/*统计学生表中身高值为y的学生数并返回*/int count(Seqlist *lp,float y){ int i,c=0;//遍历顺序表统计身高为y的学生数到c变量并返回值i = lp->last;while (i){if (lp->data[i - 1].sg = y) {c++;i--;}}}实验总结分析（本程序的重点与难点，调试中出现的问题及解决方法等）。