数据结构实验报告(C语言)顺序表查找
数据结构C语言实现顺序查找,折半查找,二叉排序树,哈希表实验原理(实验原理+程序代码+程序截图+实验小结
printf("top=%d, bottom=%d, mid=%d, a[%d]=%d\n",top,bottom,mid,mid,a[mid]);
if( (num>a[top]) || (num<a[bottom]) ) //输入的数num>a[top]或者num<a[bottom],肯定num不在这个表列中
学号:E30814013专业:网络工程姓名:张芸
实验日期:2010-6-12教师签字:成绩
实验报告
实验目的:实现顺序查找,折半查找,二叉排序树,哈希表实验原理:
顺序查找
int Search_Seq(SSTable ST, KeyType key) { //算法9.1
//在顺序表ST中顺序查找其关键字等于key的数据元素。
}
else
{
if (NULL == cursor->rchild)
{
cursor->rchild = node;
break;
}
cursor = cursor->rchild;
}
}
}
return;
}
/*查找指定值*/
BSTree Search(BSTree tree, ElemType item)
{
BSTree cursor = tree;
// p返回的是插入位置
} // SearchHash
顺序查找
#include<stdio.h>
void main()
{
int a[10]={1,2,3,4,5,6,7,8,9,10};
int i,x,y;
printf("输入你要查找的数:\n");
数据结构实验一顺序表实验报告
数据结构实验一顺序表实验报告
数据结构是计算机科学中的一门基础课程,在学习数据结构的过程中,顺序表是我们必须深入了解和掌握的重要数据结构之一。
在实验一中,我们对顺序表进行了一系列的操作,实现了增删改查等基本操作。
我们先来介绍一下顺序表的基本概念。
顺序表是将线性表中的数据存储在一段连续的存储空间中的数据结构,其查找效率高,但插入和删除操作效率较低。
顺序表需要预先分配一定的存储空间,当存储空间不足时需要进行动态扩容,即重新申请更大的存储空间并将原有数据复制到新的存储空间中。
在实验中,我们首先学习了顺序表的实现方式,包括顺序表的结构体定义、创建顺序表、插入元素、删除元素、修改元素以及查询元素等基本操作。
我们通过 C 语言来实现了这些操作,并将其封装成一个顺序表的 API,使其更加易于使用和维护。
在实验过程中,我们还发现顺序表中数据的存储顺序非常重要,因为顺序表中元素的存储顺序与元素的下标是一一对应的,如果存储的顺序错误,可能会导致元素的下标与我们想象中的不一致,从而造成一些意想不到的结果。
总的来说,实验一帮助我们更深入地了解了顺序表的实现方式和基本操作,同时也挖掘出了一些潜在问题,这对于我们今后的学习和实践都起到了很大的帮助。
数据结构C语言版 实验报告
数据结构C语言版实验报告一、实验目的本次实验旨在通过使用 C 语言实现常见的数据结构,加深对数据结构基本概念、原理和操作的理解,提高编程能力和解决实际问题的能力。
二、实验环境操作系统:Windows 10编程环境:Visual Studio 2019编程语言:C 语言三、实验内容1、线性表顺序表的实现与操作链表的实现与操作2、栈和队列栈的实现与应用(表达式求值)队列的实现与应用(模拟排队)3、树和二叉树二叉树的遍历(前序、中序、后序)二叉搜索树的实现与操作4、图图的存储结构(邻接矩阵、邻接表)图的遍历(深度优先搜索、广度优先搜索)四、实验步骤及结果1、线性表顺序表的实现与操作定义顺序表的数据结构,包括数组和表的长度。
实现顺序表的初始化、插入、删除、查找等操作。
测试顺序表的各种操作,输出操作结果。
```cinclude <stdioh>include <stdlibh>define MAX_SIZE 100typedef struct {int dataMAX_SIZE;int length;} SeqList;//初始化顺序表void initList(SeqList L) {L>length = 0;}//插入元素到顺序表int insertList(SeqList L, int pos, int element) {if (L>length >= MAX_SIZE || pos < 0 || pos > L>length) {return 0;}for (int i = L>length 1; i >= pos; i) {L>datai + 1 = L>datai;}L>datapos = element;L>length++;return 1;}//删除顺序表中的元素int deleteList(SeqList L, int pos) {if (pos < 0 || pos >= L>length) {return 0;}for (int i = pos; i < L>length 1; i++){L>datai = L>datai + 1;}L>length;return 1;}//查找顺序表中的元素int searchList(SeqList L, int element) {for (int i = 0; i < Llength; i++){if (Ldatai == element) {return i;}}return -1;}int main(){SeqList L;initList(&L);insertList(&L, 0, 10);insertList(&L, 1, 20);insertList(&L, 2, 30);printf("顺序表元素: ");for (int i = 0; i < Llength; i++){printf("%d ", Ldatai);}printf("\n");int pos = searchList(L, 20);if (pos!=-1) {printf("元素 20 在顺序表中的位置: %d\n", pos);} else {printf("顺序表中未找到元素 20\n");}deleteList(&L, 1);printf("删除元素后的顺序表元素: ");for (int i = 0; i < Llength; i++){printf("%d ", Ldatai);}printf("\n");return 0;}```实验结果:成功实现顺序表的初始化、插入、删除、查找等操作,输出结果符合预期。
c语言顺序表实验报告
c语言顺序表实验报告
C语言顺序表实验报告
实验目的:通过对C语言顺序表的实验,掌握顺序表的基本操作和实现方法,加深对数据结构的理解。
实验内容:本次实验主要包括以下内容:
1. 顺序表的创建与初始化
2. 顺序表的插入与删除
3. 顺序表的查找与修改
4. 顺序表的销毁与清空
实验步骤:
1. 创建顺序表:首先定义一个结构体来表示顺序表,包括表头指针、表长和表的最大长度等信息。
然后利用malloc函数为顺序表分配内存空间,并初始化表长和各元素的值。
2. 插入与删除操作:通过编写插入和删除函数来实现在顺序表中插入和删除元素的操作。
插入操作需要考虑插入位置的合法性和表的扩容问题,删除操作需要考虑删除位置的合法性和表的缩容问题。
3. 查找与修改操作:编写查找和修改函数来实现在顺序表中查找和修改元素的操作。
查找操作可以采用顺序查找或二分查找的方法,修改操作需要考虑修改位置和修改值的合法性。
4. 销毁与清空操作:编写销毁和清空函数来实现销毁和清空顺序表的操作。
销毁操作需要释放表的内存空间,清空操作需要将表的长度置零。
实验结果:经过实验,成功实现了顺序表的创建、插入、删除、查找、修改、
销毁和清空等基本操作。
通过实验,加深了对顺序表的理解和掌握,提高了对C语言和数据结构的应用能力。
实验总结:通过本次实验,我深刻认识到了数据结构在程序设计中的重要性,掌握了顺序表的基本操作和实现方法。
在今后的学习和工作中,我将继续加强对数据结构和算法的学习,不断提升自己的编程能力和解决问题的能力。
《数据结构》实验报告查找
实验四——查找一、实验目的1.掌握顺序表的查找方法,尤其是折半查找方法;2.掌握二叉排序树的查找算法。
二、实验内容1.建立一个顺序表,用顺序查找的方法对其实施查找;2.建立一个有序表,用折半查找的方法对其实施查找;3.建立一个二叉排序树,根据给定值对其实施查找;4.对同一组数据,试用三种方法查找某一相同数据,并尝试进行性能分析。
三、实验预习内容实验一包括的函数有:typedef struct ,创建函数void create(seqlist & L),输出函数void print(seqlist L),顺序查找int find(seqlist L,int number),折半查找int halffind(seqlist L,int number)主函数main().实验二包括的函数有:结构体typedef struct,插入函数void insert(bnode * & T,bnode * S),void insert1(bnode * & T),创建函数void create(bnode * & T),查找函数bnode * search(bnode * T,int number),主函数main().四、上机实验实验一:1.实验源程序。
#include<>#define N 80typedef struct{int number; umber;for(i=1;[i].number!=0;){cin>>[i].name>>[i].sex>>[i].age;++;cout<<endl;cin>>[++i].number;}}umber<<"\t"<<[i].name<<"\t"<<[i].sex<<"\t"<<[i].age<<endl;}umber==number)return i;}umber)return mid;elseif(number<[mid].number)high=mid-1;elselow=mid+1;}return 0;}void main(){int i,number;seqlist L;create(L);print(L);cout<<"折半查找:"<<endl;cout<<"输入学生学号:";cin>>number;if((i=halffind(L,number))!=0)cout<<"\t"<<[i].number<<"\t"<<[i].name<<"\t"<<[i].sex<<"\t"<<[i].age<<endl;elsecout<<"失败!"<<endl;cout<<"顺序查找:"<<endl;cout<<"输入学生学号:";cin>>number;if((i=find(L,number))!=0)cout<<"\t"<<[i].number<<"\t"<<[i].name<<"\t"<<[i].sex<<"\t"<<[i].age<<endl;elsecout<<"失败!"<<endl;}实验二:#include<>typedef struct{int number; 立二叉排序树"<<"\n\t2.插入学生信息"<<"\n\t3.查找学生信息"<<endl;cout<<"选择:";cin>>choice;switch(choice){case 1:{create(T);cout<<"成功建立!"<<endl;};break;case 2:{insert1(T);cout<<"插入成功!"<<endl;};break;case 3:{cout<<"输入待查学生的学号:";cin>>number;p=search(T,number);if(p)cout<<p-><<"\t"<<p-><<"\t"<<p-><<"\t"<<p-><<endl;elsecout<<"查找失败!"<<endl;};break;}cout<<"Continue(Y/N):";cin>>ctinue;if(ctinue=='y'||ctinue=='y')flag=1;elseflag=0;}}2.实验结果(截图)。
数据结构-顺序表-实验报告
实验报告课程数据结构及算法实验项目 1.顺序表的建立和基本运算成绩专业班级*** 指导教师***姓名*** 学号*** 实验日期***实验一顺序表的建立和基本运算一、实验目的1、掌握顺序表存储结构的定义及C/C++语言实现2、掌握顺序表的各种基本操作及C/C++语言实现3、设计并实现有序表的遍历、插入、删除等常规算法二、实验环境PC微机,Windows,DOS,Turbo C或者Visual C++三、实验内容1、顺序表的建立和基本运算(1)问题描述顺序表时常进行的运算包括:创建顺序表、销毁顺序表、求顺序表的长度、在顺序表中查找某个数据元素、在某个位置插入一个新数据元素、在顺序表中删除某个数据元素等操作。
试编程实现顺序表的这些基本运算。
(2)基本要求实现顺序表的每一个运算要求用一个函数实现。
(3)算法描述参见教材算法2.3、算法2.4、算法2.5等顺序表的常规算法。
(4)算法实现#include<malloc.h> // malloc()等#include<stdio.h> // NULL, printf()等#include<process.h> // exit()// 函数结果状态代码#define OVERFLOW -2#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1typedef int Status; // Status是函数的类型,其值是函数结果状态代码,如OK等typedef int Boolean; // Boolean是布尔类型,其值是TRUE或者FALSE//-------- 线性表的动态分配顺序存储结构-----------#define LIST_INIT_SIZE 10 // 线性表存储空间的初始分配量#define LIST_INCREMENT 2 // 线性表存储空间的分配增量typedef int ElemType;struct SqList{ElemType *elem; // 存储空间基址int length; // 当前长度int listsize; // 当前分配的存储容量(以sizeof(int)为单位)};void InitList(SqList &L) // 算法2.3{ // 操作结果:构造一个空的顺序线性表LL.elem=new ElemType[LIST_INIT_SIZE];if(!L.elem)exit(OVERFLOW); // 存储分配失败L.length=0; // 空表长度为0L.listsize=LIST_INIT_SIZE; // 初始存储容量}void DestroyList(SqList &L){ // 初始条件:顺序线性表L已存在。
数据结构实验一顺序表实验报告
数据结构实验一顺序表实验报告一、实验目的本次实验的主要目的是通过实现顺序表的基本操作,深入理解线性表的逻辑结构和存储结构,掌握顺序表的插入、删除、查找等操作的实现方法,提高编程能力和问题解决能力。
二、实验环境本次实验使用的编程语言为 C 语言,编程环境为 Visual Studio 2019。
三、实验原理顺序表是一种线性表的存储结构,它使用一组连续的存储单元依次存储线性表中的元素。
在顺序表中,元素的逻辑顺序与物理顺序是一致的。
顺序表的基本操作包括初始化、插入、删除、查找、遍历等。
在实现这些操作时,需要考虑顺序表的存储空间是否已满、插入和删除元素时元素的移动等问题。
四、实验内容(一)顺序表的定义```cdefine MAXSIZE 100 //定义顺序表的最大长度typedef struct {int dataMAXSIZE; //存储顺序表的元素int length; //顺序表的当前长度} SeqList;```(二)顺序表的初始化```cvoid InitList(SeqList L) {L>length = 0;}```(三)顺序表的插入操作```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++;return 1;}```(四)顺序表的删除操作```cint DeleteList(SeqList L, int i, int e) {if (L>length == 0) {//顺序表为空return 0;}if (i < 1 || i > L>length) {//删除位置不合法}e = L>datai 1; //取出被删除的元素for (int j = i; j < L>length; j++){//移动元素L>dataj 1 = L>dataj;}L>length;return 1;}```(五)顺序表的查找操作```cint SearchList(SeqList L, int e) {for (int i = 0; i < Llength; i++){if (Ldatai == e) {return i + 1;}}}```(六)顺序表的遍历操作```cvoid TraverseList(SeqList L) {for (int i = 0; i < Llength; i++){printf("%d ", Ldatai);}printf("\n");}```五、实验步骤1、打开 Visual Studio 2019,创建一个新的 C 语言项目。
数据结构实验一顺序表问题及实验报告模板 - Copy
else l = m + 1;
}
return NONE;
}
public static void main(String[] args) {
String[] word1 = {"dog", "cat", "rat", "pig", "fox", "eel"};
for (int t = 0; t < testcases.length; t++) {
String target = testcases[t];
System.out.println(target
+ " " + linearSearch1(word1, left1, right1, target) + " "
}
public static int linearSearch2(Comparable[] a, int left, int right, Comparable val)
{
for (int i = left; i <= right; i++)
{ int comp = pareTo(a[i]);
String target = testcases[t];
System.out.println(target
+ " " + linearSearch1(word1, left1, right1, target) + " "
+ linearSearch2(word2, left2, right2, target)
顺序表的查找插入与删除实验报告
顺序表的查找插入与删除实验报告顺序表的查找、插入与删除实验报告《数据结构》实验报告一学院:班级:姓名:程序名学号:日期:一、上机实验的问题和要求:顺序表的搜寻、填入与删掉。
设计算法,同时实现线性结构上的顺序表的产生以及元素的搜寻、填入与删掉。
具体内容同时实现建议:1.从键盘输入10个整数,产生顺序表,并输入结点值。
2.从键盘输入1个整数,在顺序表搜寻该结点的边线。
若找出,输入结点的边线;若打听不到,则显示“找不到”。
3.从键盘输入2个整数,一个则表示欲填入的边线i,另一个则表示欲填入的数值x,将x挂入在对应位置上,输出顺序表所有结点值,观察输出结果。
4.从键盘输入1个整数,表示欲删除结点的位置,输出顺序表所有结点值,观察输出结果。
二、源程序及注解:#include#include/*顺序表的定义:*/#include#definelistsize100/*表空间大小可根据实际需要而定,这里假设为100*/typedefintdatatype;/*datatype可以是任何相应的数据类型如int,float或char*/typedefstruct{datatypedata[listsize];/*向量data用作放置表中结点*/intlength;/*当前的表中长度*/}seqlist;voidmain(){seqlistl;inti,x;intn=10;/*欲建立的顺序表长度*/l.length=0;voidcreatelist(seqlist*l,intn);voidprintlist(seqlistl,intn);intlo catelist(seqlistl,datatypex);voidinsertlist(seqlist*l,datatypex,inti);voiddele telist(seqlist*l,inti);1createlist(&l,n);/*建立顺序表*/printlist(l,n);/*打印顺序表*/printf(\输入要查找的值:\scanf(\i=locatelist(l,x);/*顺序表查找*/printf(\输入要插入的位置:\scanf(\printf(\输入要插入的元素:\scanf(\insertlist(&l,x,i);/*顺序表插入*/printlist(l,n);/*打印顺序表*/printf(\输入要删除的位置:\scanf(\deletelist(&l,i);/*顺序表删除*/printlist(l,n);/*打印顺序表*/}/*顺序表的创建:*/voidcreatelist(seqlist*l,intn){inti;for(i=0;ilength=n;}/*顺序表的列印:*/voidprintlist(seqlistl,intn){inti;for(i=0;i/*顺序表的查找:*/intlocatelist(seqlistl,datatypex){inti=0;while(iif(i2/*顺序表的插入:*/voidinsertlist(seqlist*l,datatypex,inti){intj;if(i<1||i>l->length+1){printf(\插入位置非法\\n\exit(0);}if(l->length>=listsize){printf(\表空间溢出,退出运行\\n\exit(0);}for(j=l->length-1;j>=i-1;j--)l->data[j+1]=l->data[j];l->data[i-1]=x;l->length++;}/*顺序表的删除:*/voiddeletelist(seqlist*l,inti){intj;if(l->length==0){printf(\现行表为空,退出运行\\n\exit(0);}if(i<1||i>l->length){printf(\删除位置非法\\n\exit(0);}for(j=i;j<=l->length-1;j++)l->data[j-1]=l->data[j];l->length--;}3三、运行输出结果:四、调试和运行程序过程中产生的问题及采取的措施:4。
数据结构实验报告(C语言)顺序表__排序
int i,j,n,x,change; n=L->length; change=1; for(i=1;i<=n-1 && change;++i){
change=0; for(j=1;j<=n-i-1;++j)
if(L->r[j] > L->r[j+1]){ x=L->r[j]; L->r[j]=L->r[j+1]; L->r[j+1]=x; change=1;
void QuickSort(SqeList *L,int low,int high){ int mid; if(low<high){ mid=Partition(L,low,high); QuickSort(L,low,mid-1); QuickSort(L,mid+1,high); }
}
//直接选择排序
printf("\n7-直接选择排序结果为:\n"); SelectSort(&l); PrintList(&l); printf("\n"); printf("\n8-二路归并结果为:\n"); MergeSort(&l);
PrintList(&l); printf("\n"); } else printf("请输入大于 0 的值: "); return 0; }
} else{
MR->r[k]=R->r[j]; ++j; } ++k; } while(i<=mid) MR->r[k++]=R->r[i++]; while(j<=high) MR->r[k++]=R->r[j++]; }
c语言顺序表实验报告
c语言顺序表实验报告C语言顺序表实验报告引言:C语言是一种广泛应用于软件开发领域的编程语言,其灵活性和高效性备受开发者青睐。
在本次实验中,我们将探索C语言中的一种数据结构——顺序表。
顺序表是一种线性表的存储结构,通过数组实现,具有快速访问元素的特点。
本实验将通过实际操作,深入了解顺序表的创建、插入、删除和查找等基本操作,并对其性能进行评估。
实验目的:1. 掌握顺序表的创建和初始化方法;2. 熟悉顺序表的插入、删除和查找等基本操作;3. 评估顺序表在不同操作下的性能。
实验步骤:1. 创建顺序表在C语言中,可以通过定义一个结构体来表示顺序表,其中包含一个数组和一个记录当前元素个数的变量。
通过动态内存分配,可以根据需要调整顺序表的大小。
```ctypedef struct {int* data; // 数组指针int length; // 当前元素个数int capacity; // 顺序表的容量} SeqList;```在主函数中,可以通过调用malloc函数为顺序表分配内存空间,并对其进行初始化。
```cSeqList* createSeqList(int capacity) {SeqList* list = (SeqList*)malloc(sizeof(SeqList));list->data = (int*)malloc(capacity * sizeof(int));list->length = 0;list->capacity = capacity;return list;}```2. 插入元素顺序表的插入操作需要考虑插入位置的合法性以及顺序表是否已满的情况。
在插入元素时,需要将插入位置之后的元素后移一位,为新元素腾出空间。
```cvoid insert(SeqList* list, int position, int element) {if (position < 0 || position > list->length) {printf("插入位置非法!");return;}if (list->length >= list->capacity) {printf("顺序表已满,无法插入!");return;}for (int i = list->length - 1; i >= position; i--) {list->data[i + 1] = list->data[i];}list->data[position] = element;list->length++;}```3. 删除元素顺序表的删除操作需要考虑删除位置的合法性以及顺序表是否为空的情况。
数据结构-顺序表的查找实验报告
计算机科学与技术系实验报告专业名称计算机科学与技术课程名称《数据结构》项目名称顺序表查找班级学号姓名同组人员无实验日期一、实验目的与要求:(简述本次实验要求达到的目的,涉及到的相关知识点,实验的具体要求。
)(一)实验目的:应用顺序表来实现对数据的查找(二)实验要求:用顺序表实现对数据进行查找(三)实验环境:VC++6.0.二、实验内容#include<stdio.h>#include<stdlib.h>#include<malloc.h>#define ERROR 0#define OK 1#define INIT_SIZE 5 /*初始分配的顺序表长度*/#define INCREM 5 /*溢出时,顺序表长度的增量*/ typedef int ElemType; /*定义表元素的类型*/typedef struct Sqlist{ElemType *slist; /*存储空间的基地址*/int length; /*顺序表的当前长度*/int listsize; /*当前分配的存储空间*/}Sqlist;int InitList_sq(Sqlist *L);int CreateList_sq(Sqlist *L,int n);int ListInsert_sq(Sqlist *L,int i,ElemType e);int PrintList_sq(Sqlist *L);int ListDelete_sq(Sqlist *L,int i);int ListLocate(Sqlist *L,ElemType e);//初始化顺序表int InitList_sq(Sqlist *L){L->slist=(ElemType*)malloc(INIT_SIZE*sizeof(ElemType));if(!L->slist) return ERROR;L->length=0;L->listsize=INIT_SIZE;return OK;}/*InitList*///创建顺序表int CreateList_sq(Sqlist *L,int n){ElemType e;int i;for(i=0;i<n;i++){printf("input data %d",i+1);printf(": ");scanf("%d",&e);if(!ListInsert_sq(L,i+1,e))return ERROR;}return OK;}/*CreateList*//*输出顺序表中的元素*/int PrintList_sq(Sqlist *L){int i;for(i=1;i<=L->length;i++)printf("%-5d",L->slist[i-1]);printf("\n");return OK;}/*PrintList*///在顺序表中插入int ListInsert_sq(Sqlist *L,int i,ElemType e){ int k;if(i<1||i>L->length+1)return ERROR;if(L->length>=L->listsize){L->slist=(ElemType*)realloc(L->slist,(INIT_SIZE+INCREM)*sizeof(ElemType));if(!L->slist)return ERROR;L->listsize+=INCREM;}for(k=L->length-1;k>=i-1;k--){L->slist[k+1]=k;}L->slist[i-1]=e;L->length++;return OK;}/*ListInsert*//*在顺序表中删除第i个元素*/int ListDelete_sq(Sqlist *L,int i){int j;if(L->length<0){printf("顺序表为空!\n");return ERROR;}else if(i < 0 || (i > L->length)){printf("i 的参数出错!\n");return ERROR;}else{for(j = i; j <= L->length; j ++) L->slist[j-1] = L->slist[j];L->length--;return OK;}}/*在顺序表中查找指定值元素,返回其序号*/int ListLocate(Sqlist *L,ElemType e){int i, z = 0;for(i = 0; i < L->length; i ++){if(L->slist[i] == e){printf("查找的元素%d 在第%d 位置\n", e, i+1);z = 1;//return OK;}}printf("没有查找到相应的数\n");return ERROR;}//主函数int main(){Sqlist sl;int n, i;ElemType e;printf("请创建表,输入顺序表的元素个数:"); /*输入顺序表的元素个数*/scanf("%d",&n);if(n>0){printf("\n1-Create Sqlist:\n");InitList_sq(&sl);CreateList_sq(&sl,n);printf("\n2-Print Sqlist:\n");PrintList_sq(&sl);system("cls");}elseprintf("ERROR");printf("---------------------------请选择操作方式--------------------------\n");printf("\t 1: 查找\t 2:删除\t 3: 输出表\t 0: 退出\n 输入操作数:");scanf("%d", &n);while(n){printf("\n链表元素:\n");PrintList_sq(&sl);if(n == 1){printf("\n请输入想要查找的元素:");scanf("%d", &e);ListLocate(&sl,e);}if(n == 2){printf("\n请输入想要删除元素的位置:");scanf("%d", &i);ListDelete_sq(&sl, i);}if(n == 3){printf("\n链表元素:\n");PrintList_sq(&sl);}printf("\t---------------------------请选择操作方式--------------------------");printf("\t 1: 查找\t 2:删除\t 0: 退出\n 输入操作数:");scanf("%d", &n);}return 0;}三、实验分析与小结(实验过程中的问题分析、产生的原因以及解决方法;实验结果分析;有待优化思路)(一)实验结果截图.(二)总结通过顺序表数组元素的特点,我们可以对数据实现顺序查找。
数据结构c语言实验报告
数据结构c语言实验报告数据结构C语言实验报告引言:数据结构是计算机科学中的重要概念,它涉及存储和组织数据的方式。
在本次实验中,我们将使用C语言来实现一些常见的数据结构,并对其进行测试和分析。
通过这些实验,我们将深入理解数据结构的原理和应用。
一、线性表线性表是最基本的数据结构之一,它由一系列元素组成,这些元素按照线性的顺序排列。
我们将使用C语言实现线性表,并测试其插入、删除和查找功能。
通过实验,我们可以比较不同操作的时间复杂度,并分析其优缺点。
二、栈和队列栈和队列是常用的数据结构,它们都是线性表的变种。
栈是一种后进先出(LIFO)的数据结构,而队列是一种先进先出(FIFO)的数据结构。
我们将使用C语言实现栈和队列,并测试它们的入栈、出栈、入队和出队操作。
通过实验,我们可以比较不同数据结构在特定场景下的应用效果。
三、链表链表是一种常见的数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的指针。
链表可以分为单向链表、双向链表和循环链表等不同类型。
我们将使用C语言实现链表,并测试其插入、删除和查找功能。
通过实验,我们可以比较链表和线性表在不同操作上的性能差异。
四、树树是一种非线性的数据结构,它由一系列节点组成,每个节点可以有多个子节点。
树的应用非常广泛,例如文件系统、数据库索引等。
我们将使用C语言实现二叉树,并测试其插入、删除和查找功能。
通过实验,我们可以比较不同树结构在不同操作上的时间复杂度,并分析其适用场景。
五、图图是一种复杂的数据结构,它由一系列节点和边组成,节点表示实体,边表示实体之间的关系。
图的应用包括社交网络、路线规划等。
我们将使用C语言实现图,并测试其遍历和最短路径算法。
通过实验,我们可以比较不同图算法的时间复杂度,并分析其在实际应用中的效果。
结论:通过本次实验,我们深入学习了数据结构的原理和应用。
我们使用C语言实现了线性表、栈、队列、链表、树和图等常见的数据结构,并测试了它们的各种操作。
数据结构实验报告顺序表1
数据结构实验报告顺序表1一、实验目的本次实验的主要目的是深入理解和掌握顺序表这种数据结构的基本概念、存储方式和操作方法,并通过实际编程实现,提高对数据结构的实际应用能力和编程技能。
二、实验环境本次实验使用的编程语言为C++,开发工具为Visual Studio 2019。
三、顺序表的基本概念顺序表是用一组地址连续的存储单元依次存储线性表中的数据元素。
在顺序表中,逻辑上相邻的元素在物理位置上也相邻。
顺序表可以随机访问表中的任意元素,但插入和删除操作可能需要移动大量元素,效率较低。
四、顺序表的存储结构在 C++中,可以使用数组来实现顺序表。
以下是一个简单的顺序表存储结构的定义:```cppconst int MAX_SIZE = 100; //定义顺序表的最大容量class SeqList {private:int dataMAX_SIZE; //存储数据元素的数组int length; //顺序表的当前长度public:SeqList(){ length = 0; }//构造函数,初始化长度为 0//其他操作函数的声明int GetLength();bool IsEmpty();bool IsFull();int GetElement(int position);int LocateElement(int element);void InsertElement(int position, int element);void DeleteElement(int position);void PrintList();};```五、顺序表的基本操作实现1、获取顺序表长度```cppint SeqList::GetLength(){return length;}```2、判断顺序表是否为空```cppbool SeqList::IsEmpty(){return length == 0;}```3、判断顺序表是否已满```cppbool SeqList::IsFull(){return length == MAX_SIZE;}```4、获取指定位置的元素```cppint SeqList::GetElement(int position) {if (position < 1 || position > length) {std::cout <<"位置错误!"<< std::endl; return -1;}return dataposition 1;}```5、查找指定元素在顺序表中的位置```cppint SeqList::LocateElement(int element) {for (int i = 0; i < length; i++){if (datai == element) {return i + 1;}}return -1; //未找到返回-1}```6、在指定位置插入元素```cppvoid SeqList::InsertElement(int position, int element) {if (IsFull()){std::cout <<"顺序表已满,无法插入!"<< std::endl; return;}if (position < 1 || position > length + 1) {std::cout <<"位置错误!"<< std::endl;return;}for (int i = length; i >= position; i) {datai = datai 1;}dataposition 1 = element;length++;}```7、删除指定位置的元素```cppvoid SeqList::DeleteElement(int position) {if (IsEmpty()){std::cout <<"顺序表为空,无法删除!"<< std::endl; return;}if (position < 1 || position > length) {std::cout <<"位置错误!"<< std::endl;return;}for (int i = position; i < length; i++){datai 1 = datai;}length;}```8、打印顺序表中的所有元素```cppvoid SeqList::PrintList(){for (int i = 0; i < length; i++){std::cout << datai <<"";}std::cout << std::endl;}```六、实验结果与分析1、对顺序表进行初始化,创建一个空的顺序表。
数据结构实验报告实验1
数据结构实验报告实验1一、实验目的本次实验的主要目的是通过实际操作和编程实现,深入理解和掌握常见的数据结构,如线性表、栈、队列等,并能够运用所学知识解决实际问题。
二、实验环境本次实验使用的编程环境为Visual Studio 2019,编程语言为C++。
三、实验内容与步骤(一)线性表的实现与操作1、顺序表的实现定义一个固定大小的数组来存储线性表的元素。
实现插入、删除、查找等基本操作。
2、链表的实现定义链表节点结构体,包含数据域和指针域。
实现链表的创建、插入、删除、遍历等操作。
(二)栈的实现与应用1、栈的实现使用数组或链表实现栈的数据结构。
实现入栈、出栈、栈顶元素获取等操作。
2、栈的应用利用栈实现表达式求值。
(三)队列的实现与应用1、队列的实现使用循环数组或链表实现队列。
实现入队、出队、队头元素获取等操作。
2、队列的应用模拟银行排队系统。
四、实验结果与分析(一)线性表1、顺序表插入操作:在指定位置插入元素时,需要移动后续元素,时间复杂度为 O(n)。
删除操作:删除指定位置的元素时,同样需要移动后续元素,时间复杂度为 O(n)。
查找操作:可以直接通过索引访问元素,时间复杂度为 O(1)。
2、链表插入操作:只需修改指针,时间复杂度为 O(1)。
删除操作:同样只需修改指针,时间复杂度为 O(1)。
查找操作:需要遍历链表,时间复杂度为 O(n)。
(二)栈1、表达式求值能够正确计算简单的四则运算表达式,如 2 + 3 4。
对于复杂表达式,如(2 + 3) 4,也能得到正确结果。
(三)队列1、银行排队系统模拟了客户的到达、排队和服务过程,能够反映出队列的先进先出特性。
五、实验中遇到的问题及解决方法(一)线性表1、顺序表的空间浪费问题问题描述:当预先分配的空间过大而实际使用较少时,会造成空间浪费。
解决方法:可以采用动态分配空间的方式,根据实际插入的元素数量来调整存储空间。
2、链表的指针操作错误问题描述:在链表的插入和删除操作中,容易出现指针指向错误,导致程序崩溃。
数据结构实验报告顺序表
数据结构实验报告顺序表数据结构实验报告:顺序表一、引言数据结构是计算机科学的重要基础,它研究数据的组织方式和操作方法。
顺序表是一种常见的数据结构,它以数组的形式存储数据元素,具有随机访问和插入删除方便的特点。
本实验旨在深入理解顺序表的实现原理和操作方法,并通过实验验证其性能。
二、实验目的1. 掌握顺序表的基本概念和实现原理;2. 熟悉顺序表的插入、删除、查找等操作;3. 分析顺序表的时间复杂度,并进行性能测试。
三、实验过程1. 顺序表的定义和初始化顺序表是一种线性表,它以一组连续的存储单元来存储数据元素。
在实验中,我们使用数组来实现顺序表。
首先,定义一个结构体来表示顺序表,包括数据元素和当前长度等信息。
然后,通过动态分配内存来初始化顺序表。
2. 插入元素顺序表的插入操作是将一个新元素插入到指定位置,同时移动后面的元素。
在实验中,我们可以通过循环将后面的元素依次向后移动,然后将新元素放入指定位置。
3. 删除元素顺序表的删除操作是将指定位置的元素删除,并将后面的元素依次向前移动。
在实验中,我们可以通过循环将后面的元素依次向前移动,然后将最后一个元素置为空。
4. 查找元素顺序表的查找操作是根据指定的值查找元素所在的位置。
在实验中,我们可以通过循环遍历顺序表,逐个比较元素的值,找到匹配的位置。
五、实验结果与分析在实验中,我们通过插入、删除、查找等操作对顺序表进行了测试,并记录了操作所需的时间。
通过分析实验结果,我们可以得出以下结论:1. 顺序表的插入操作的时间复杂度为O(n),其中n为元素的个数。
因为插入操作需要移动后面的元素,所以时间复杂度与元素个数成正比。
2. 顺序表的删除操作的时间复杂度也为O(n),与插入操作相同,需要移动后面的元素。
3. 顺序表的查找操作的时间复杂度为O(n),需要逐个比较元素的值。
六、结论通过本次实验,我们深入理解了顺序表的实现原理和操作方法。
顺序表以数组的形式存储数据,具有随机访问和插入删除方便的特点。
数据结构顺序表操作实验报告
实验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.实验环境:●操作系统:Windows 10●编程语言:C/C++●开发工具:Visual Studio Code3.实验内容:3.1 初始化顺序表●定义顺序表结构体●实现创建顺序表的函数●实现销毁顺序表的函数3.2 插入元素●实现在指定位置插入元素的函数●实现在表尾插入元素的函数3.3 删除元素●实现删除指定位置元素的函数●实现删除指定值元素的函数3.4 查找元素●实现按值查找元素的函数●实现按位置查找元素的函数3.5 修改元素●实现修改指定位置元素的函数3.6 打印顺序表●实现打印顺序表中所有元素的函数4.实验步骤:4.1 初始化顺序表●定义顺序表结构体,并分配内存空间●初始化顺序表中的数据和长度4.2 插入元素●调用插入元素函数,在指定位置或表尾插入元素4.3 删除元素●调用删除元素函数,删除指定位置或指定值的元素4.4 查找元素●调用查找元素函数,按值或位置查找元素4.5 修改元素●调用修改元素函数,修改指定位置的元素4.6 打印顺序表●调用打印顺序表函数,输出顺序表中的所有元素5.实验结果:经过测试,顺序表的基本操作均能正确执行。
插入元素、删除元素、查找元素、修改元素和打印顺序表等功能都能正常运行。
6.实验总结:本实验通过实现顺序表的基本操作,巩固了对数据结构顺序表的理论知识,并加深了对算法的理解和应用能力。
顺序表是一种简单、易于实现的数据结构,适用于元素数量变化较少的情况下。
7.附件:无8.法律名词及注释:●顺序表:一种基本的线性数据结构,数据元素按照其逻辑位置依次存储在一片连续的存储空间中。
●初始化:为数据结构分配内存空间并进行初始化,使其具备基本的数据存储能力。
●插入元素:将一个新元素插入到已有元素的合适位置,使得数据结构保持有序或符合特定要求。
数据结构实验一顺序表实验报告
数据结构实验一顺序表实验报告数据结构实验一顺序表实验报告一、实验目的顺序表是一种基本的数据结构,本次实验的目的是通过实现顺序表的基本操作,加深对顺序表的理解,并掌握顺序表的插入、删除、查找等操作的实现方法。
二、实验内容1. 实现顺序表的创建和初始化操作。
2. 实现顺序表的插入操作。
3. 实现顺序表的删除操作。
4. 实现顺序表的查找操作。
5. 实现顺序表的输出操作。
三、实验步骤1. 创建顺序表的数据结构,包括数据存储数组和记录当前元素个数的变量。
2. 初始化顺序表,将当前元素个数置为0。
3. 实现顺序表的插入操作:- 判断顺序表是否已满,若已满则输出错误信息。
- 将插入位置之后的元素依次后移一位。
- 将要插入的元素放入插入位置。
- 当前元素个数加一。
4. 实现顺序表的删除操作:- 判断顺序表是否为空,若为空则输出错误信息。
- 判断要删除的位置是否合法,若不合法则输出错误信息。
- 将删除位置之后的元素依次前移一位。
- 当前元素个数减一。
5. 实现顺序表的查找操作:- 遍历顺序表,逐个比较元素值与目标值是否相等。
- 若找到目标值,则返回该元素的位置。
- 若遍历完整个顺序表仍未找到目标值,则返回错误信息。
6. 实现顺序表的输出操作:- 遍历顺序表,逐个输出元素值。
四、实验结果经过实验,顺序表的各项操作均能正确实现。
在插入操作中,可以正确将元素插入到指定位置,并将插入位置之后的元素依次后移。
在删除操作中,可以正确删除指定位置的元素,并将删除位置之后的元素依次前移。
在查找操作中,可以正确返回目标值的位置。
在输出操作中,可以正确输出顺序表中的所有元素。
五、实验总结通过本次实验,我深入了解了顺序表的原理和基本操作,并通过实际编程实现了顺序表的各项功能。
在实验过程中,我遇到了一些问题,如如何判断顺序表是否已满或为空,如何处理插入和删除位置的合法性等。
通过查阅资料和与同学讨论,我解决了这些问题,并对顺序表的操作有了更深入的理解。
数据结构实验报告顺序表
数据结构实验报告顺序表数据结构实验报告:顺序表摘要:顺序表是一种基本的数据结构,它通过一组连续的存储单元来存储线性表中的数据元素。
在本次实验中,我们将通过实验来探索顺序表的基本操作和特性,包括插入、删除、查找等操作,以及顺序表的优缺点和应用场景。
一、实验目的1. 理解顺序表的概念和特点;2. 掌握顺序表的基本操作;3. 了解顺序表的优缺点及应用场景。
二、实验内容1. 实现顺序表的初始化操作;2. 实现顺序表的插入操作;3. 实现顺序表的删除操作;4. 实现顺序表的查找操作;5. 对比顺序表和链表的优缺点;6. 分析顺序表的应用场景。
三、实验步骤与结果1. 顺序表的初始化操作在实验中,我们首先定义了顺序表的结构体,并实现了初始化操作,即分配一定大小的存储空间,并将表的长度设为0,表示表中暂时没有元素。
2. 顺序表的插入操作接下来,我们实现了顺序表的插入操作。
通过将插入位置后的元素依次向后移动一位,然后将新元素插入到指定位置,来实现插入操作。
我们测试了在表中插入新元素的情况,并验证了插入操作的正确性。
3. 顺序表的删除操作然后,我们实现了顺序表的删除操作。
通过将删除位置后的元素依次向前移动一位,来实现删除操作。
我们测试了在表中删除元素的情况,并验证了删除操作的正确性。
4. 顺序表的查找操作最后,我们实现了顺序表的查找操作。
通过遍历表中的元素,来查找指定元素的位置。
我们测试了在表中查找元素的情况,并验证了查找操作的正确性。
四、实验总结通过本次实验,我们对顺序表的基本操作有了更深入的了解。
顺序表的插入、删除、查找等操作都是基于数组的操作,因此在插入和删除元素时,需要移动大量的元素,效率较低。
但是顺序表的优点是可以随机访问,查找效率较高。
在实际应用中,顺序表适合于元素数量不变或变化不大的情况,且需要频繁查找元素的场景。
综上所述,顺序表是一种基本的数据结构,我们通过本次实验对其有了更深入的了解,掌握了顺序表的基本操作,并了解了其优缺点及应用场景。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
//L->slist[i-1]=e; //L->length++; return OK; }/*ListInsert*/
/*在顺序表中删除第 i 个元素*/ int ListDelete_sq(Sqlist *L,int i)
return ERROR; } return OK; }/*CreateList*/ /*输出顺序表中的元素*/ int PrintList_sq(Sqlist *L){ int i; for(i=1;i<=L->length;i++)
printf("%5d",L->slist[i-1]); return OK; }/*PrintList*/
计算机科学与技术系
实验报告
专业名称 课程名称 项目名称 班级 学号 姓名 实验日期
计算机科学与技术 数据结构与算法 顺序表查找
格式要求
实验报告注意格式规范,要求在 word 中编写,文中不要有空行,统一使 用 A4 页面。
页边距:上 2.5cm、下 2cm、左 2.5cm、右 2cm。 标题:宋体、四号字、加粗、1.5 倍行距。 正文:宋体、小四号字、1.2 倍行距。
//创建顺序表 int CreateList_sq(Sqlist *L,int n){
ElemType e; int i; for(i=0;i<n;i++){
printf("input data %d",i+1); printf(": "); scanf("%d",&e); if(!ListInsert_sq(L,i+1,e))
{ int j; if (L->listsize<0) { printf ( "error"); return (0);} else if ( (i<1)||(i >L->length ) ) { printf ("error"); return (0); } else { for( j=i; j<=L->length+1; j++) L->slist[ j-1] =L->slist[ j]; L->length-- ; return (1); }
typedef int ElemType; /*定义表元素的类型*/
typedef struct Sqlist{
ElemType *slist;
/*存储空间的基地址*/
int length;
/*顺序表的当前长度*/
int listsize;
/*当前分配的存储空间*/
}Sqlist;
int InitList_sq(Sqlist *L);
InitList_sq(&sl); CreateList_sq(&sl,n); printf("输入要插入的值得序号和值:"); //顺序表的插入输出 scanf("%d %d",&i,&e); //输入要插入值元素的序号和要插入的值 ListInsert_sq(&sl,i,e); printf("输出插入后的顺序表:"); PrintList_sq(&sl); printf("\n"); //顺序表的删除输出 printf("输入要删除的值元素的序号:"); scanf("%d",&i ); //输入要删除的值元素的序号 ListDelete_sq(&sl,i); printf("输出删除后的顺序表:\n"); PrintList_sq(&sl); printf("\n"); //顺序表的查找输出 printf("输入要顺序查找的值:"); scanf("%d",&e );
} /*在顺序表中查找指定值元素,返回其序号*/ void ListLocate(Sqlist *L,ElemType e){ int i,z=0; for(i=0;i<L->length;i++) if (L->slist[i]==e) {printf("该数值所在表中序号为:第%d 位",i+1); z=1;} if(z==0) printf("表中没有该值\n"); }
//初始化顺序表 int InitList_sq(Sqlist *L){
L->slist=(ElemType*)malloc(INIT_SIZE*sizeof(ElemType)); if(!L->slist) return ERROR; L->length=0; L->listsize=INIT_SIZE; return OK; }/*InitList*/
二、实验方法:(代码)
include "stdafx.h"
#include<stdio.h>
#include<malloc.h>
#define ERROR 0
#define OK 1
#define INIT_SIZE 5 /*初始分配的顺序表长度*/
#define INCREM 5
/*溢出时,顺序表长度的增量*/
一、实验目的与要求:
(一)实验目的
1、掌握线性表中元素的前驱、后续的概念。 2、掌握顺序表与链表的建立、插入元素、删除时间复杂度进行分析。 5、理解顺序表数据结构的特点(优缺点)。
(二)实验要求
1.将实验中所要求的每个功能用一个函数实现。 2.每个输入前要有输入提示,每个输出数据都要求有内容说明(如:280 和 100 的和是: 380。)。 3.函数名称和变量名称等用英文或英文简写(每个单词第一个字母大写)形式说明。
//在顺序表中插入 int ListInsert_sq(Sqlist *L,int i,ElemType e) {
int k; if(i<1||i>L->length+1)
return ERROR; else {
for(k=L->length-1;k>=i-1;k--) L->slist[k+1]=L->slist[k];
//主函数 int main(){
Sqlist sl; int n,i,e; printf("******** 欢迎来到该界面 ******** \n"); printf("please input n:"); /*输入顺序表的元素个数*/
scanf("%d",&n); if(n>0) { printf("\n1-Create Sqlist:\n");
int CreateList_sq(Sqlist *L,int n);
int ListInsert_sq(Sqlist *L,int i,ElemType e);
int PrintList_sq(Sqlist *L);
int ListDelete_sq(Sqlist *L,int i);
void ListLocate(Sqlist *L,ElemType e);
ListLocate(&sl, e); getchar(); }else printf("ERROR"); return 0;
}
三、实验分析与小结
得分(百分制)