实验报告线性表的顺序存储结构
数据结构实验报告-实验: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 问题描述利用顺序表设计一组输入数据假定为一组整数能够对顺序表进行如下操作创建一个新的顺序表实现动态空间分配的初始化根据顺序表结点的位置插入一个新结点位置插入也可以根据给定的值进行插入值插入形成有序顺序表根据顺序表结点的位置删除一个结点位置删除也可以根据给定的值删除对应的第一个结点或者删除指定值的所有结点值删除利用最少的空间实现顺序表元素的逆转实现顺序表的各个元素的输出彻底销毁顺序线性表回收所分配的空间对顺序线性表的所有元素删除置为空表返回其数据元素个数按序号查找根据顺序表的特点可以随机存取直接可以定位于第 i 个结点查找该元素的值对查找结果进行返回按值查找根据给定数据元素的值只能顺序比较查找该元素的位置对查找结果进行返回判断顺序表中是否有元素存在对判断结果进行返回编写主程序实现对各不同的算法调用2 实现要求对顺序表的各项操作一定要编写成为C C 语言函数组合成模块化的形式每个算法的实现要从时间复杂度和空间复杂度上进行评价初始化算法的操作结果构造一个空的顺序线性表对顺序表的空间进行动态管理实现动态分配回收和增加存储空间位置插入算法的初始条件顺序线性表L已存在给定的元素位置为i且1≤i ≤ListLength L 1操作结果在L中第i个位置之前插入新的数据元素eL的长度加1位置删除算法的初始条件顺序线性表L已存在1≤i≤ListLength L 操作结果删除L的第i个数据元素并用e返回其值L的长度减1逆转算法的初始条件顺序线性表L已存在操作结果依次对L的每个数据元素进行交换为了使用最少的额外空间对顺序表的元素进行交换输出算法的初始条件顺序线性表L已存在操作结果依次对L的每个数据元素进行输出销毁算法初始条件顺序线性表L已存在操作结果销毁顺序线性表 L置空表算法初始条件顺序线性表L已存在操作结果将L重置为空表求表长算法初始条件顺序线性表L已存在操作结果返回L中数据元素个数按序号查找算法初始条件顺序线性表 L 已存在元素位置为 i且 1≤i≤ListLength L 操作结果返回 L 中第 i 个数据元素的值按值查找算法初始条件顺序线性表 L 已存在元素值为 e 操作结果返回 L 中数据元素值为 e 的元素位置判表空算法初始条件顺序线性表 L 已存在操作结果若 L 为空表则返回 TRUE否则返回 FALSE分析修改输入数据预期输出并验证输出的结果加深对有关算法的理解二基本实验内容单链表建立单链表完成链表带表头结点的基本操作建立链表插入删除查找输出求前驱求后继两个有序链表的合并操作其他基本操作还有销毁链表将链表置为空表求链表的长度获取某位置结点的内容搜索结点1 问题描述利用线性表的链式存储结构设计一组输入数据假定为一组整数能够对单链表进行如下操作初始化一个带表头结点的空链表创建一个单链表是从无到有地建立起一个链表即一个一个地输入各结点数据并建立起前后相互链接的关系又分为逆位序插在表头输入 n 个元素的值和正位序插在表尾输入 n 个元素的值插入结点可以根据给定位置进行插入位置插入也可以根据结点的值插入到已知的链表中值插入且保持结点的数据按原来的递增次序排列形成有序链表删除结点可以根据给定位置进行删除位置删除也可以把链表中查找结点的值为搜索对象的结点全部删除值删除输出单链表的内容是将链表中各结点的数据依次显示直到链表尾结点编写主程序实现对各不同的算法调用其它的操作算法描述略2 实现要求对链表的各项操作一定要编写成为 C C 语言函数组合成模块化的形式还要针对每个算法的实现从时间复杂度和空间复杂度上进行评价初始化算法的操作结果构造一个空的线性表 L产生头结点并使 L 指向此头结点建立链表算法初始条件空链存在操作结果选择逆位序或正位序的方法建立一个单链表并且返回完成的结果链表位置插入算法初始条件已知单链表 L 存在操作结果在带头结点的单链线性表 L 中第 i 个位置之前插入元素 e链表位置删除算法初始条件已知单链表 L 存在操作结果在带头结点的单链线性表 L 中删除第 i 个元素并由 e 返回其值输出算法初始条件链表 L 已存在操作结果依次输出链表的各个结点的值三扩展实验内容顺序表查前驱元素查后继元素顺序表合并等1 问题描述根据给定元素的值求出前驱元素根据给定元素的值求出后继元素对已建好的两个顺序表进行合并操作若原线性表中元素非递减有序排列要求合并后的结果还是有序有序合并对于原顺序表中元素无序排列的合并只是完成 A A∪B 无序合并要求同样的数据元素只出现一次修改主程序实现对各不同的算法调用2 实现要求查前驱元素算法初始条件顺序线性表 L 已存在操作结果若数据元素存在且不是第一个则返回前驱否则操作失败查后继元素算法初始条件顺序线性表 L 已存在操作结果若数据元素存在且不是最后一个则返回后继否则操作失败无序合并算法的初始条件已知线性表 La 和 Lb操作结果将所有在线性表 Lb 中但不在 La 中的数据元素插入到 La 中有序合并算法的初始条件已知线性表 La 和 Lb 中的数据元素按值非递减排列操作结果归并 La 和 Lb 得到新的线性表 LcLc 的数据元素也按值非递减排列四扩展实验内容链表1 问题描述求前驱结点是根据给定结点的值在单链表中搜索其当前结点的后继结点值为给定的值将当前结点返回求后继结点是根据给定结点的值在单链表中搜索其当前结点的值为给定的值将后继结点返回两个有序链表的合并是分别将两个单链表的结点依次插入到第 3 个单链表中继续保持结点有序2 实现要求求前驱算法初始条件线性表 L 已存在操作结果若 cur_e 是 L 的数据元素且不是第一个则用 pre_e 返回它的前驱求后继算法初始条件线性表 L 已存在操作结果若 cur_e 是 L 的数据元素且不是最后一个则用 next_e 返回它的后继两个有序链表的合并算法初始条件线性表单链线性表 La 和 Lb 的元素按值非递减排列操作结果归并 La 和 Lb 得到新的单链表三实验环境和实验步骤实验环境利用CodeBlocks1005集成开发环境进行本实验的操作实验步骤――顺序表的定义与操作1启动CodeBlocks1052按Create a new project 通过file 按CC source选择c然后GO储存文件D\c语言\顺序表c3进行编代码4编好之后搞ctrlshiftF9进行编译然后按ctrlF105如果编译出问题然后进行调试实验步骤――链表的定义与操作1启动CodeBlocks1052按Create a new project 通过file 按CC source选择c然后GO储存文件D\c语言\单链表c3进行编代码4编好之后搞ctrlshiftF9进行编译然后按ctrlF105如果编译出问题然后进行调试四 includeinclude "stdlibh"includedefine LIST_INIT_SIZE 100define ok 1define ERROR 0define OVERFLOW -1define Num 3typedef int DataTypetypedef int Statustypedef structDataType elemint Lengthint ListsizeSeqListSeqList LStatus InitSeqList SeqList LL- elem Da。
《线性表的顺序存储》实验报告
《线性表的顺序存储》实验报告1.需解决的的问题利用顺序表,设计一组输入数据。
2.数据结构的定义typedefstruct{ElemType *elem;int length;intlistsize;}SqList;3.程序的结构图4.函数的功能1)初始化一个空顺序表voidInitSqList(SqList *L){L->elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!L->elem) exit(OVERFLOW);L->length=0;L->listsize=LIST_INIT_SIZE;}2)输入元素voidPushSqList(SqList *L){inti;printf("input the length of the list:");scanf("%d",&L->length);printf("input the sqlist:");for(i=0;i<L->length;i++){printf("input the %dth number:",i+1);scanf("%d",&L->elem);}}3)在指定位置插入一个指定的元素voidInsertSqList(SqList *L,inti,ElemType x){ElemType *newbase;intn,m;if(i<1||i>L->length+1){printf("ERROR!");}if(L->length>=L->listsize){newbase=(ElemType*)realloc(L->elem,(L->listsize+LISTINCREMENT)*sizeof(ElemType));if(!newbase) exit(OVERFLOW);L->elem=newbase;L->listsize+=LISTINCREMENT;}else{for(n=L->length;n>=i;n--){++L->length;L->elem[n]=L->elem[n-1];}L->elem[i-1]=x;printf("the list is:");for(m=0;m<L->length+1;n++)printf("%d",L->elem[n]);}}4)删除指定位置的元素voidDelSqList(SqList *L,inti){ElemType *p,*q;ElemType x;int n;if(i<1||i>L->length)printf("ERROR!");p=&(L->elem[i-1]);x=*p;for(q=p;q<&(L->elem[L->length-1]);q++)*q=*(q+1);L->length--;printf("the element which is delete is %d",x);printf("the list is:");for(n=0;n<L->length-1;n++)printf("%d",L->elem[n]);}5)将顺序表中所有的元素颠倒voidChangeoverSqList(SqList *L){SqList S;inti,j;if(L->length==L->listsize)S.elem=(ElemType*)malloc(L->length*sizeof(ElemType));if(!S.elem) exit(OVERFLOW);else{for(i=0;i<L->length;i++)S.elem[i]=L->elem[L->length-i-1];for(i=0;i<L->length;i++)L->elem[i]=S.elem[i];}printf("the list is:");for(j=0;j<L->length;i++)printf("%d",L->elem[i]);}6)按顺序输出表中元素voidPrintSqList(SqList *L){inti;for(i=0;i<L->length;i++)printf("%d ",L->elem[i]);}7)摧毁顺序表voidDestroySqList(SqList *L){if(L->elem) free(L->elem);}8)清空顺序表voidClearSqList(SqList *L){L->length=0;}9)查找指定位置的元素,并返回该元素的值intGetElem(SqList *L,inti){ElemType x;if(i<1||i>L->length+1) {printf("ERROR!");}else{x=L->elem[i-1];printf("the elem is %d",x);}}5.输入/输出数据1)创建一个顺序表,先输入表长度,然后输入数据2)选择菜单,进行不同操作选‘1’,在指定位置插入指定元素选‘2’,删除指定位置的元素选‘3’,颠倒顺序表中元素的顺序选‘4’,按顺序输出表中的元素选‘5’,摧毁顺序表选‘6’,清空线性表选‘7’,输出当前顺序表的长度选‘8’,输出指定位置的元素选‘9’,退出该程序6.总结这个实验让我更好的掌握了在线性表的顺序存储中如何初始化,如何进行输入输出的处理,以及各种常用功能是怎样实现的。
数据结构实验报告-线性表的顺序存储
姓 名
专业班级
实验地点
指导教师
实验时间
一、实验目的及要求
本次实验目的是通过上机练习,熟悉和掌握课堂所讲授的基本知识点。要求上机以前要认真复习课堂教学内容。完成教师带领实验,完成线性表的顺序存储实验。
二、实验设备(环境)及要求
计算机;学生不许把食物带到机房吃;不许上网做与实验无关的内容;不许同学之间聊天;保持实验室安静卫生。下课把键盘,座椅放回原处。
Integer length;/*当前线性表长度,线性表中现有元素个数*/
Integer listsize;/*当前分配的存储量以下定义线性表的操作*/
Integer InitList(Class_List *SqList)
/*构造一个空的线性表*/
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
typedef int Integer;
typedef char *String;
typedef struct
{
Integer number;
String name[10];
Integer age;
String interest[50];
完成一个有多于3个学生的线性表。并且显示学生信息。删除其中一个学生。然后再打印显示。
Source.cpp
#include"header.h"
void main()
{
Class_List xinji2013;
InitList(&xinji2013);
Student st;
Integer i,n=2,w,q,e;
三、实验内容与步骤
线性表实验
实验一线性表的顺序存储一、实验说明实验项目名称:线性表的顺序存储实验类型:基础实验课时:2实验所用主要仪器:微型计算机1台,安装中文版Windows 2000/XP 操作系统、VC++6.0集成编程环境。
二、实验目的:1. 掌握线性表的顺序存储结构。
2. 利用顺序存储结构实现线性表的基本操作。
3. 了解线性表的应用。
三、实验内容1. 运行顺序表的演示程序,掌握顺序表的存储结构的实现,进一步了解顺序表的初始化、查找、插入、删除、销毁等算法的编程实现。
(请运行源程序,写出创建线性表以及线性表的插入、删除、查找等一组测试结果)2. 按课本P43题2.6的要求,在演示程序中增加顺序表逆置功能。
本题要求:(1) 写出顺序表逆置算法加入到程序中并上机验证通过。
(2) 设计一组测试数据,并测试程序各个功能,记录输出结果。
(请查看源码中的reverse(L)函数)3. 约瑟夫圈问题:假设有n个人按1、2、3、…、n的顺序围成一圈。
现在,从第s个人开始按1、2、3、…、m的顺序报数,数到m的人出圈,接着从出圈的下一个人开始重复此过程,直到所有人出圈为止。
求出所有人的出圈顺序。
本题解法1:用顺序表为数据结构来解决这个问题。
算法如下:可以将n个人的编号存入一个一维数组中,表的长度就是人数n,因此,就可以用一维数组来代替顺序表。
算法的思想是:先求出出圈人的编号,用一个临时单元保存它,然后从出圈人的后一个开始,直到最后一个,都按顺序向前移动一个位置,再将临时单元的出圈人编号存入最后。
当这个重复步骤完成后,数组中存放的是出圈人的逆序列。
本题中,围圈的人数n、出圈的报数号m、开始报数的位置s,在程序中预先给定为10、3、2。
当然,用户也可以从键盘临时输入。
本题提供源程序。
(请查看源码中的joes(int n,int s,int m)、joes1(SqList &a,int n,int s,int m)、joes2(SqList a,int n,int s,int m)函数,对比两种方法解决约瑟夫问题的优劣性)本题要求:要求在main函数中修改joes、Joes1函数,设计出至少三组不同的测试数据(对应三个变量人数n、报数号m、开始位置s),记录输出结果。
数据结构线性表实验报告
数据结构线性表实验报告数据结构线性表实验报告引言:数据结构是计算机科学中的一个重要概念,它研究如何组织和存储数据,以便能够高效地访问和操作。
线性表是数据结构中最基本的一种,它是一种有序的数据元素集合,其中的元素之间存在一对一的关系。
本次实验旨在通过实际操作线性表,加深对数据结构的理解,并掌握基本的线性表操作。
实验目的:1. 理解线性表的概念和特点;2. 掌握线性表的基本操作,如插入、删除、查找等;3. 熟悉线性表的顺序存储结构和链式存储结构;4. 分析不同存储结构的优缺点。
实验内容:1. 实现线性表的顺序存储结构顺序存储结构是将线性表的元素按照其逻辑顺序依次存放在一块连续的存储空间中。
我们可以使用数组来实现顺序存储结构。
首先,定义一个固定大小的数组作为线性表的存储空间,然后通过数组的下标来访问和操作线性表中的元素。
在插入和删除元素时,需要移动其他元素的位置,以保持线性表的有序性。
2. 实现线性表的链式存储结构链式存储结构是将线性表的元素存储在一系列的结点中,每个结点包含一个数据元素和一个指向下一个结点的指针。
通过将各个结点用指针连接起来,形成一个链表。
在插入和删除元素时,只需要修改相邻结点之间的指针,而不需要移动其他元素的位置。
实验步骤:1. 实现顺序存储结构的线性表首先,定义一个固定大小的数组,用于存储线性表的元素。
然后,实现插入、删除、查找等基本操作。
在插入元素时,需要判断线性表是否已满,如果已满则需要扩容。
在删除元素时,需要判断线性表是否为空,如果为空则无法删除元素。
通过实现这些基本操作,可以对线性表进行增删查改等操作。
2. 实现链式存储结构的线性表首先,定义一个结点类,包含一个数据元素和一个指向下一个结点的指针。
然后,通过将各个结点用指针连接起来,形成一个链表。
实现插入、删除、查找等基本操作。
在插入元素时,需要找到插入位置,并修改相邻结点之间的指针。
在删除元素时,需要找到待删除元素的前一个结点,并修改前一个结点的指针。
存储结构描述实验报告
一、实验目的通过本次实验,使学生掌握数据结构中存储结构的基本概念,了解不同存储结构的特点和适用场景,能够根据具体问题选择合适的存储结构,提高编程能力和问题解决能力。
二、实验环境1. 操作系统:Windows 102. 编程语言:C++3. 开发环境:Visual Studio 2019三、实验内容1. 线性表的存储结构描述(1)顺序存储结构:使用数组实现线性表的存储结构,通过数组的索引来访问元素。
顺序存储结构具有以下特点:优点:存储密度高,空间利用率高;随机访问速度快。
缺点:插入和删除操作需要移动大量元素,效率较低。
(2)链式存储结构:使用链表实现线性表的存储结构,每个节点包含数据和指向下一个节点的指针。
链式存储结构具有以下特点:优点:插入和删除操作效率高,只需修改指针;支持动态内存分配。
缺点:存储密度低,空间利用率较低;随机访问速度慢。
2. 栈的存储结构描述(1)顺序存储结构:使用数组实现栈的存储结构,栈顶元素位于数组的最后一个位置。
顺序存储结构具有以下特点:优点:存储密度高,空间利用率高;随机访问速度快。
缺点:插入和删除操作需要移动大量元素,效率较低。
(2)链式存储结构:使用链表实现栈的存储结构,每个节点包含数据和指向下一个节点的指针。
链式存储结构具有以下特点:优点:插入和删除操作效率高,只需修改指针;支持动态内存分配。
缺点:存储密度低,空间利用率较低;随机访问速度慢。
3. 队列的存储结构描述(1)顺序存储结构:使用数组实现队列的存储结构,队首元素位于数组的第一个位置,队尾元素位于数组的最后一个位置。
顺序存储结构具有以下特点:优点:存储密度高,空间利用率高;随机访问速度快。
缺点:插入和删除操作需要移动大量元素,效率较低。
(2)链式存储结构:使用链表实现队列的存储结构,队首元素位于链表的第一个节点,队尾元素位于链表的最后一个节点。
链式存储结构具有以下特点:优点:插入和删除操作效率高,只需修改指针;支持动态内存分配。
线性表实验报告
线性表实验报告一、实验目的本次实验的主要目的是深入理解线性表的基本概念和操作,通过实际编程实现线性表的存储和基本运算,掌握线性表在数据结构中的应用,提高对数据结构的理解和编程能力。
二、实验环境本次实验使用的编程语言为C++,开发工具为Visual Studio 2019。
三、实验原理线性表是一种最基本、最简单的数据结构,它是由 n(n≥0)个数据元素组成的有限序列。
在这个序列中,每个数据元素的位置是按照其逻辑顺序排列的。
线性表有两种存储结构:顺序存储结构和链式存储结构。
顺序存储结构是用一组地址连续的存储单元依次存储线性表中的数据元素,使得逻辑上相邻的两个元素在物理位置上也相邻。
其优点是可以随机访问表中的任意元素,时间复杂度为 O(1);缺点是插入和删除操作需要移动大量元素,时间复杂度为 O(n)。
链式存储结构是通过指针将各个数据元素链接起来,每个数据元素由数据域和指针域组成。
其优点是插入和删除操作不需要移动大量元素,时间复杂度为 O(1);缺点是不能随机访问表中的元素,需要从头指针开始遍历,时间复杂度为 O(n)。
四、实验内容本次实验实现了顺序表和链表的基本操作,包括创建、插入、删除、查找、遍历等。
1、顺序表的实现定义顺序表的结构体,包括数据存储数组和表的长度。
实现顺序表的初始化函数,将表的长度初始化为 0。
实现顺序表的插入函数,在指定位置插入元素,如果插入位置非法或表已满,则返回错误。
实现顺序表的删除函数,删除指定位置的元素,如果删除位置非法,则返回错误。
实现顺序表的查找函数,查找指定元素,如果找到则返回元素的位置,否则返回-1。
实现顺序表的遍历函数,输出表中的所有元素。
2、链表的实现定义链表的结构体,包括数据域和指向下一个节点的指针域。
实现链表的创建函数,创建一个空链表。
实现链表的插入函数,在指定位置插入元素,如果插入位置非法,则返回错误。
实现链表的删除函数,删除指定位置的元素,如果删除位置非法,则返回错误。
数据结构实验报告—顺序表
《算法与数据结构》课程实验报告一、实验目的1、实现线性表的顺序存储结构。
2、熟悉C++程序的基本结构,掌握程序中的头文件、实现文件和主文件之间的相互关系及各自的作用。
3、熟悉顺序表的基本操作方式,掌握顺序表相关操作的具体实现。
二、实验内容及要求对顺序存储的线性表进行一些基本操作。
主要包括:(1)插入:操作方式为在指定元素前插入、在指定元素之后插入、在指定位置完成插入。
(2)删除:操作方式可分为删除指定元素、删除指定位置的元素等,尝试实现逻辑删除操作。
(3)显示数据。
(4)查找:查询指定的元素(可根据某个数据成员完成查询操作)。
(5)定位操作:定位指定元素的序号。
(6)更新:修改指定元素的数据。
(7)数据文件的读写操作等。
其它操作可根据具体需要自行补充。
要求线性表采用类的定义,数据对象的类型自行定义。
三、系统分析(1)数据方面:能够实现多种数据类型顺序表的创建,并进行操作,不同的数据类型数据使用不同的文本文件保存。
(2)功能方面:能够实现线性表的一些基本操作,主要包括:1.计算表最大可以容纳表项个数以及当前表的当前长度。
2.能够进行添加操作,在已有的数据文件中进行数据的添加。
3.能够进行搜索操作,返回搜索项在表中表项序号4.能够进行定位操作,定位到表中合理位置。
5.能够进行取值操作,根据用户需求取出表中某项的值。
6.能够进行修改操作,在用户选择修改项后将重新输入内容修改到对应位置。
7.能够进行插入操作,在用户选择合理位置并输入插入内容后即可。
8.能够进行删除操作,用户根据选择表中项数删除对应数据。
9.能够进行判断表空或表满。
四、系统设计(1)设计的主要思路根据实验要求,首先将顺序表模板类完成,并将需要实现的功能代码完善,在写实现各个功能的菜单并将模板类实例化为简单数据类型最后进行调试,由于还需使得顺序表能够存储自定义的学生类类型数据,故根据要求写出Student类,并将之前所写得模板类用学生类数据类型实例化,再进行调试。
线性表的顺序存储结构实验报告总结
线性表的顺序存储结构实验报告总结一、需求分析⒈本程序中,要求输入到表A,B中的元素是整形的,并且要按非递增顺序输入,否则系统会给出“出错信息”。
输出结果应该是一个不含有重复元素的非递增的表。
⒉本程序以用户和计算机的对话方式执行,即在计算机演示界面上显示“提示信息”后,由用户在键盘上输入相应的信息;相应的输入数据和运算结果显示在其后。
⒊程序执行的命令包括:(1)构造线性表A (2)构造线性表B (3)检验表A,B是否非递减有序(4)求表A与B的合并(5)删除表中值相同的多余元素(6)结束。
4.测试数据(1)A=123(2)A=9 5 0 -2B=1050-1-3-5 -10二、概要设计⒈为实现上述算法,需要线性表的抽象数据类型:ADT Stack {数据对象:D={ai:|ai∈ElemSet,i=1…n,n≥0}数据关系:R1={<ai-1,ai>|ai-1,ai∈D,i=2,…n}基本操作:init(list *L)操作结果:构造一个空的线性表L。
InputList(List *L)初始条件:线性表L已经存在操作结果:人工输入了一张表。
CheckList(List *L)初始条件:线性表L已经存在操作结果:判断L是否非递增有序,若为否,则重新输入。
MergeList(List *La,List *Lb,List *Lc)初始条件:非递增线性表La,Lb已经存在操作结果:合并La,Lb得到Lc,Lc仍按非递增有序排列。
DeleteSame(List *L)初始条件:非递增线性表L已经存在操作结果:删除了L中值相同的元素。
PrintList(List L)初始条件:线性表L已经存在操作结果:打印出表L。
}ADT List2. 本程序有三个模块:⑴主程序模块void main(){初始化;do{接受命令;显示结果;}while(执行完毕)}⑵线性表单元模块:实现线性表抽象数据类型;⑶结点结构单元模块:定义线性表中的结点结构。
线性表的实验报告
线性表的实验报告线性表的实验报告概述:线性表是一种常见的数据结构,它是由一组具有相同数据类型的元素组成的序列。
本次实验旨在通过实际操作线性表,掌握线性表的基本操作以及了解其应用场景。
实验目的:1. 理解线性表的概念和基本操作;2. 掌握线性表的顺序存储结构和链式存储结构;3. 熟悉线性表的常见应用场景。
实验材料:1. 计算机;2. 编程软件(如C、C++、Java等);3. 实验教材或参考资料。
实验步骤:一、线性表的顺序存储结构实验1. 创建一个空的线性表;2. 向线性表中插入若干元素;3. 删除线性表中的某个元素;4. 根据索引查找线性表中的元素;5. 遍历线性表,输出所有元素。
二、线性表的链式存储结构实验1. 创建一个空的链表;2. 向链表中插入若干节点;3. 删除链表中的某个节点;4. 根据节点值查找链表中的节点;5. 遍历链表,输出所有节点。
实验结果:1. 顺序存储结构实验结果:- 成功创建空的线性表;- 成功插入若干元素;- 成功删除某个元素;- 成功根据索引查找元素;- 成功遍历线性表,输出所有元素。
2. 链式存储结构实验结果:- 成功创建空的链表;- 成功插入若干节点;- 成功删除某个节点;- 成功根据节点值查找节点;- 成功遍历链表,输出所有节点。
实验分析:1. 顺序存储结构适用于元素个数固定或变化不大的情况,插入和删除操作需要移动大量元素,效率较低;2. 链式存储结构适用于元素个数不固定的情况,插入和删除操作只需修改指针,效率较高;3. 线性表的应用场景包括但不限于:图书馆图书管理系统中的图书列表、学生信息管理系统中的学生列表等。
实验总结:通过本次实验,我深入了解了线性表的概念、基本操作以及两种常见存储结构。
顺序存储结构适用于元素个数固定的情况,而链式存储结构适用于元素个数不固定的情况。
线性表在实际应用中有着广泛的应用场景,如图书馆管理系统、学生信息管理系统等。
在以后的学习和工作中,我将灵活运用线性表,为解决实际问题提供便利。
数据结构实验报告--
数据结构实验报告--实验一、线性表的实现线性表是常用的数据结构之一,其中最常用的是顺序存储结构。
本实验使用C语言实现了顺序存储结构的线性表。
首先,定义了一个结构体来表示线性表:```#define MAXSIZE 100 //线性表最大长度typedef struct {int data[MAXSIZE]; //存放线性表元素int length; //线性表当前长度} SqList; //线性表类型定义```其中,data数组存放线性表元素,length表示线性表当前长度。
接着,定义了三个基本操作:1. 初始化线性表```void InitList(SqList *L) {L->length = 0;}```2. 插入元素```bool ListInsert(SqList *L, int i, int e) {if (i < 1 || i > L->length + 1) { //插入位置不合法}if (L->length >= MAXSIZE) { //线性表已满return false;}for (int j = L->length; j >= i; j--) { //将第i个位置之后的所有元素后移一位L->data[j] = L->data[j - 1];}L->data[i - 1] = e; //将元素e插入到第i个位置L->length++; //线性表长度加1return true;}```3. 删除元素以上三个操作就是线性表的基本操作,通过这三个操作就能完成线性表的所有操作。
实验二、栈和队列的实现2.1 栈的实现栈是一种后进先出(Last In First Out)的数据结构。
我们可以用线性表来实现栈,只需要对线性表的插入和删除操作进行限制就行了。
具体实现如下:void InitStack(Stack *S) {S->top = -1; //初始化栈顶指针}bool Push(Stack *S, int e) {if (S->top == STACK_SIZE - 1) { //栈已满,无法插入元素}S->top++; //栈顶指针加1S->data[S->top] = e; //插入元素e到栈顶return true;}以上代码实现了栈的初始化、入栈和出栈操作。
线性表实验报告
LinkList p;
p=L->next;
while(p){
printf("%5d",p->data);
p=p->next;
}
return OK;
}
void main()
{
int i,n,k,d,e;
LinkList La,Lb;
InitList_L(La);
InitList_L(Lb);
e=L.elem[i];
for(j=i;j<=L.length;j++)
L.elem[j]=L.elem[j+1];
L.length--;
return ok;
}
int output(sqlist &L){
int i;
printf("output sqlist data:\n");
for(i=0;i<L.length;i++)
PrintList(La);
printf("\nAfter delete the list is:\n");
ListDelete_L(La,e);
PrintList(La);
printf("\n");
printf("I will insert:");
scanf("%d",&k);
ListInsert_L(La,k);
int a,j,i,m;
CLinkList p,r;
printf("Input the m(m<=20):\nm=");
scanf("%d",&m);
线性表实验报告
线性表实验报告导言:线性表是数据结构中最基本也是最常用的一种结构之一。
它以一种线性的方式存储和组织数据,简单而高效。
本实验旨在通过对线性表的实践操作,加深对线性表概念的理解,并掌握其基本操作。
实验目的:1. 了解线性表的基本概念和特点;2. 掌握线性表的基本操作,如插入、删除、查找等;3. 熟悉线性表的顺序存储和链式存储结构;4. 学会通过编程实现线性表的基本操作。
实验内容:本次实验分为两个部分,分别是线性表的顺序存储和链式存储结构。
一、顺序存储结构的线性表操作1. 初始化线性表:定义一个固定大小的数组,用于存储线性表中的元素;2. 插入元素:从表尾开始,逐个向前移动元素,为新元素腾出位置;3. 删除元素:从指定位置开始,逐个向后移动元素,覆盖待删除元素;4. 查找元素:按照线性表的顺序依次比较元素,直到找到目标元素或遍历结束;5. 获取表长度:通过记录插入和删除操作的次数,得到线性表的长度。
二、链式存储结构的线性表操作1. 定义结点:创建一个结点类,包含数据域和指向下一结点的指针;2. 初始化链表:定义一个头指针,将其初始化为 NULL,表示链表为空;3. 插入元素:找到插入位置的前一个结点,将新结点插入到其后面;4. 删除元素:找到待删除结点的前一个结点,将其指针指向待删除结点的下一个结点;5. 查找元素:从链表头部开始遍历,逐个比较结点中的数据,直到找到目标元素或遍历结束;6. 获取表长度:通过遍历链表中的结点,计数来获取表长度。
实验过程:1. 根据实验目的,在 C/C++ 环境下创建一个项目,并命名为"LinearList";2. 依次完成顺序存储结构和链式存储结构的线性表操作函数的编写;3. 调用这些函数,对线性表进行初始化、插入、删除、查找等操作;4. 验证线性表操作的正确性,并检查函数是否能正确处理各种边界情况;5. 根据实验内容,编写实验报告,记录实验过程和结果。
实验一线性表的顺序存储结构实验报告页
攀枝花学院实验报告实验课程数据结构实验项目:线性表的顺序存储实验日期:系:班级:姓名:学号:同组人:指导老师:成绩:[ 实验目的:]1、掌握线性表的顺序存储结构。
2、能熟练地利用顺序存储结构实现线性表的基本操作。
3、能熟练地掌握顺序存储结构中算法的实现。
[ 实验仪器设备、药品、器材]1、硬件环境微型计算机一台2、软件环境Windows98/2000/XP/win7操作系统、调试程序VC 6.0.[ 实验原理(装置)]无[ 实验步骤(内容)]一、建立含有若干个元素的顺序表,并将结果在屏幕上输出。
1、顺序表源代码如下创建了顺序表的头文件SeqList.h主要代码如下:void initList(SeqList& L){L.data=new DataType[initSize];if (! L.data){cerr<<"存储错误分配!\n";exit(1);}L.maxSize=initSize;L.n=0;};void Creat(SeqList& L)//获取线性表的值{int i,n;initList(L);printf("请输入线性表的元素个数:");scanf("%d",&n);printf("请输入%d个顺序表元素:\n",n);for(i=0;i<n;i++)scanf("%d",&L.data[i]);L.n=n;}void clearList(SeqList& L)//清空顺序表{L.n=0;}int Length(SeqList& L)//计算顺序表的长度{return L.n;}int isEmpty(SeqList& L)//判断空否{return (L.n==0)?1:0;}int isFull(SeqList& L)//判断满否{return (L.n==L.maxSize)?1:0;}int Search(SeqList& L,DataType x)//顺序查找算法{for(int i=1;i<=L.n;i++)if(L.data[i-1]==x)return i;return 0;};int Locate(SeqList& L,int i)//顺序定位算法{if(i>=1 && i<=L.n) return i;elsereturn 0;};void Copy(SeqList& L1,SeqList& L2)//顺序表复制算法{L1.maxSize=L2.maxSize;L1.n=L2.n;if(!L1.data) {L1.data=new DataType[L1.maxSize]; if(! L1.data){cout<<"存储分配错误!\n";exit(1);}}for(int i=1;i<=L2.n;i++)L1.data[i-1]=L2.data[i-1];};int Insert(SeqList& L,int i,DataType& x)//顺序表插入{if(L.n==L.maxSize) return 0;if(i<0 || i>L.n+1) return 0;for(int j=L.n;j>=i;j--)L.data[j]=L.data[j-1];L.data[i-1]=x;L.n++;return 1;};int Remove(SeqList& L,int i,DataType& x)//顺序表删除{if(!L.n)return 0;if(i<1 || i>L.n)return 0;x=L.data[i-1];for(int j=i;j<L.n;j++)L.data[j-1]=L.data[j];L.n--;return 1;};主函数代码如下:void main(){int ch;int i;DataType x;SeqList L;L.n=0;initList(L);printf("**************\n");printf("******************欢迎进入CHEN CHENG 顺序表结构******************\n");Creat(L);menu();/*显示菜单*/scanf("%d",&ch); /*输入一个数符*/while(1){switch(ch){case 0: printf("The list:");Print(L);break;case 1: printf("The list's length is %d\n", Length(L));break;case 2: i=isEmpty(L);if(i==0)printf("顺序表非空!\n");if(i==1)printf("顺序表为空!\n");break;case 3: i=isFull(L);if(i==1)printf("顺序表已满!\n");if(i==0)printf("顺序表未满!\n");break;case 4:printf("x=");scanf("%d",&x);i=Search(L,x);if(i==0)printf("查找失败!");elseprintf("查找成功:\n%d 为查找数!\n",i);break;case 5:printf("i=");scanf("%d",&i);i=Locate(L,i);if(i==0) printf("Nofind %d\n",i);elseprintf("The locationof %d is %d\n",L.data[i-1],i);break;case 6: printf("创建一个新的顺序表!\n");SeqList La;La.n=0;initList(La); Copy(La,L);printf("输出顺序表L的值:\n");Print(L);printf("\n");printf("输出顺序表La的值:\n");Print(La);break;case 7:printf("i=");scanf("%d",&i);printf("\n");printf("x=");scanf("%d",&x);printf("\n");if(Insert(L,i,x)==1){printf("Insert success !\n");printf("输出插入元素后的顺序表L!\n");Print(L);}elseprintf("Insert failed !\n");break;case 8:printf("i=");scanf("%d",&i);if(Remove(L,i,x)){printf("Delete success!\nThe deleted data is %d!\n",x);printf("输出删除后元素后的顺序表L!\n");Print(L);}elseprintf("Delete failed !\n");break;case 9:printf("创建一个新的顺序表!\n");SeqList Lc;La.n=0;initList(Lc);Creat(Lc);Merge(Lc,L);printf("输出求交后的顺序表的值:");Print(Lc);break;case 10:printf("创建一个新的顺序表!\n");SeqList Lb;La.n=0;initList(Lb);Creat(Lb);Intersection(Lb,L);printf("输出求交后的顺序表的值:");Print(Lb);break;case 11: printf("EIXT!");printf("\n");exit(1);}printf("再次输入选择:");scanf("%d",&ch);}}程序运行结果如下:2、对刚建立的表实现插入、删除、修改、查找,并将结果在屏幕上输出。
数据结构线性表实验报告
数据结构线性表实验报告一、实验目的本次实验的主要目的是深入理解和掌握数据结构中线性表的基本概念、存储结构和操作算法,并通过实际编程实现来提高对线性表的应用能力和编程技能。
二、实验环境本次实验使用的编程语言为C++,开发工具为Visual Studio 2019。
三、实验内容(一)线性表的顺序存储结构顺序表是用一组地址连续的存储单元依次存储线性表的数据元素。
其特点是逻辑上相邻的元素在物理位置上也相邻,便于随机存取,但插入和删除操作需要移动大量元素,效率较低。
(二)线性表的链式存储结构链表是通过指针将一组零散的存储单元链接成一个线性序列。
常见的链表有单链表、双向链表和循环链表。
链表的插入和删除操作只需修改指针,无需移动元素,但随机存取效率较低。
(三)线性表的基本操作实现1、初始化线性表2、销毁线性表3、清空线性表4、判断线性表是否为空5、获取线性表的长度6、获取指定位置的元素7、查找指定元素在线性表中的位置8、在线性表指定位置插入元素9、删除线性表指定位置的元素四、实验步骤(一)顺序表的实现1、定义顺序表的结构体,包括数据存储数组和表的长度。
2、实现顺序表的初始化函数,分配初始存储空间并设置表长度为0。
3、销毁顺序表函数,释放存储空间。
4、清空顺序表函数,将表长度置为 0。
5、判断顺序表是否为空,根据表长度判断。
6、获取顺序表长度,直接返回表长度。
7、获取指定位置元素,检查位置合法性后返回对应元素。
8、查找指定元素位置,遍历表进行比较。
9、插入元素函数,检查插入位置合法性,若合法则移动后续元素,插入新元素并更新表长度。
10、删除元素函数,检查删除位置合法性,若合法则移动后续元素,更新表长度。
(二)链表的实现1、定义链表节点结构体,包含数据域和指针域。
2、实现链表的初始化函数,创建头节点。
3、销毁链表函数,遍历链表释放节点内存。
4、清空链表函数,遍历链表删除节点但保留头节点。
5、判断链表是否为空,检查头节点的指针域是否为空。
数据结构实验报告1线性表的顺序存储结构
数据结构实验报告1线性表的顺序存储结构一、实验目的本次实验的主要目的是深入理解线性表的顺序存储结构,并通过编程实现其基本操作,包括创建线性表、插入元素、删除元素、查找元素以及输出线性表等。
通过实际操作,掌握顺序存储结构的特点和优势,同时也了解其在不同情况下的性能表现。
二、实验环境本次实验使用的编程语言为C++,编译环境为Visual Studio 2019。
三、实验原理1、线性表的定义线性表是由 n(n≥0)个数据元素组成的有限序列。
在顺序存储结构中,线性表的元素存储在一块连续的存储空间中,通过数组来实现。
2、顺序存储结构的特点存储密度高,无需额外的指针来表示元素之间的关系。
可以随机访问表中的任意元素,时间复杂度为 O(1)。
插入和删除操作需要移动大量元素,平均时间复杂度为 O(n)。
四、实验内容及步骤1、定义线性表的数据结构```cppdefine MAX_SIZE 100 //定义线性表的最大长度typedef struct {int dataMAX_SIZE; //存储线性表元素的数组int length; //线性表的当前长度} SeqList;```2、初始化线性表```cppvoid InitList(SeqList L) {L>length = 0; //初始时线性表长度为 0}```3、判断线性表是否为空```cppbool ListEmpty(SeqList L) {return (Llength == 0);}```4、求线性表的长度```cppint ListLength(SeqList L) {return Llength;}```5、按位查找操作```cppint GetElem(SeqList L, int i) {if (i < 1 || i > Llength) {printf("查找位置不合法!\n");return -1;}return Ldatai 1;}```6、按值查找操作```cppint LocateElem(SeqList L, int e) {for (int i = 0; i < Llength; i++){if (Ldatai == e) {return i + 1;}}return 0; //未找到返回 0}```7、插入操作```cppbool ListInsert(SeqList L, int i, int e) {if (L>length == MAX_SIZE) {//表已满printf("表已满,无法插入!\n");return false;}if (i < 1 || i > L>length + 1) {//插入位置不合法printf("插入位置不合法!\n");return false;}for (int j = L>length; j >= i; j) {//移动元素L>dataj = L>dataj 1;}L>datai 1 = e; //插入元素L>length++;//表长加 1return true;}```8、删除操作```cppbool ListDelete(SeqList L, int i) {if (L>length == 0) {//表为空printf("表为空,无法删除!\n");return false;}if (i < 1 || i > L>length) {//删除位置不合法printf("删除位置不合法!\n");return false;}for (int j = i; j < L>length; j++){//移动元素L>dataj 1 = L>dataj;}L>length; //表长减 1return true;}```9、输出线性表```cppvoid PrintList(SeqList L) {for (int i = 0; i < Llength; i++){printf("%d ", Ldatai);}printf("\n");}```10、测试用例```cppint main(){SeqList L;InitList(&L);ListInsert(&L, 1, 10);ListInsert(&L, 2, 20);ListInsert(&L, 3, 30);ListInsert(&L, 4, 40);ListInsert(&L, 5, 50);printf("线性表的长度为:%d\n", ListLength(L));printf("查找第 3 个元素:%d\n", GetElem(L, 3));int loc = LocateElem(L, 30);if (loc) {printf("元素 30 的位置为:%d\n", loc);} else {printf("未找到元素 30\n");}ListDelete(&L, 3);printf("删除第 3 个元素后的线性表:");PrintList(L);return 0;}```五、实验结果及分析1、实验结果成功创建并初始化了线性表。
实验报告材料--线性表
实验名称线性表实验室实验日期
return(1);
}
然后依次输出计算结果。
五、实验数据记录及分析(可包括错误提示,原因,如何解决等)
六、实验总结
t=t->next;
k=k+1;
}
最后释放结点,并将结果输出。
五、实验数据记录及分析(可包括错误提示,原因,如何解决等)
六、实验总结
经过该实验单链表是线性表的一种链式存储结构。
通过对线性表的链式存储结构进行了解与学习,了解了其与顺序表不同之处,
1. 通过保存直接后继元素的存储位置来表示数据元素之间的逻辑关系;
2. 插入删除操作通过修改结点的指针实现;
3. 不能随机存取元素;
七、代码清单
#inc lude<stdio.h>
#include<malloc.h>
#define NULL 0
typedef struct Node//结点类型定义
{
char data;
struct Node *next;。
线性表的顺序存储结构实验报告总结
线性表的顺序存储结构实验报告总结一、目的1.做实验的目的加深对线性表的理解,学会定义线性表的存储结构,掌握线性表的基本操作。
2.撰写实验报告的目的对本次实验情况进行总结,加强对实验内容的理解,对实验过程有一-个系统的认识,从中获得本次试验的经验,并对实验结果进行适当的分析,加深对栈和队列的理解和认识。
二、内容1.说明实验次数及实验内容本次实验用一次实验课时完成实验内容:节点定义:typedef struct node{int idx: int age: struct node *next:}Node, *List;本次实验的对象的存储内容包括功D和AGE,所以定义了如上的结构体,idx用于存储ID号,age用于存储年龄,next用于形成链式结构,Node定义了该类型的一一个节点,List定义了该类型的--个链表。
(1)、编写函数CreateList ()和PrintList(),从给定数组创建链表,打印链表。
int idx[8] = {1,2,3,4,5,6, 7,8}:int age[8] = {15, 18, 13, 22, 50, 18, 30, 20} :List CreatList(int idx[],int age[], int 1en) {}int PrintList(List L) {}(2)、编写函数DeleteNode(List L, int delete_ age),完成以下操作。
int DeleteNodeAge(List L, intdelete_ age) {}该函数传入List L,可以直接修改链表的节点,建议返回值为int 或void类型,无需为List类型,3,题同上。
2.1删除年龄为18的成员,打印链表。
2.2删除年龄为20的成员,打印链表。
2.3删除年龄为15的成员,打印链表。
2.4 (可选)删除年龄为21的成员(因无此成员,报错) ,打印链表。
.(3)、编写函数Inser tNodeByIdx(List L, Node nd),完成以下操作。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
4、撰写实验报告
实验内容
1.输入一组整型数据,建立顺序表。
2.实现该线性表的遍历。
3.实现该线性表的删除。
4、实现该线性表的插入。
5、编写一个主函数,调试上述算法。
实验数据
程序:
#include<>
#include<>
typedef int Elemtype;
}
}
id main()
{
int a[5];
int i;
Elemtype x;
list k;
cout<<"请输入线性表元素:"<<endl;
for(i=0;i<5;i++)
cin>>a[i];
cout<<endl;
initlist(k);
traverselist(k);
for(i=0;i<5;i++)
if(pos<0||pos>
{
cout<<"pos值无效!"<<endl;
return false;
}
if==0)
{
cout<<"线性表为空表!"<<endl;
return false;
}
for(int i=pos;i<;i++)
{[i-1]=[i];}
;
if(float/<&&>10)
{
int k=sizeof(Elemtype);
}
if==
{
int k=sizeof(Elemtype);
=(Elemtype *)realloc,2**k);
if==NULL)
{
cout<<"分配空间不成功!"<<endl;
return false;
}
=2*;
}
for(int i=;i>=pos-1;i--)
{[i+1]=[i];}
[pos-1]=item;
return;
}
=0;
}
bool insertlist(list &l,Elemtype item,int pos) //在线性表中插入元素
{
//cout<<"对任意的线性表中任意大位置插入任意的元素"<<endl;
if(pos<1||pos>+1)
{
cout<<"插入的位置非法!"<<endl;
return false;
insertlist(k,x,3);
traverselist(k);
cout<<"删除一个位置的元素:";
cin>>x;
if(deletelist(k,x))
cout<<"删除成功!"<<endl;
else cout<<"删除失败"<<endl;
traverselist(k);
}
运行结果:
实验总结
1、线性表的初始化为一个空表时,要明确给空(==NULL)
**大学实验报告
学院: 专业: 班级:
姓名
学号
实验组
实验时间
指导教师
成绩
实验项目名称
实验一线性表的顺序存储结构
实验目的
1. 熟练掌握线性表的基本操作在顺序存储和链式存储上的实现;
2. 以线性表的各种操作(建立、插入、删除等)的实现为重点;
3. 掌握线性表的动态分配顺序存储结构的定义和基本操作的实现;
2、线性表的插入、删除操作前都要进行非法位置的剔除
3、插入、删除等操作非法时,一定要有返回值(return false),否则操作会出现错误
4、程序编写过程中,要注意细节部分,减少错误的产生,减少调试时间
指导教师意见
签名: 年 月 日
注:各学院可根据教学需要对以上栏木进行增减。表格内容可根据内容扩充。
实验要求
1、 独立完成实验,并认真撰写实验报告
2、分析试验中出现的问题,并找出原因
实验原理
线性表顺序存储结构的初始化、遍历、插入、删除算法的程序编写及运用
实验仪器
运行Visual c++的微机一台
实验步骤
1、分别编写线性表顺序结构的初始化、遍历、插入、删除的程序
2、编写一个主程序来调用初始化、遍历、插入、删除函数
struct list{
Elemtype *elem;
int size;
int maxsize;
};
void initlist(list &l) //线性表的初始化
{
cout<<"线性表的初始化!"<<endl;
=10;
=new Elemtype[];
if==NULL)
{
cout<<"动态分配空间失败!"<<endl;
++;
return true;
}
void traverselist(list l) //线性表遍历
{
for(int i=0;i<;i++)
cout<<[i]<<endl;
}
bool deletelist(list &l,int pos) //删除线性表中的元素
{
cout<<"删除线性表中的任意元素"<<endl;
=(Elemtype *)realloc,*k/2);
=2;
}
return true;
}
void display(list l)
{
cout<<<<endl;
cout<<<<endl;
for(int i=0;i<;i++)
{
cout<<"输出第"<<i+1<<"个元素"<<endl;
cout<<[i]<<" ";
insertlist(k,a[i],i+1);
traverselist(k);
cout<<"插入一个位置:"<<endl;
cin>>x;
cout<<endl;
insertlist(k,0,x);
traverselist(k);
cout<<"插入一个元素:"<<endl;
cin>>x;
cout<<endl;