线性表顺序存储实现、插入、删除操作
线性表 知识点总结
线性表知识点总结线性表的特点：1. 有序性：线性表中的元素是有序排列的，每个元素都有唯一的前驱和后继。
2. 可变性：线性表的长度是可变的，可以进行插入、删除操作来改变表的元素数量。
3. 线性关系：线性表中的元素之间存在明确的前驱和后继关系。
4. 存储结构：线性表的存储结构有顺序存储和链式存储两种方式。
线性表的操作：1. 查找操作：根据元素的位置或值来查找线性表中的元素。
2. 插入操作：将一个新元素插入到线性表中的指定位置。
3. 删除操作：将线性表中的某个元素删除。
4. 更新操作：将线性表中的某个元素更新为新的值。
线性表的顺序存储结构：顺序存储结构是将线性表的元素按照其逻辑顺序依次存储在一块连续的存储空间中。
线性表的顺序存储结构通常采用数组来实现。
数组中的每个元素都可以通过下标来访问，因此可以快速的进行查找操作。
但是插入和删除操作会导致元素位置的变动，需要进行大量数据搬移，效率较低。
线性表的链式存储结构：链式存储结构是将线性表的元素通过指针相连，形成一个链式结构。
每个元素包含数据和指向下一个元素的指针。
链式存储结构不需要连续的存储空间，可以动态分配内存，适合插入和删除频繁的场景。
但是链式结构的元素访问不如顺序结构高效，需要通过指针来逐个访问元素。
线性表的应用场景：1. 线性表适用于数据元素之间存在明确的前后关系，有序排列的场景。
2. 顺序存储结构适用于元素的插入和删除操作较少，对元素的随机访问较频繁的场景。
3. 链式存储结构适用于插入和删除操作较频繁的场景，对元素的随机访问较少。
线性表的操作的时间复杂度：1. 查找操作：顺序存储结构的时间复杂度为O(1)，链式存储结构的时间复杂度为O(n)。
2. 插入和删除操作：顺序存储结构的时间复杂度为O(n)，链式存储结构的时间复杂度为O(1)。
线性表的实现：1. 顺序存储结构的实现：使用数组来存储元素，通过下标来访问元素。
2. 链式存储结构的实现：使用链表来实现，每个元素包含数据和指向下一个元素的指针。
线性顺序表的插入与删除(实验报告)
一、实验目的和要求通过对顺序表的编程练习，加强对顺序表的特点、顺序存储结构及其基本运算的理解和掌握。
提前了解实验相关的c语言的知识。
使用C语言根据相应算法编写一个程序，实现建立线性顺序表、插入和删除等基本操作。
要求仔细阅读下面的内容，编写一个C程序，上机调试通过，并观察其结果，写出实验报告书。
二、实验内容和原理内容：建立一个容量10的顺序表，在其中插入3个元素，然后作删除运算。
原理：在第i个元素前插入元素，从第i个元素开始到最后一个元素均向后移动一个位置，然后将新元素插入到第i个位置，将线性表的长度加1。
删除第i个元素，从第i+1个元素开始到最后一个元素均向前移动一个位置，然后将线性表的长度减1。
三、主要仪器设备计算机一台四、实验主程序#include<stdio.h>#include<stdlib.h>struct List{int size;int n;int *head;};void init(struct List *pl,int size){pl->size=size;pl->n=0;pl->head=malloc(size*sizeof(int)); }void in(int i,int val,struct List *pl){int k;if(pl->n==pl->size){printf("list is full.\n");return;}if(i>pl->n)i=pl->n+1;if(i<1)i=1;for(k=pl->n-1;k>=i-1;--k)pl->head[k+1]=pl->head[k];pl->head[i-1]=val;++pl->n;}void out(int i,struct List *pl){int k;if(pl->n==0){printf("list is empty.\n");return;}if(i<1||i>pl->n){printf("this element is not in the list.\n");return;}for(k=i;k<=pl->n;++k)pl->head[k-1]=pl->head[k];--pl->n;return;}void print(const struct List *pl) {int i;for(i=0;i!=pl->n;++i)printf("%d ",pl->head[i]);printf("\n");}int main(void){int i;struct List list;init(&list,10);for(i=0;i!=5;++i)in(i+1,i,&list);print(&list);in(1,5,&list);print(&list);in(10,4,&list);print(&list);in(5,50,&list);print(&list);out(1,&list);print(&list);out(list.n,&list);print(&list);out(3,&list);print(&list);getchar();return 0;}实验结果五、实验心得通过实验学习，我理解了线性顺序表的插入与删除的算法，了解到线性顺序表的插入与删除得效率低下，感到受益匪浅。
数据结构实验报告-线性表(顺序表实现)
实验1：线性表（顺序表的实现）一、实验项目名称顺序表基本操作的实现二、实验目的掌握线性表的基本操作在顺序存储结构上的实现。
三、实验基本原理顺序表是由地址连续的的向量实现的，便于实现随机访问。
顺序表进行插入和删除运算时，平均需要移动表中大约一半的数据元素，容量难以扩充四、主要仪器设备及耗材Window 11、Dev-C++5.11五、实验步骤1.导入库和一些预定义:2.定义顺序表:3.初始化:4.插入元素:5.查询元素：6.删除元素:7.销毁顺序表:8.清空顺序表:9.顺序表长度:10.判空:11.定位满足大小关系的元素(默认小于):12.查询前驱:13.查询后继:14.输出顺序表15.归并顺序表16.写测试程序以及主函数对顺序表的每一个操作写一个测试函数，然后在主函数用while+switch-case的方式实现一个带菜单的简易测试程序，代码见“实验完整代码”。
实验完整代码:#include <bits/stdc++.h>using namespace std;#define error 0#define overflow -2#define initSize 100#define addSize 10#define compareTo <=typedef int ElemType;struct List{ElemType *elem;int len;int listsize;}L;void init(List &L){L.elem = (ElemType *) malloc(initSize * sizeof(ElemType)); if(!L.elem){cout << "分配内存失败！";exit(overflow);}L.len = 0;L.listsize = initSize;}void destroy(List &L){free(L.elem);L.len = L.listsize = 0;}void clear(List &L){L.len = 0;}bool empty(List L){if(L.len == 0) return true;else return false;}int length(List L){return L.len;}ElemType getElem(List L,int i){if(i < 1 || i > L.len + 1){cout << "下标越界！";exit(error);}return L.elem[i - 1];}bool compare(ElemType a,ElemType b) {return a compareTo b;}int locateElem(List L,ElemType e) {for(int i = 0;i < L.len;i++){if(compare(L.elem[i],e))return i;}return -1;}int check1(List L,ElemType e){int idx = -1;for(int i = 0;i < L.len;i++)if(L.elem[i] == e)idx = i;return idx;}bool check2(List L,ElemType e){int idx = -1;for(int i = L.len - 1;i >= 0;i--)if(L.elem[i] == e)idx = i;return idx;}int priorElem(List L,ElemType cur_e,ElemType pre_e[]) {int idx = check1(L,cur_e);if(idx == 0 || idx == -1){string str = "";str = idx == 0 ? "无前驱结点" : "不存在该元素";cout << str;exit(error);}int cnt = 0;for(int i = 1;i < L.len;i++){if(L.elem[i] == cur_e){pre_e[cnt ++] = L.elem[i - 1];}}return cnt;}int nextElem(List L,ElemType cur_e,ElemType next_e[]){int idx = check2(L,cur_e);if(idx == L.len - 1 || idx == - 1){string str = "";str = idx == -1 ? "不存在该元素" : "无后驱结点";cout << str;exit(error);}int cnt = 0;for(int i = 0;i < L.len - 1;i++){if(L.elem[i] == cur_e){next_e[cnt ++] = L.elem[i + 1];}}return cnt;}void insert(List &L,int i,ElemType e){if(i < 1 || i > L.len + 1){cout << "下标越界！";exit(error);}if(L.len >= L.listsize){ElemType *newbase = (ElemType *)realloc(L.elem,(L.listsize + addSize) * sizeof(ElemType));if(!newbase){cout << "内存分配失败！";exit(overflow);}L.elem = newbase;L.listsize += addSize;for(int j = L.len;j > i - 1;j--)L.elem[j] = L.elem[j - 1];L.elem[i - 1] = e;L.len ++;}void deleteList(List &L,int i,ElemType &e){if(i < 1 || i > L.len + 1){cout << "下标越界！";exit(error);}e = L.elem[i - 1];for(int j = i - 1;j < L.len;j++)L.elem[j] = L.elem[j + 1];L.len --;}void merge(List L,List L2,List &L3){L3.elem = (ElemType *)malloc((L.len + L2.len) * sizeof(ElemType)); L3.len = L.len + L2.len;L3.listsize = initSize;if(!L3.elem){cout << "内存分配异常";exit(overflow);}int i = 0,j = 0,k = 0;while(i < L.len && j < L2.len){if(L.elem[i] <= L2.elem[j])L3.elem[k ++] = L.elem[i ++];else L3.elem[k ++] = L2.elem[j ++];}while(i < L.len)L3.elem[k ++] = L.elem[i ++];while(j < L2.len)L3.elem[k ++] = L2.elem[j ++];}bool visit(List L){if(L.len == 0) return false;for(int i = 0;i < L.len;i++)cout << L.elem[i] << " ";cout << endl;return true;}void listTraverse(List L){if(!visit(L)) return;}void partion(List *L){int a[100000],b[100000],len3 = 0,len2 = 0; memset(a,0,sizeof a);memset(b,0,sizeof b);for(int i = 0;i < L->len;i++){if(L->elem[i] % 2 == 0)b[len2 ++] = L->elem[i];elsea[len3 ++] = L->elem[i];}for(int i = 0;i < len3;i++)L->elem[i] = a[i];for(int i = 0,j = len3;i < len2;i++,j++) L->elem[j] = b[i];cout << "输出顺序表:" << endl;for(int i = 0;i < L->len;i++)cout << L->elem[i] << " ";cout << endl;}//以下是测试函数------------------------------------void test1(List &list){init(list);cout << "初始化完成!" << endl;}void test2(List &list){if(list.listsize == 0)cout << "线性表不存在!" << endl;else{int len;ElemType num;cout << "选择插入的元素数量：" << endl;cin >> len;cout << "依次输入要插入的元素：" << endl;for(int i = 1;i <= len;i++){cin >> num;insert(list,i,num);}cout << "操作成功！" << endl;}}void test3(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{cout << "请输入要返回的元素的下标" << endl;int idx;cin >> idx;cout << "线性表中第" << idx << "个元素是：" << getElem(L,idx) << endl;}}void test4(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{int idx;ElemType num;cout << "请输入要删除的元素在线性表的位置" << endl;cin >> idx;deleteList(L,idx,num);cout << "操作成功！" << endl << "被删除的元素是：" << num << endl; }}void test5(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{destroy(L);cout << "线性表已被销毁" << endl;}}void test6(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{clear(L);cout << "线性表已被清空" << endl;}}void test7(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else cout << "线性表的长度现在是：" << length(L) << endl;}void test8(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else if(empty(L))cout << "线性表现在为空" << endl;else cout << "线性表现在非空" << endl;}void test9(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{ElemType num;cout << "请输入待判定的元素:" << endl;cin >> num;cout << "第一个与目标元素满足大小关系的元素的位置：" << locateElem(L,num) << endl;}}void test10(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{ElemType num,num2[initSize / 2];cout << "请输入参照元素:" << endl;cin >> num;int len = priorElem(L,num,num2);cout << num << "的前驱为：" << endl;for(int i = 0;i < len;i++)cout << num2[i] << " ";cout << endl;}}void test11(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{ElemType num,num2[initSize / 2];cout << "请输入参照元素:" << endl;cin >> num;int len = nextElem(L,num,num2);cout << num << "的后继为：" << endl;for(int i = 0;i < len;i++)cout << num2[i] << " ";cout << endl;}}void test12(List list){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{cout << "输出线性表所有元素:" << endl;listTraverse(list);}}void test13(){if(L.listsize == 0)cout << "初始线性表不存在!" << endl; else{List L2,L3;cout << "初始化一个新线性表" << endl;test1(L2);test2(L2);cout << "归并两个线性表" << endl;merge(L,L2,L3);cout << "归并成功!" << endl;cout << "输出合并后的线性表" << endl;listTraverse(L3);}}void test14(){partion(&L);cout << "奇偶数分区成功!" << endl;}int main(){std::ios::sync_with_stdio(false);cin.tie(0),cout.tie(0);int op = 0;while(op != 15){cout << "-----------------menu--------------------" << endl;cout << "--------------1：初始化------------------" << endl;cout << "--------------2：插入元素----------------" << endl;cout << "--------------3：查询元素----------------" << endl;cout << "--------------4：删除元素----------------" << endl;cout << "--------------5：销毁线性表--------------" << endl;cout << "--------------6：清空线性表--------------" << endl;cout << "--------------7：线性表长度--------------" << endl;cout << "--------------8：线性表是否为空----------" << endl;cout << "--------------9：定位满足大小关系的元素--" << endl;cout << "--------------10：查询前驱---------------" << endl;cout << "--------------11：查询后继---------------" << endl;cout << "--------------12：输出线性表-------------" << endl;cout << "--------------13：归并线性表-------------" << endl;cout << "--------------14：奇偶分区---------------" << endl;cout << "--------------15: 退出测试程序-----------" << endl;cout << "请输入指令编号:" << endl; if(!(cin >> op)){cin.clear();cin.ignore(INT_MAX,'\n');cout << "请输入整数!" << endl;continue;}switch(op){case 1:test1(L);break;case 2:test2(L);break;case 3:test3();break;case 4:test4();break;case 5:test5();break;case 6:test6();break;case 7:test7();break;case 8:test8();break;case 9:test9();break;case 10:test10();break;case 11:test11();break;case 12:test12(L);break;case 13:test13();break;case 14:test14();break;case 15:cout << "测试结束！" << endl;default:cout << "请输入正确的指令编号！" << endl;}}return 0;}六、实验数据及处理结果1.初始化:2.插入元素3.查询元素（返回的是数组下标，下标从0开始）4.删除元素（位置从1开始）5.销毁顺序表6.清空顺序表7.顺序表长度（销毁或清空操作前）8.判空（销毁或清空操作前）9.定位满足大小关系的元素（销毁或清空操作前）说明：这里默认找第一个小于目标元素的位置且下标从0开始，当前顺序表的数据为:1 4 2 510.前驱（销毁或清空操作前）11.后继（销毁或清空操作前）12.输出顺序表（销毁或清空操作前）13.归并顺序表（销毁或清空操作前）七、思考讨论题或体会或对改进实验的建议通过本次实验，我掌握了定义线性表的顺序存储类型，加深了对顺序存储结构的理解，进一步巩固和理解了顺序表的基本操作，如建立、查找、插入和删除等。
codeblock数据结构算法实现-顺序表基本操作
数据结构算法实现-顺序表基本操作序号一、引言二、顺序表的定义三、顺序表的基本操作1.初始化操作2.插入操作3.删除操作4.查找操作四、顺序表的实现五、总结一、引言数据结构是计算机科学中非常重要的一部分，它是计算机存储、组织数据的方式。
而顺序表是其中的一种基本数据结构，它采用一组位置区域连续的存储单元依次存放线性表中的元素。
本文将着重介绍顺序表的基本操作及其算法实现。
二、顺序表的定义顺序表是一种基本的线性表，顺序表中元素的逻辑顺序和物理顺序是一致的。
顺序表的特点是利用一组连续的存储单元依次存放线性表中的元素。
顺序表可以用数组实现，其元素在内存中是连续存储的，可以通过下标直接访问元素。
由于顺序表的存储方式，使得其在查找、插入和删除等操作上具有较好的性能。
三、顺序表的基本操作顺序表的基本操作包括初始化、插入、删除和查找等。
下面分别介绍这些操作的实现方法。
1.初始化操作初始化操作是指将一个空的顺序表初始化为一个具有初始容量的顺序表，并为其分配内存空间。
初始化操作的实现方法主要有两种，一种是静态分配内存空间，另一种是动态分配内存空间。
静态分配内存空间时，需要预先指定顺序表的容量大小，然后在程序中创建一个数组，并为其分配指定大小的内存空间。
动态分配内存空间时，可以根据需要动态创建一个数组，并为其分配内存空间。
下面是一个简单的初始化操作的实现示例：```C代码#define MAXSIZE 100 // 定义顺序表的最大容量typedef struct {ElementType data[MAXSIZE]; // 定义顺序表的元素数组int length; // 定义顺序表的当前长度} SeqList;2.插入操作插入操作是指将一个新元素插入到顺序表的指定位置。
插入操作的实现方法主要包括在指定位置插入元素，同时对其他元素进行后移操作。
下面是一个简单的插入操作的实现示例：```C代码Status Insert(SeqList *L, int i, ElementType e) {if (i < 1 || i > L->length + 1) { // 判断插入位置是否合法return ERROR;}if (L->length >= MAXSIZE) { // 判断顺序表是否已满return ERROR;}for (int j = L->length; j >= i; j--) { // 插入位置及之后的元素后移L->data[j] = L->data[j - 1];}L->data[i - 1] = e; // 插入新元素L->length++; // 顺序表长度加1return OK;}```3.删除操作删除操作是指将顺序表中指定位置的元素删除。
数据结构实验报告-实验：1线性表的顺序存储和操作实现
}
for(inti=pos-1;i<length;i++)
if(listArray[i].equals(obj))returni+1;
return-1;
}
publicbooleanmodify(Object obj,intpos){
if(pos<1||pos>length){
List sort();
}
publicclasssequenceListimplementsList {
finalintmaxSize=10;
privateintlength;
privateObject[]listArray;
publicsequenceList(){//无参数的构造函数的定义
length=0;//线性表初始为空，即长度为0
System.out.println();
list2.preOrder();
System.out.println("线性表list2长度："+list2.size());
}
}
publicinterfaceList {
Object value(intpos);
booபைடு நூலகம்eanadd(Object obj,intpos);
int[] a={20,16,38,42,29};
for(inti=0;i<a.length;i++) list1.add(a[i], i+1);
intn1=(Integer)list1.remove(2);
list1.add(80, 3);
intn2=(Integer)list1.value(4);
实验1顺序表和链表基本操作(学生)
实验一线性表运算的实现班级学号姓名一、实验预备知识1．复习C中函数的相关内容。
2．复习如何用主函数将多个函数连在一起构成一个C完整程序。
3．复习多文件结构。
二、实验目的1．掌握线性表的顺序和链式存储结构2．熟练运用线性表在顺序存储方式下的初始化、创建、输出、插入和删除运算3．熟练运用线性表在链式存储方式下的创建、输出、插入和删除运算三、实验要求1．编写初始化并创建线性表和输出线性表的算法。
2．编写对线性表插入和删除运算算法，要判断位置的合法性和溢出问题。
3．编写有序表的插入和删除运算算法。
4．编写一个主函数，将上面函数连在一起，构成一个完整的程序。
5．将实验源程序调试并运行，写出输入、输出结果，并对结果进行分析。
四、实验内容顺序表实验内容：1．给定的线性表为L=（12，25，7，42，19，38），元素由键盘输入。
2．初始化并建立顺序表。
（开辟的存储空间大小为8）3．编写顺序表输出算法。
4．依次插入3，21，15三个数，分别插入在第4，6和2位置，每插入一次都要输出一次顺序表。
5．删除第5，第3和第12个位置上的元素，每删除一个元素都要输出一次顺序表。
6．编写一个排序算法，对线性表中元素从小到大排列。
7．向有序表分别插入20和50，插入后表仍然有序。
（修改开辟的存储空间大小为15）单链表实验内容：1．给定的线性表为L=（12，25，7，42，19，38），元素由键盘输入。
2．建立一个带表头结点的单链表（前插入法和尾插入法都可以）。
3．编写单链表输出算法。
4．依次插入3，21，15三个数，分别插入在第4，6和12位置，每插入一次都要输出一次单链表。
5．删除第5，第3和第12个位置上的元素，每删除一个元素都要输出一次单链表。
6．编写一个排序算法，对线性表中元素从小到大排列。
7．分别删除值为25和42的元素，删除后表仍然有序。
五、实验结果给出程序清单及输入/输出结果六、总结1．实验过程中遇到的问题及解决方法2．收获北华航天工业学院《数据结构》课程实验报告实验题目：作者所在系部：作者所在专业：作者所在班级：作者学号：作者姓名：任课教师姓名：完成时间：北华航天工业学院教务处制一、实验目的1 掌握线性表的顺序和链式存储结构；2 熟练运用线性表在顺序存储方式下的初始化、创建、输出、插入和删除运算；3 熟练运用线性表在链式存储方式下的创建、输出、插入和删除运算。
建立一个顺序表,表中元素为学生,每个学生信息包含姓名、学号和成绩三部分,对该表实现输出、插入、删除、
云南大学物理实验教学中心实验报告课程名称：计算机软件技术基础实验项目：实验二、线性表（顺序存储）及其应用学生姓名：学号：学院系级专业成绩指导教师：实验时间：年日时分至时分实验地点：实验类型：教学（演示□验证□综合█设计□）学生科研□课外开放□测试□其它□一、实验目的：掌握顺序表的建立及基本操作。
二、问题：建立一个顺序表，表中元素为学生，每个学生信息包含姓名、学号和成绩三部分，对该表实现：①输出、②插入、③删除、④查找功能，并计算出平均成绩和总成绩。
三、程序的编写与调试1、原程序：#include <iostream>using namespace std;typedef struct{ long double num; char name[10]; int score; } STUDENT; class sq_LList{ private:int mm;int nn;STUDENT *v;public:sq_LList(int);void prt_sq_LList();void ins_sq_LList(int, STUDENT);void del_sq_LList(int);void sea_num_sq_LList(int);voidvoid cal_sq_LList(int);};/*输出*/sq_LList ::sq_LList(int m){ mm=m;v=new STUDENT [mm];v[0].num=970156; strcpy(v[0].name,"张小明"); v[0].score=87; v[1].num=970157; strcpy(v[1].name,"李小青"); v[1].score=96;v[2].num=970158; strcpy(v[2].name,"刘华");v[2].score=85; v[3].num=970159; strcpy(v[3].name,"王伟");v[3].score=93; v[4].num=970160; strcpy(v[4].name,"李启明"); v[4].score=88;nn=5;}void sq_LList ::prt_sq_LList(){ int i;for(i=0; i<nn; i++){ cout<<"学号: "<<v[i].num<<" 姓名: "<<v[i].name<<" "<<"分数: "<<v[i].score<<endl;}}/*插入*/void sq_LList ::ins_sq_LList(int i, STUDENT b){ int k;if(nn==mm){cout<<"overflow"; return ;}if(i>nn) i=nn+1;if(i<1) i=1;for(k=nn; k>=i; k--)v[k]=v[k-1];v[i-1]=b; nn=nn+1;}/*删除*/void sq_LList ::del_sq_LList(int i){ int k;if(nn==0){cout<<"underflow"<<endl; return ;}if((i<1)||(i>nn)){cout<<"Not this element in the list!"<<endl; return ;}for(k=i; k<nn; k++)v[k-1]=v[k];nn=nn-1;}/*按学号查找*/void sq_LList ::sea_num_sq_LList(int i){ int k,t ;＿＿＿＿t=0;for(i=0;i<nn;i++){ if(v[i].num==k){ t=t+1;cout<<"学号: "<<v[i].num<<" 姓名: "<<v[i].name<<" "<<"分数: "<<v[i].score<<endl;}}if(t==0)cout<<"No this student in the list!"<<endl;}/*按姓名查找*/void sq_LList ::sea_name_sq_LList(int i, char y[]){ int t;＿＿＿＿t=0;for(i=0;i<nn;i++){ if(strcmp(y,v[i].name)=0){t=t+1cout<<"学号: "<<v[i].num<<" 姓名: "<<v[i].name<<" "<<"分数: "<<v[i].score<<endl;}}if(t==0) cout<<"No this student in the list!"<<endl }/*计算*/void sq_LList ::cal_sq_LList(int m){ int i;float sum,avr;{ sum=0;for(i=0;i<nn;i++){sum=sum+v[i].score;avr=sum/(i+1);}}cout<<"总分："<<sum<<endl；cout<<"平均分："<<avr<<endl;}int main(){ int mx; sq_LList s1(100);while (1){ cout<<"1.输出 2.插入 3.删除 4.查找 5.计算 0.退出\n";cout<<"输入0-5:";cin>>mx;switch(mx){ case 1: s1.prt_sq_LList(); break;case 2: int i; STUDENT b;cout<<"输入插入点位置和插入元素值：";cin>>i>>b.num>>>>b.score;s1.ins_sq_LList(i,b); s1.prt_sq_LList(); break; case 3: cout<<"请输入删除学生的位置：";cin>>i;s1.del_sq_LList(i);s1.prt_sq_LList(); break; case 4: int main(){ int mx;while (1){cout<<"1.按学号查找 2.按姓名查找 0.返"<<endl;cout<<"输入0-2：";cin>>mx;switch (mx){casecout<<"请输入要查找学生的学号:";s1.sea_num_sq_LList(i); break;casecout<<"请输入要查找学生的姓名:";s1.sea_name_sq_LList(); break;case 0: cout<<"返回"<<endl; return ;}}return 0;} break;case 5: s1.cal_sq_LList(); break;case 0: cout<<"程序结束"<<endl; return 0;}}return 0;2、正确程序：#include <iostream>using namespace std;typedef struct{ long double num; char name[10]; int score; } STUDENT; class sq_LList{ private:int mm;int nn;STUDENT *v;public:sq_LList(int);void prt_sq_LList();void ins_sq_LList(int, STUDENT);void del_sq_LList(int);void sea_num_sq_LList(int);void sea_name_sq_LList();void cal_sq_LList(int);/*输出*/sq_LList ::sq_LList(int m){ mm=m;v=new STUDENT [mm];v[0].num=970156; strcpy(v[0].name,"张小明"); v[0].score=87; v[1].num=970157; strcpy(v[1].name,"李小青"); v[1].score=96;v[2].num=970158; strcpy(v[2].name,"刘华");v[2].score=85; v[3].num=970159; strcpy(v[3].name,"王伟");v[3].score=93; v[4].num=970160; strcpy(v[4].name,"李启明"); v[4].score=88;nn=5;}void sq_LList ::prt_sq_LList(){ int i;for(i=0; i<nn; i++){ cout<<"学号: "<<v[i].num<<" 姓名: "<<v[i].name<<" "<<"分数: "<<v[i].score<<endl;}}/*插入*/void sq_LList ::ins_sq_LList(int i, STUDENT b){ int k;if(nn==mm){cout<<"overflow"; return ;}if(i>nn) i=nn+1;if(i<1) i=1;for(k=nn; k>=i; k--)v[k]=v[k-1];v[i-1]=b; nn=nn+1;}/*删除*/void sq_LList ::del_sq_LList(int i){ int k;if(nn==0){cout<<"underflow"<<endl; return ;}if((i<1)||(i>nn)){cout<<"Not this element in the list!"<<endl; return ;}for(k=i; k<nn; k++)v[k-1]=v[k];nn=nn-1;}/*按学号查找*/void sq_LList ::sea_num_sq_LList(int i){ int k,t ;cin>>k;t=0;for(i=0;i<nn;i++){ if(v[i].num==k){ t=t+1;cout<<"学号: "<<v[i].num<<" 姓名: "<<v[i].name<<" "<<"分数: "<<v[i].score<<endl;}}if(t==0)cout<<"No this student in the list!"<<endl;}/*按姓名查找*/void sq_LList ::sea_name_sq_LList(){ char y[10]; int i,t;cin>>y;t=0;for(i=0;i<nn;i++){ if(strcmp(y,v[i].name)==0){t=t+1;cout<<"学号: "<<v[i].num<<" 姓名: "<<v[i].name<<" "<<"分数: "<<v[i].score<<endl;}}if(t==0) cout<<"No this student in the list!"<<endl; }/*计算*/void sq_LList ::cal_sq_LList(int m){ int i;float sum,avr;{ sum=0;for(i=0;i<nn;i++){sum=sum+v[i].score;avr=sum/(i+1);}}cout<<"总分："<<sum<<endl;cout<<"平均分："<<avr<<endl;}int main(){ int mx; sq_LList s1(100);while (1){ cout<<"1.输出 2.插入 3.删除 4.查找 5.计算 0.退出\n";cout<<"输入0-5:";cin>>mx;switch(mx){ case 1: s1.prt_sq_LList(); break;case 2: int i; STUDENT b;cout<<"输入插入点位置和插入元素值：";cin>>i>>b.num>>>>b.score;s1.ins_sq_LList(i,b); s1.prt_sq_LList(); break; case 3: cout<<"请输入删除学生的位置：";cin>>i;s1.del_sq_LList(i);s1.prt_sq_LList(); break; case 4:{ int mx;while (1){cout<<"1.按学号查找 2.按姓名查找 0.返"<<endl;cout<<"输入0-2：";cin>>mx;switch (mx){case 1: cout<<"请输入要查找学生的学号:";s1.sea_num_sq_LList(i); break;case 2: cout<<"请输入要查找学生的姓名:";s1.sea_name_sq_LList(); break;case 0: cout<<"返回"<<endl; return 0;}}return 0;} break;case 5: s1.cal_sq_LList(i); break;case 0: cout<<"程序结束"<<endl; return 0;}}return 0;}四、实验总结通过此次试验，我对线性表（顺序存储）有了全面的认识，知道了什么是线性表，以及线性表有什么作用；并学会了如何根据要求建立一个实际的线性表，包括线性表的输出、插入、删除、查。
数据结构线性表实验报告
数据结构线性表实验报告数据结构线性表实验报告实验目的：本次实验主要是为了学习和掌握线性表的基本操作和实现方式。
通过实验，我们可以加深对线性表的理解，并能够熟悉线性表的基本操作。
实验设备与环境：本次实验所需的设备包括计算机和编程环境。
我们选择使用C语言来实现线性表的操作，并在Visual Studio Code编程软件中进行编写和调试。
实验内容：1.线性表的定义和基本操作1.1 线性表的定义：线性表是一种有序的数据结构，其中的元素按照一定的顺序存储，可以插入、删除和访问元素。
1.2 线性表的基本操作：1.2.1 初始化线性表：创建一个空的线性表。
1.2.2 判断线性表是否为空：判断线性表是否不含有任何元素。
1.2.3 获取线性表的长度：返回线性表中元素的个数。
1.2.4 在线性表的指定位置插入元素：在线性表的第i个位置插入元素x，原第i个及其之后的元素依次后移。
1.2.5 删除线性表中指定位置的元素：删除线性表中第i个位置的元素，原第i+1个及其之后的元素依次前移。
1.2.6 获取线性表中指定位置的元素：返回线性表中第i个位置的元素的值。
1.2.7 清空线性表：将线性表中的元素全部删除，使其变为空表。
2.线性表的顺序存储结构实现2.1 线性表的顺序存储结构：使用数组来实现线性表的存储方式。
2.2 线性表的顺序存储结构的基本操作：2.2.1 初始化线性表：创建一个指定长度的数组，并将数组中的每个元素初始化为空值。
2.2.2 判断线性表是否为空：判断线性表的长度是否为0。
2.2.3 获取线性表的长度：返回线性表数组的长度。
2.2.4 在线性表的指定位置插入元素：将要插入的元素放入指定位置，并将原位置及其之后的元素依次后移。
2.2.5 删除线性表中指定位置的元素：将指定位置的元素删除，并将原位置之后的元素依次前移。
2.2.6 获取线性表中指定位置的元素：返回指定位置的元素的值。
2.2.7 清空线性表：将线性表数组中的每个元素赋空值。
线性表的插入和删除C++程序
修改内容：重新排版《数据结构》试验报告-------------线性表的插入和删除康一飞地理信息系统08-208014208一，实验目的掌握线性表的顺序存储结构的定义及C语言实现插入，删除操作掌握线性表的链式存储结构的定义及C语言实现插入，删除操作二，实验内容1定义数据元素之间的关系在计算机中又两种不同的表示方式：顺序映像和非顺序映像，由此得到两种不同的存储结构：顺序存储结构和链式存储结构。
顺序映像的特点是借助元素在存储器中的相对位置来表示数据元素之间的逻辑关系非顺序映像的特点是借助指针元素存储地址的指针表示数据元素之间的逻辑关系2顺序表的插入#include<stdio.h>#include<malloc.h>typedef struct{int elem;int length;int listsize;}SqList,* SqL;SqL CreateList_S(){int n;SqList *p,*S;S=(SqL) malloc (sizeof(SqList));S->listsize=100;printf("input the length of the list:");scanf("%d",&(S->length));printf("input the element of the list:");for(n=1,p=S;n<=(S->length);n++,p+=sizeof(SqList)) scanf("%d",&p->elem);return(S);}SqL ListInsert_S(SqL S){int e,i,m,n;loop: printf("input the place you want to insert:");scanf("%d",&i);if(i<1||i>S->length+1){printf("ERROR input again\n");goto loop;}printf("iuput the element you want to insert:");scanf("%d",&e);m=S->length;for(n=i;n<=S->length;n++){(S+m*sizeof(SqList))->elem=(S+(m-1)*sizeof(SqList))->elem;m=m-1;}(S+(i-1)*sizeof(SqList))->elem=e;S->length++;return(S);}void main(){SqList *Sa,*p;int n,i,e;Sa=CreateList_S();printf("the list is:");for(n=1,p=Sa;n<=(Sa->length);n++,p+=sizeof(SqList))prin tf("%d ",p->elem);printf("\n\n");Sa= ListInsert_S(Sa);printf("the list is:");for(n=1,p=Sa;n<=(Sa->length);n++,p+=sizeof(SqList))prin tf("%d ",p->elem);printf("\n");}3单链表的删除#include<stdio.h>#include<malloc.h>#define NULL 0typedef struct LNode{int data;struct LNode *next;}LNode,*LiL;LiL CreatList_L(){int i,n;LNode *p,*L;L=(LiL)malloc(sizeof(LNode));L->next=NULL;printf("please input the length of the list:");scanf("%d",&n);printf("input the element of the list:");for(i=0;i<n;i++){p=(LiL)malloc(sizeof(LNode));scanf("%d",&p->data);p->next=L->next,L->next=p;}return(L);}LiL ListDelete_L(LiL L){LNode *p;int j,e,i;loop:printf("input the place you want to delited:");scanf("%d",&i);for(j=0, p=L;j<i-1&&p->next!=NULL;j++) p=p->next;if(p->next==NULL){printf("ERROR input again\n");goto loop;}e=p->next->data;p->next=p->next->next;printf("the element you want to delited is:%d\n",e);return(L);}void main(){LNode *La,*p;int n,i,e;La=CreatList_L();printf("the list is:");for(p=La->next;p!=NULL;p=p->next)printf("%d ",p->data);printf("\n\n");La= ListDelete_L(La);printf("the list is:");for(p=La->next;p!=NULL;p=p->next)printf("%d ",p->data);printf("\n");}三、实验体会1，由于《数据结构》课本上给出的示例函数并不是完全由C语言写出，包含了一些伪代码，所以不可以直接拿来使用，一定要结合具体的程序设计实际例题用严格的C语言编写出才能通过编译2. 程序中用了大量的指针，在定义和使用它时要分清楚哪些是代表指针，哪些是代表指针所指向的地址，以及哪些是其他的类型，我在编程中就因为没有把握好这几种类型，耗费了许多时间来检查错误3. 在调用和创建函数时，注意函数使用的各种规则，注意函数类型和返回值，参见C语言课本4. 编写两个程序时，要注意两种存储结构的线性表的不同，不要把二者的一些东西混淆5 一些小细节，比如：单链表输出时令p=La->next,而不是p=La；以及程序中作为计数器使用的一些int型变量的起始值，可能以为一个数的差别导致程序运行错误，要反复检查实验才能得到正确结果6 由于能力有限，除了“插入/删除位置有误”外，没有对其他复杂情况分析，值编写了简单的数字线性表的操作康一飞地理信息系统08-2班 08014208。
顺序表类型定义
顺序表类型定义顺序表（SequenceList）是一种基础数据结构，可以容纳一组元素，它们可以按照一定的顺序排列。
顺序表的特性是元素的插入、删除、查询、更新等操作比较方便，存储空间利用率也相当高，但是插入和删除操作有可能会改变所有元素的位置，另外建立该类型所需要的内存较大，因此内存空间是一个限制。
顺序表的类型定义顺序表是用一组连续的存储单元存放一组数据的一种线性表，它的特点是插入和删除元素的操作相对较简单，查找元素的效率也较高，但是存储空间的利用率较低。
顺序表的类型定义应该包括其结构、实现、操作和应用四个方面。
顺序表的结构是指存储该表中元素的最基本单元，它是线性表中最基本的概念，通常由一组连续的存储单元组成；实现是指建立顺序表所必须实现的步骤；操作是指在顺序表中插入、删除、查找和更新等基本操作；应用是指顺序表可以应用于各种不同的场景，使用它可以解决很多实际问题。
顺序表的应用顺序表在实际应用中有很多优点，它可以为程序设计带来十分可靠和高效的存储结构，广泛应用于计算机科学和工程领域。
顺序表可以用于实现经典的排序算法，比如冒泡排序、快速排序和插入排序等。
此外，还可以使用顺序表实现一些数据结构中的基本操作，比如栈、队列、链表、图、哈希表等。
在数据库管理系统中，也会使用顺序表，比如把磁盘的数据取出来放到内存中，或者分析大量数据的统计信息时，都可以采用顺序表。
顺序表的缺点顺序表的缺点主要有：首先，它的空间效率较低，因为当插入和删除元素时，就会发生数据搬移；其次，它所需要的内存较多，特别是当表中元素多于预设范围时，就会出现内存溢出的情况；最后，它的查询效率较低，因为要想得到某一特定元素，就必须要从头开始遍历，直到找到或者没有找到为止。
总结顺序表是一种基础数据结构，它是由一组连续的存储单元组成的线性表，它的特点是插入和删除元素的操作相对较简单，查找元素的效率也较高，但是存储空间的利用率较低。
它可以在实际程序设计中、实现经典的排序算法以及实现一些数据结构相关操作等场景中使用，但同时也存在一些缺点，比如空间效率较低、查询效率较低等。
数据结构 顺序表基本运算实现
; //依次打印输出顺序表中的元素
printf("\n");
}
//查找
locate(SeqList *list, int e)
{
int i;
printf("插入元素,请输入需要插入的位置:\n");
scanf("%d",&i);
insert(list,i,e);
printList(list);
break;
3．编写一个完整的程序实现顺序表的下列基本操作：
(1) 新建一个顺序表。。
(2) 打印输出顺序表中的元素。
(3) 在顺序表中查找某个元素。
(4) 在顺序表中指定位置插入元素。
(5) 在顺序表中删除指定位置的元素。
(6) 删除顺序表La中的某一元素。
编写一个主菜单，调用以上基本操作。
参考程序代码如下，请将其补充完整，并上机调试运行。
//顺序表的建立、查找、插入与删除，表元素为数字
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#define MAX 100 //表最大长度
//选择顺序表操作动作
printf("请输入操作对应的数字进行顺序表的操作：\n");
printf("————查询(1)\n);
printf("————插入(2)\n);
printf("————删除(3)\n);
printf("————退出(0)\n);
顺序表的初始化及基本操作Word版
顺序表的初始化及基本操作Word版顺序表是一种线性表的存储结构，它是一种物理上连续的存储空间用于存储相同数据类型的元素。
顺序表的基本操作包括初始化、插入、删除、查找和修改等。
顺序表的应用广泛，常用于各种数据结构和算法的实现中顺序表的初始化顺序表的初始化是指创建一个空的顺序表，为其分配存储空间并进行初始化。
初始化顺序表的步骤包括定义表的存储空间、设置表的长度为0，即表中无元素二、顺序表的插入顺序表的插入是指在表中的指定位置上插入一个元素。
插入操作需要将插入位置之后的元素依次后移，为插入元素腾出空间。
插入操作有两种情况:在表的末尾插入元素和在表的中间插入元素。
三、顺序表的删除顺序表的删除是指删除表中指定位置上的元素。
删除操作需要将删除位置之后的元素依次前移，覆盖被删除的元素。
删除操作有两种情况:删除表的末尾元素和删除表的中间元素四、顺序表的查找顺序表的查找是指在表中查找指定元素的位置。
查找操作可以按照元素值进行查找，也可以按照元素位置进行查找。
顺序表的查找操，作可以采用顺序查找和二分查找等算法五、顺序表的修改顺序表的修改是指修改表中指定位置上的元素的值。
修改操作可以直接修改元素的值，也可以通过删除和插入操作实现。
顺序表的应用:1.顺序表可以用于实现栈和队列等数据结构。
栈是一种先进后出的数据结构，可以使用顺序表的插入和删除操作实现。
队列是一种先进先出的数据结构，可以使用顺序表的插入和删除操作实现2.顺序表可以用于实现线性表，如数组和矩阵等。
数组是一种具有相同数据类型的元素按照一定顺序排列的数据结构，可以使用顺序表的插入、删除、查找和修改操作实现。
矩阵是一种二维数组，可以使用顺序表的插入、删除、查找和修改操作实现。
3.顺序表可以用于实现排序和查找算法。
排序算法可以使用顺序表的插入和删除操作实现，如插入排序和冒泡排序等。
查找算法可以使用顺序表的查找操作实现，如顺序查找和二分查找等4.顺序表可以用于存储和处理大量的数据，如学生信息管理系统和图书馆管理系统等。
国开数据结构(本)数据结构课程实验报告
国开数据结构(本)数据结构课程实验报告1. 实验目的本次实验的主要目的是通过实际操作，掌握数据结构的基本概念、操作和应用。
通过对实验内容的了解和实际操作，达到对数据结构相关知识的深入理解和掌握。
2. 实验工具与环境本次实验主要使用C++语言进行编程，需要搭建相应的开发环境。
实验所需的工具和环境包括：C++编译器、集成开发环境(IDE)等。
3. 实验内容本次实验主要包括以下内容：3.1. 实现顺序存储结构的线性表3.2. 实现链式存储结构的线性表3.3. 实现栈和队列的顺序存储结构和链式存储结构3.4. 实现二叉树的顺序存储结构和链式存储结构3.5. 实现图的邻接矩阵和邻接表表示4. 实验步骤实验进行的具体步骤如下：4.1. 实现顺序存储结构的线性表- 定义数据结构- 实现插入、删除、查找等操作4.2. 实现链式存储结构的线性表- 定义数据结构- 实现插入、删除、查找等操作4.3. 实现栈和队列的顺序存储结构和链式存储结构- 定义数据结构- 实现入栈、出栈、入队、出队操作4.4. 实现二叉树的顺序存储结构和链式存储结构- 定义数据结构- 实现插入、删除、查找等操作4.5. 实现图的邻接矩阵和邻接表表示- 定义数据结构- 实现插入、删除、查找等操作5. 实验结果与分析通过对以上实验内容的实现和操作，得到了以下实验结果与分析： 5.1. 顺序存储结构的线性表- 实现了线性表的插入、删除、查找等操作- 通过实验数据进行性能分析，得出了相应的性能指标5.2. 链式存储结构的线性表- 实现了线性表的插入、删除、查找等操作- 通过实验数据进行性能分析，得出了相应的性能指标5.3. 栈和队列的顺序存储结构和链式存储结构- 实现了栈和队列的入栈、出栈、入队、出队操作- 通过实验数据进行性能分析，得出了相应的性能指标5.4. 二叉树的顺序存储结构和链式存储结构- 实现了二叉树的插入、删除、查找等操作- 通过实验数据进行性能分析，得出了相应的性能指标5.5. 图的邻接矩阵和邻接表表示- 实现了图的插入、删除、查找等操作- 通过实验数据进行性能分析，得出了相应的性能指标6. 总结与展望通过本次数据结构课程的实验，我们深入了解并掌握了数据结构的基本概念、操作和应用。
线性表的插入与删除实验报告
void main()
{
clock_t start,finish;
int a[1000],out[N],i,j,k;
for(i=0;i<1000;i++)
a[i]=-1;
double duration;
start=clock();
ifstream infile("integer.dat");
for(k=0;a[k]!=-1;k++)
{
cout<<a[k]<<'\t';
}
}
finish=clock();
duration=(double)(finish-start)/CLOCKS_PER_SEC;
cout<<endl<<"所用时间"<<duration<<"秒"<<endl;
}
（3）、
#include<iostream.h>
其中mod（*）是模运算，INT（*）是取整函数。
2、线性表的插入与删除：
在本实验中线性表是动态增长的。插入一个新元素后，为了使线性表仍保持有序，必须要找到新元素应插入的位置。实际上这是一个插入排序的问题。为了要将新元素插入到一个有序的线性表中，可以从原有序表的最后一个元素开始，往前逐个与新元素比较，并将大于新元素的所有元素都往后移动一个位置，直到找到新元素应插入的位置为止。显然，插入一个新元素后，表的长度也增加了1。现假设用一个数组L(1:m)来存储线性表，其中m为最大容量（在本实验中为m=1000）；用一个变量n表示线性表的长度（在本实验中，其初值为n=0）。则可以得到将新元素插入到有序线性表的算法如下。
数据结构-顺序表的基本操作的实现-课程设计-实验报告
数据结构-顺序表的基本操作的实现-课程设计-实验报告顺序表的基本操作的实现一、实验目的1、掌握使用VC++上机调试顺序表的基本方法；2、掌握顺序表的基本操作：建立、插入、删除等运算。
二、实验仪器安装VC++软件的计算机。
三、实验原理利用线性表的特性以及顺序存储结构特点对线性表进行相关的基本操作四、实验内容程序中演示了顺序表的创建、插入和删除。
程序如下：#include#include/*顺序表的定义：*/#define ListSize 100typedef struct{ int data[ListSize]; /*向量data用于存放表结点*/i nt length; /*当前的表长度*/}SeqList;void main(){ void CreateList(SeqList *L,int n);v oid PrintList(SeqList *L,int n);i nt LocateList(SeqList *L,int x);v oid InsertList(SeqList *L,int x,int i);v oid DeleteList(SeqList *L,int i);SeqList L;i nt i,x;i nt n=10;L.length=0;c lrscr();C reateList(&L,n); /*建立顺序表*/P rintList(&L,n); /*打印建立后的顺序表*/p rintf("INPUT THE RESEARCH ELEMENT");s canf("%d",&x);i=LocateList(&L,x);p rintf("the research position is %d\n",i); /*顺序表查找*/ p rintf("input the position of insert:\n");s canf("%d",&i);p rintf("input the value of insert\n");s canf("%d",&x);I nsertList(&L,x,i); /*顺序表插入*/P rintList(&L,n); /*打印插入后的顺序表*/p rintf("input the position of delete\n");s canf("%d",&i);D eleteList(&L,i); /*顺序表删除*/P rintList(&L,n); /*打印删除后的顺序表*/g etchar();}/*顺序表的建立：*/void CreateList(SeqList *L,int n){int i;printf("please input n numbers\n");for(i=1;i<=n;i++)scanf("%d",&L->data[i]);L->length=n;}/*顺序表的打印：*/void PrintList(SeqList *L,int n){int i;printf("the sqlist is\n");for(i=1;i<=n;i++)printf("%d ",L->data[i]);}/*顺序表的查找：*/int LocateList(SeqList *L,int x){int i;for(i=1;i<=10;i++)if((L->data[i])==x) return(i);else return(0);}/*顺序表的插入：*/void InsertList(SeqList *L,int x,int i){int j;for(j=L->length;j>=i;j--)L->data[j+1]=L->data[j];L->data[i]=x;L->length++;}void DeleteList(SeqList *L,int i) /*顺序表的删除：*/ { int j;for(j=i;j<=(L->length)-1;j++)L->data[j]=L->data[j+1];}五、实验步骤1、认真阅读和掌握本实验的程序。
顺序表的操作实验报告
顺序表的操作实验报告一、实验目的。
1. 了解顺序表的基本概念和操作方法；2. 掌握顺序表的插入、删除、查找等操作；3. 熟悉顺序表的存储结构和实现方式。
二、实验内容。
1. 实现顺序表的基本操作，包括插入、删除、查找等；2. 对比顺序表和链表的优缺点；3. 分析顺序表的存储结构和实现方式。
三、实验原理。
顺序表是一种线性表的存储结构，它的特点是元素之间的逻辑顺序和物理顺序一致，即在内存中连续存储。
顺序表的基本操作包括插入、删除、查找等。
1. 插入操作，在顺序表的某个位置插入一个元素，需要将插入位置后的所有元素向后移动一个位置，然后将新元素插入到指定位置。
2. 删除操作，删除顺序表中的某个元素，需要将删除位置后的所有元素向前移动一个位置，然后将最后一个元素删除。
3. 查找操作，在顺序表中查找某个元素，需要遍历整个顺序表，逐个比较元素的值，直到找到目标元素或者遍历完整个表。
四、实验步骤。
1. 实现顺序表的基本操作，包括插入、删除、查找等；2. 编写测试用例，验证顺序表的功能和正确性；3. 对比顺序表和链表的优缺点，分析其适用场景；4. 分析顺序表的存储结构和实现方式，总结其特点和应用场景。
五、实验结果与分析。
1. 实现了顺序表的基本操作，包括插入、删除、查找等，功能正常；2. 经过测试用例验证，顺序表的功能和正确性得到了验证；3. 对比顺序表和链表的优缺点，发现顺序表的插入、删除操作效率较低，但查找操作效率较高，适合静态查找；4. 分析顺序表的存储结构和实现方式，发现其适用于元素数量较少且频繁查找的场景。
六、实验总结。
通过本次实验，我们深入了解了顺序表的基本概念和操作方法，掌握了顺序表的插入、删除、查找等操作。
同时，我们对比了顺序表和链表的优缺点，分析了顺序表的存储结构和实现方式，加深了对顺序表的理解和应用。
在今后的学习和工作中，我们将根据实验结果的分析，合理选择顺序表或链表作为数据结构，以满足不同场景下的需求。
线性表的实现及操作(二)
typedef struct
{
DataType list[MaxSize];
int size;
} SeqList;
void ListInitiate(SeqList *L)/*初始化顺序表L*/
{
L->size = 0;/*定义初始数据元素个数*/
}
int ListLength(SeqList L)/*返回顺序表L的当前数据元素个数*/
ListDelete(&myList, 4, &x);
for(i = 0; i < ListLength(myList); i++)
{
ListGet(myList, i, &x);//此段程序有一处错误
printf("%d ", x);
}
}
测试结果：
线性表的实现及操作（二）
一、实验目的
了解和掌握线性表的链式存储结构；掌握用C语言上机调试线性表的基本方法；掌握线性表的基本操作：插入、删除、查找以及线性表合并等运算在顺序存储结构和链接存储结构上的运算，以及对相应算法的性能分析。
p = p->next;
free(p1);
}
*head = NULL;
}
void main(void)
{
SLNode *head;
int i , x;
ListInitiate(&head);/*初始化*/
for(i = 0; i < 10; i++)
{
if(ListInsert(head, i, i+1) == 0)/*插入10个数据元素*/
实验一数据结构顺序表的插入和删除
实验一顺序表的操作1.实验题目：顺序表的操作2.实验目的和要求：1）了解顺序表的基本概念、顺序表结构的定义及在顺序表上的基本操作(插入、删除、查找以及线性表合并)。
2) 通过在Turbo C（WinTc，或visual stdio6）实现以上操作的C语言代码。
3）提前了解实验相关的知识（尤其是C语言）。
3.实验内容：(二选一)1) 顺序表的插入算法,删除算法,顺序表的合并算法2) 与线性表应用相关的实例(自己选择具体实例)4.部分参考实验代码：⑴顺序表结构的定义：#include <stdio.h>#define MAXLEN 255typedef int ElemType;typedef struct{ ElemType elem[MAXLEN];int length;}sqList;⑵顺序表前插（在第i号元素前插入一个新的元素）int ListInsert(sqList *la,int i,int x){ int j;if(i<0||i>la-> length +1){ printf(“\n the value of i is wrong!”);return 0;}if(la-> length +1>=MAXLEN){ printf(“\n overflow!”);return 0;}. for(j=la-> length;j>=i;j--)la->list[j+1]=la->list[j];la->list[i]=x;la-> length ++;return 1;}⑶顺序表删除int ListDelete(sqList *la,int i){ if(i<0||i>la-> length){ printf(“\n the position is wrong!\n”);return 0;}for(i;i<la-> length;i++)la->list[i-1]=la->list[i];la-> length --;return 1;}5.附录：实验预备知识：⑴复习C语言中数组的用法。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
{
*(l.elem+i)=i;
if(i<10)
cout<<" "<<*(l.elem+i)<<" ";
else
cout<<*(l.elem+i)<<" ";}
l.length=i;
l.listsize=list_init_size;
cout<<endl;
*(p+1)=*p;
*q=e;
++l.length;
int j;
for(j=0;j<l.length;j++)
if(j<10)
{
cout<<" "<<*(l.elem+j)<<" ";
}
else
{
cout<<*(l.elem+j)<<" ";
}
cout<<endl;
return ok;
}
int listdelete_sq(sqlist &l,int n,elemtype;请输入要删除的位置";
cin>>n;
while(n<1||n>l.length)
{
cout<<"输出错误！请输入1到"<<l.length<<"之间的数"<<endl;
cin>>n;
}
p=&(l.elem[n-1]);
*f=*p;
cout<<"要删除的位置是"<<n<<endl;
cout<<"要删除的数据是"<<*f<<endl;
q=l.elem+l.length-1;
for(++p;p<=q;++p)
*(p-1)=*p;
--l.length;
int j;
for(j=0;j<l.length;j++)
{
if(j<10)
cout<<" "<<l.elem[j]<<" ";
else
cout<<l.elem[j]<<" ";
}
cout<<endl;
}
}
cout<<"插入位置为："<<m<<endl;
cout<<"请输入插入数据:";
cin>>e;
cout<<"插入数据为："<<e<<endl;
elemtype *newbase;
newbase=(elemtype*)realloc(l.elem,(l.listsize+listincrement)*sizeof(elemtype));
elemtype *q;
elemtype *p;
typedef struct{
elemtype *elem;
int length;
int listsize;
}sqlist;
int initlist_sq(sqlist &l)//线性表动态分配存储结构//
{
l.elem=(elemtype*)malloc(list_init_size*sizeof(elemtype));
if(!newbase)
{
cout<<" ERROR! HAVE NO SPACE"<<endl;
exit(overflow);
}
else
{
l.elem=newbase;
l.listsize+=listincrement;
}
q=&(l.elem[m-1]);
for(p=&(l.elem[l.length-1]);p>=q;--p)
if(!l.elem)
{
cout<<"the list have no space"<<endl;
exit(overflow);}
else{
l.length=0;
l.listsize=list_init_size;}
return ok;
}
void addelem(sqlist &l)
{
int i=0;
#include<iostream.h>
#include<stdlib.h>
#define list_init_size 100
#define listincrement 10
#define ok 1
#define overflow -1
#define elemtype int
#define error -1
}
int listinsert_sq(sqlist &l,int m,elemtype e)//插入函数//
{cout<<"请输入插入位置:";
cin>>m;
while(m<1||m>l.length+1)
{
cout<<"输入错误！请输入1到"<<l.length<<"之间的整数"<<endl;
cin>>m;
return ok;
}
void main()
{
sqlist l;
initlist_sq(l);
addelem(l);
int m,n,e;
listinsert_sq(l,m,e);
elemtype *f;
f=(elemtype*)malloc(sizeof(elemtype));
listdelete_sq(l,n,f);