顺序表基本操作的实现
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.删除操作删除操作是指将顺序表中指定位置的元素删除。
实验一 顺序表操作实现
实验一顺序表操作实现实验一顺序表操作实现实验日期:2022年3月6日实验目的及要求1.掌握线性表的基本操作和顺序存储的实现;2.以线性表的各种操作(建立、插入、删除、遍历等)的实现为重点;3.掌握线性表的顺序存储结构的定义和基本操作的实现;4.加深本函数指针的使用(尤其是C的应用)。
实验内容已知程序文件seqlist CPP给出了学生身高信息序列表的类型定义和基本运算函数定义。
(1)顺序表类型定义typedefstruct{intxh;/*学号*/floatsg;/*身高*/intsex;/*性别:0为男性,1为女性*/}数据类型;typedefstruct{datatypedata[max];/*存放顺序表元素的数组*/intlast;/*表示data中实际存放元素个数*/}seqlist;(2)基本操作功能原型voidinitlist(seqlist*lp);/*置一个空表*/voidcreatelist(seqlist*lp);/*创建学生订单表*/voidsort_xh(seqlist*lp);/*按学生编号排序*/void error(char*s)/*用户定义的错误处理函数*/void pntlist (seqlist*LP)/*输出学生表*/voidsave(seqlist*lp,charstrname[]);/*保存学生顺序表到指定文件*/任务一创建程序文件seqlist.cpp,其代码如下所示,理解顺序表类型seqlist和基本运算函数后回答下列问题。
/*seqlist。
CPP程序文件代码*/#include#include#definemax50typedef{intxh;/*学号*/floatsg;/*身高*/intsex;/*性别:0为男性,1为女性*/}数据类型;typedefstruct{datatypedata[max];/*存放顺序表元素的数组*/intlast;/*表示data中实际存放元素个数*/}seqlist;voidinitlist(seqlist*lp);/*摆一张空桌子*/voidcreatelist(seqlist*lp);/*建一个学生顺序表*/voidsort_xh(seqlist*lp);/*按学号排序*/voiderror(char*s);/*自定义错误处理函数*/voidpntlist(seqlist*lp);/*输出学生表*/voidsave(seqlist*lp,charstrname[]);/*将学生序列表保存到指定文件*//*置一个空表*/voidinitlist(seqlist*lp){lp->last=0;}/*建一个学生顺序表*/voidcreatelist(seqlist*lp){file*fp;intxh,sex;floatsg;if((fp=fopen(\{error(\}而(!feof(fp)){fscanf(fp,\lp->data[lp->last].xh=xh;lp->data[lp->last].sg=sg;lp->data[lp->last].sex=sex;lp->last++;}fclose(fp);}/*按学生人数递增*/voidsort_xh(seqlist*lp){inti,j,k;datatypest;对于(i=0;ilast-1;i++){k=i;for(j=i+1;jlast;j++)if(lp->data[j].xhdata[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(\exit(1);/*返回os,该函数定义在stdlib.h中*/}/*输出学生序列表*/void pntlist(seqlist*LP){inti;for(i=0;ilast;i++)printf(\}/*保存学生顺序表到指定文件*/voidsave(seqlist*lp,charstrname[]){file*fp;inti;如果((fp=fopen(strname,\{error(\}for(i=0;ilast;i++){fprintf(fp,\}fclose(fp);}请回答以下问题:(1)由顺序表类型定义可知,该顺序表类型名为seqlist,其中存放的元素为学生信息,学生信息定义的类型名为datatype,包含xh、sg、sex三个成员(写出成员变量名),学生信息存储于data数组,顺序表的表长变量为max。
实现顺序表的各种基本运算的算法
实现顺序表的各种基本运算的算法1. 初始化顺序表算法实现:初始化操作就是将顺序表中所有元素的值设置为默认值,对于数值类型,可以将其设置为0,对于字符类型,可以将其设置为空格字符。
初始化的时间复杂度为O(n),其中n为顺序表的长度。
2. 插入操作算法实现:顺序表的插入操作就是在指定位置上插入一个元素,需要将该位置后面的元素全部后移,在指定位置上插入新元素。
若顺序表已满,则需要进行扩容操作,将顺序表长度扩大一倍或者按一定的比例扩大。
插入操作的时间复杂度为O(n),其中n为顺序表长度。
3. 删除操作算法实现:顺序表的删除操作需要将指定位置上的元素删除,并将该位置后面的元素全部前移。
删除操作后,如果顺序表的实际长度小于等于其总长度的1/4,则需要进行缩容操作,将顺序表长度缩小一倍或者按一定的比例缩小。
删除操作的时间复杂度为O(n),其中n为顺序表长度。
4. 修改操作算法实现:顺序表的修改操作就是将指定位置上的元素赋予新的值。
修改操作的时间复杂度为O(1)。
5. 查找操作算法实现:顺序表的查找操作就是在顺序表中找到指定位置的元素,并返回其值。
查找操作的时间复杂度为O(1)。
6. 遍历操作算法实现:顺序表的遍历操作就是依次访问顺序表中的每个元素,遍历操作的时间复杂度为O(n),其中n为顺序表的长度。
7. 合并操作算法实现:顺序表的合并操作就是将两个顺序表合并成一个新的顺序表,新的顺序表的长度为两个顺序表的长度之和。
合并操作的时间复杂度为O(n),其中n为两个顺序表的长度之和。
总结:顺序表是一种简单而高效的数据结构,其基本运算包括初始化、插入、删除、修改、查找、遍历和合并等操作。
其中,插入、删除、遍历和合并操作的时间复杂度比较高,需要进行相应的优化处理。
同时,在实际应用中,还需要注意顺序表的扩容和缩容操作,避免造成资源浪费或者性能下降。
实验一顺序表的基本操作实验报告
元素之后的所有数据都前移一个位置,最将线性表长减1。
3.顺序表查找操作的基本步骤:要在顺序表中查找一个给定值的数据元素则可以采用顺序查找的方法,从表中第 1 个数据元素开始依次将值与给定值进行比较,若相等则返回该数据元素在顺序表中的位置,否则返回0 值。
线性表的动态分配顺序存储结构—C语言实现#define MaxSize 50//存储空间的分配量Typedef char ElemType;Typedef struct{ElemType data[MaxSize];int length; //表长度(表中有多少个元素)}SqList;动态创建一个空顺序表的算法:void InitList(SqList *&L) //初始化线性表{L=(SqList *)malloc(sizeof(SqList)); //分配存放线性表的空间L->length=0; //置空线性表长度为0}线性表的插入:status Sqlist_insert(Sqlist &L,int i,Elemtype x)/*在顺序表L中第i个元素前插入新元素x*/{ if (i<1||i>L.length+1) return ERROR; /*插入位置不正确则出错*/if (L.length>=MAXLEN)return OVERFLOW;/*顺序表L中已放满元素,再做插入操作则溢出*/for(j=L.length-1;j>=i-1;j--)L.elem[j+1]=L.elem[j]; /*将第i个元素及后续元素位置向后移一位*/L.elem[i-1]=x; /*在第i个元素位置处插入新元素x*/L.length++; /*顺序表L的长度加1*/return OK;}线性表的删除:status Sqlist_delete(Sqlist &L,int i,Elemtype &e)/*在顺序表L中删除第i个元素*{ if (i<1||i>L.length) return ERROR; /*删除位置不正确则出错*/for(j=i;j<=L.length-1;j++)L.elem[j-1]=L.elem[j]; /*将第i+1个元素及后继元素位置向前移一位*/L.length--;/*顺序表L的长度减1*/return OK;}线性表元素的查找:int LocateElem(SqList *L, ElemType e) //按元素值查找{int i=0;while (i<L->length && L->data[i]!=e)i++; //查找元素eif (i>=L->length) //未找到时返回0return 0;elsereturn i+1; //找到后返回其逻辑序号}输出线性表:void DispList(SqList *L) //输出线性表{int i;if (ListEmpty(L)) return;for (i=0;i<L->length;i++)printf("%c ",L->data[i]);printf("\n");}输出线性表第i个元素的值:bool GetElem(SqList *L,int i,ElemType &e)//求线性表中某个数据元素值{if (i<1 || i>L->length)return false; //参数错误时返回falsee=L->data[i-1]; //取元素值return true; //成功找到元素时返回true}代码:#include <stdio.h>#include <malloc.h>#define MaxSize 50typedef char ElemType;typedef struct{ElemType data[MaxSize];int length;} SqList;void InitList(SqList *&L);void DestroyList(SqList *L);bool ListEmpty(SqList *L);int ListLength(SqList *L);void DispList(SqList *L);bool GetElem(SqList *L,int i,ElemType &e);int LocateElem(SqList *L, ElemType e);bool ListInsert(SqList *&L,int i,ElemType e);bool ListDelete(SqList *&L,int i,ElemType &e);void InitList(SqList *&L)//初始化线性表{L=(SqList *)malloc(sizeof(SqList));//分配存放线性表的空间L->length=0;//置空线性表长度为0 }void DestroyList(SqList *L)//销毁线性表{free(L);}bool ListEmpty(SqList *L)//判线性表是否为空表{return(L->length==0);}int ListLength(SqList *L)//求线性表的长度{return(L->length);}void DispList(SqList *L)//输出线性表{int i;if (ListEmpty(L)) return;for (i=0;i<L->length;i++)printf("%c ",L->data[i]);printf("\n");}bool GetElem(SqList *L,int i,ElemType &e)//求线性表中某个数据元素值{if (i<1 || i>L->length)return false;//参数错误时返回falsee=L->data[i-1];//取元素值return true;//成功找到元素时返回true}int LocateElem(SqList *L, ElemType e)//按元素值查找{int i=0;while (i<L->length && L->data[i]!=e)i++;//查找元素eif (i>=L->length)//未找到时返回0return 0;elsereturn i+1;//找到后返回其逻辑序号}bool ListInsert(SqList *&L,int i,ElemType e)//插入数据元素{int j;if (i<1 || i>L->length+1)return false;//参数错误时返回falsei--;//将顺序表逻辑序号转化为物理序号for (j=L->length;j>i;j--)//将data[i]及后面元素后移一个位置L->data[j]=L->data[j-1];L->data[i]=e;//插入元素eL->length++;//顺序表长度增1return true;//成功插入返回true}bool ListDelete(SqList *&L,int i,ElemType &e)//删除数据元素{int j;if (i<1 || i>L->length)//参数错误时返回falsereturn false;i--;//将顺序表逻辑序号转化为物理序号e=L->data[i];for (j=i;j<L->length-1;j++)//将data[i]之后的元素前移一个位置L->data[j]=L->data[j+1];L->length--;//顺序表长度减1return true;//成功删除返回true}void main(){SqList *L;ElemType e;printf("顺序表的基本运算如下:\n");printf(" (1)初始化顺序表L\n");InitList(L);printf(" (2)依次采用尾插法插入a,b,c,d,e元素\n");ListInsert(L,1,'a');ListInsert(L,2,'b');ListInsert(L,3,'c');ListInsert(L,4,'d');ListInsert(L,5,'e');printf(" (3)输出顺序表L:");DispList(L);printf(" (4)顺序表L长度=%d\n",ListLength(L));printf(" (5)顺序表L为%s\n",(ListEmpty(L)?"空":"非空"));GetElem(L,3,e);printf(" (6)顺序表L的第3个元素=%c\n",e);实验结果:心得体会:通过本次实验,实现了数据结构在程序设计上的作用,了解了数据结构语言,加深了对c语言的认识掌并掌握了线性表的顺序存储结构的表示和实现方法,掌握顺序表基本操作的算法实现,同时了解了顺序表的应用。
顺序表的基本操作和实现实验报告(一)
顺序表的基本操作和实现实验报告(一)顺序表的基本操作和实现实验报告1. 引言顺序表是计算机科学中一种常用的数据结构,用于存储一组元素并支持快速的随机访问。
本实验旨在探究顺序表的基本操作和实现方法。
2. 实验目的•理解顺序表的概念和特性。
•学习顺序表的基本操作,包括插入、删除、查找和修改等。
•掌握顺序表的实现方法,包括静态分配和动态分配两种方式。
•培养对数据结构的抽象思维和编程能力。
3. 实验内容1.了解顺序表的定义,及其与数组的关系。
2.掌握插入操作的实现方法,包括在表头、表中和表尾插入元素。
3.掌握删除操作的实现方法,包括按索引删除和按值删除。
4.掌握查找操作的实现方法,包括按索引查找和按值查找。
5.掌握修改操作的实现方法,包括按索引修改和按值修改。
6.实现顺序表的静态分配和动态分配两种方式。
4. 实验步骤1.定义顺序表的结构体,包括数据存储区和长度属性。
2.实现插入操作,根据需要选择插入位置和移动元素。
3.实现删除操作,根据需要选择删除方式和更新长度。
4.实现查找操作,根据需要选择查找方式和返回结果。
5.实现修改操作,根据需要选择修改方式和更新元素。
6.实现顺序表的静态分配和动态分配方法。
5. 实验结果经过多次实验和测试,顺序表的基本操作都能够正确实现。
在插入操作中,能够将元素正确插入指定位置,并保持顺序表的有序性。
在删除操作中,能够按需删除指定位置或值的元素,并正确更新顺序表的长度。
在查找操作中,能够根据索引或值查找到对应的元素,并返回正确的结果。
在修改操作中,能够按需修改指定位置或值的元素,并更新顺序表的内容。
6. 实验总结本实验通过对顺序表的基本操作和实现方法的学习和实践,进一步巩固了对数据结构的理解和编程能力的培养。
顺序表作为一种常用的数据结构,对于解决实际问题具有重要的作用。
通过本次实验,我对顺序表的插入、删除、查找和修改等操作有了更深入的了解,并学会了如何实现这些操作。
通过本次实验,我还学会了顺序表的静态分配和动态分配方法,了解了它们的区别和适用场景。
C语言实现顺序表的基本操作(从键盘输入生成线性表,读txt文件生成线性表和数组生成线性表-。。。
C语⾔实现顺序表的基本操作(从键盘输⼊⽣成线性表,读txt⽂件⽣成线性表和数组⽣成线性表-。
经过三天的时间终于把顺序表的操作实现搞定了。
(主要是在测试部分停留了太长时间)1. 线性表顺序存储的概念:指的是在内存中⽤⼀段地址连续的存储单元依次存储线性表中的元素。
2. 采⽤的实现⽅式:⼀段地址连续的存储单元可以⽤固定数组或者动态存储结构来实现,这⾥采⽤动态分配存储结构。
3. 顺序表结构体⽰意图三种写法完整代码:第⼀种写法. 从键盘输⼊⽣成线性表--完整代码如下,取值操作实际上就是删除操作的部分实现,这⾥就不写了#include<stdio.h>#include<stdlib.h>#include<malloc.h>#define LIST_INIT_SIZE 100#define LISTINCREMENT 10#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2#define TRUE 1#define FALSE 0typedef int Status;typedef int ElemType;typedef struct SqList{ElemType *elem;int length;int listsize;}SqList;Status InitList(SqList &L){L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));if (!L.elem){printf("ERROR\n");return ERROR;}L.length = 0;L.listsize = LIST_INIT_SIZE;return OK;}Status ListEmpty(SqList L) //判空{if (L.length = 0) return TRUE;else return FALSE;}Status ListInsert(SqList &L, int i, ElemType e) //插⼊{ElemType *p, *q;ElemType *newbase;int j;if (i < 1 || i > L.length + 1) return ERROR;if (L.length >= L.listsize){newbase = (ElemType *)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));if (newbase == NULL){printf("realloc failed!\n");return ERROR;//exit(-1);}L.elem = newbase;L.listsize += LISTINCREMENT;}p = L.elem+i-1;for( q = L.elem + L.length - 1; q>= p; --q ){*(q+1) = *q;}*p = e;++L.length;return OK;}Status CrtList(SqList &L) // 从键盘输⼊数据⽣成线性表{printf("输⼊整数,以0结束:\n");ElemType e;int i = 1;scanf("%d", &e);while (e != 0){if (!ListInsert(L, i, e)) return ERROR;i++;scanf("%d", &e);}return OK;}Status CrtList2(SqList &L, ElemType d[], int n) // 从数组⽣成线性表{int i;for (i = 0; i < n; ++i){if (!ListInsert(L, i + 1, d[i])) return ERROR;}return OK;}Status ListDelet(SqList &L, int i, ElemType &e) //删除{if ((i<1) || (i>L.length)) return ERROR;ElemType *p, *q;p = &(L.elem[i - 1]);e = *p;q = L.elem + L.length - 1;for (++p; p <= q; ++p) *(p - 1) = *(p);--L.length;return OK;}Status GetElem(SqList &L, int i, ElemType &e) //取值{if ((i <= 0) || (i>L.length)) return ERROR;else{e = L.elem[i - 1];return OK;}}Status compare(ElemType a, ElemType b) //⽐较{if (a == b) return TRUE;else return FALSE;}int LocateElem(SqList L, ElemType e) //定位{Status compare(ElemType a, ElemType b);int i;for (i = 0; i<L.length; i++){if (compare(L.elem[i], e))return ++i;}if (i == L.length) return0;}Status PriorElem(SqList L, ElemType cur_e, ElemType &pre_e) //求直接前驱{int LocateElem(SqList L, ElemType e);int i = LocateElem(L, cur_e);if ((i == 0) || (i == 1)) return ERROR;pre_e = L.elem[i - 2];return OK;}int ListLength(SqList L) //求长度{int length = L.length;return length;}void MergeList(SqList La, SqList Lb, SqList &Lc) //归并{Lc.length = La.length + Lb.length;Lc.listsize = Lc.length;Lc.elem = (ElemType*)malloc(Lc.length*sizeof(ElemType));if (Lc.elem == NULL) exit(OVERFLOW);int i, j, k;for (i = 0, j = 0, k = 0; (i<La.length) && (j<Lb.length); k++){if (La.elem[i]<Lb.elem[j]){Lc.elem[k] = La.elem[i];i++;}else{Lc.elem[k] = La.elem[j];j++;}}while (i<La.length){Lc.elem[k] = La.elem[i];i++;k++;}while (j<Lb.length){Lc.elem[k] = Lb.elem[j];j++;k++;}}void vist(ElemType e){printf("%d ", e);}Status ListTraverse(SqList L) //遍历{int i;if (L.length == 0) printf("⽆元素");for (i = 0; i<L.length; i++){vist(L.elem[i]);}if (i == L.length){printf("\n");return OK;}else return ERROR;}Status ListClear(SqList L) //清空{if (L.elem == NULL) return ERROR;int i;for (i = 0; i<L.length; i++) L.elem[i] = 0;L.length = 0;return OK;}Status DestroyList(SqList &L) //销毁{if (L.elem == NULL) return ERROR;free(L.elem);L.length = 0;L.listsize = 0;return OK;}void PrnList(SqList L) //打印{int i;for (i = 0; i < L.length; ++i){printf("%5d", L.elem[i]);}printf("\n");}int main(){int j, l;ElemType e, e1;SqList La;if (InitList(La)) printf("OK\n");else exit(INFEASIBLE);CrtList(La);PrnList(La);int k;printf("1:判空\n2:插⼊\n3:删除\n4:定位\n5:求长度\n6:直接前驱\n");printf("7:归并\n8:遍历\n9:清空\n10:销毁\n\n0:退出\n");scanf("%d", &k);while (k != 0){switch (k){case1:if (ListEmpty(La)) printf("empty\n");else printf("non-empty\n");break;case2:printf("在第⼏个位置插⼊何数:");scanf("%d%d", &j, &e);if (ListInsert(La, j, e)) printf("OK\n");else printf("ERROR\n");break;case3:printf("删除第⼏个数:");scanf("%d", &j);if (ListDelet(La, j, e))PrnList(La);printf("删除数为:%d\n", e);break;case4:printf("定位数字:");scanf("%d", &e);if (LocateElem(La, e) != 0) printf("OK,位序为:%d\n", LocateElem(La, e));else printf("ERROR\n");break;case5:l = ListLength(La);printf("ListLength=%d\n", l);break;case6:printf("寻找何数直接前驱:");scanf("%d", &e);if (PriorElem(La, e, e1)) printf("前驱为:%d\n", e1);else printf("ERROR\n");break;case7:SqList Lb, Lc;if (InitList(Lb)) printf("OK\n");else printf("ERROR\n");CrtList(Lb);MergeList(La, Lb, Lc);printf("有序归并后:\n");PrnList(Lc);break;case8:if (ListTraverse(La)) printf("遍历成功\n");else printf("遍历失败\n");break;case9:if (ListClear(La)) printf("清空成功\n");else printf("清空失败\n");break;case10:if (DestroyList(La)) printf("销毁完成\n");else printf("销毁失败\n");return0;default:printf("ERROR\n");}scanf("%d", &k);}return0;}View Code第⼆种写法. 从txt⽂件读⼊⽣成线性表--完整代码如下:#include<stdio.h>#include<stdlib.h>#define OK 1#define ERROR 0#define OVERFLOW -1#define TRUE 1#define FALSE 0#define INIT_LIST_SIZE 100#define LISTINCREMENT 10typedef int Status;typedef int ElemType;typedef struct{ElemType *elem;int length;int listsize;}SqList;Status InitList(SqList *L){L->elem = (ElemType*)malloc(INIT_LIST_SIZE*sizeof(ElemType));if (!L->elem) exit(OVERFLOW);L->length = 0;L->listsize = INIT_LIST_SIZE;return OK;}Status ListEmpty(SqList L) //判空{if (L.length = 0) return TRUE;else return FALSE;}Status ListInsert(SqList *L, int i, ElemType e) //插⼊{ElemType *newbase, *q, *p;if (i<1 || i>L->length + 1) return 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;}q = L->elem + i - 1; //q为插⼊位置for (p = L->elem + L->length - 1; p >= q; p--){*(p + 1) = *p;}*q = e;++L->length;return OK;}Status ListDelete(SqList *L, int i, ElemType * e) //删除{ElemType * p, *q;if (i<1 || i>L->length) return ERROR;p = L->elem + i - 1; //p为被删除元素位置*e = *p; //被删除元素的值赋值给eq = L->elem + L->length - 1; //表尾元素位置for (++p; p <= q; ++p){*(p - 1) = *p;}L->length--;return OK;}Status GetElem(SqList *L, int i, ElemType * e) //取值{if (i<1 || i>L->length) return ERROR;*e = *(L->elem + i - 1); //获取第i个元素的地址return OK;}int LocateElem(SqList L, ElemType e) //定位{int i;for (i = 0; i<L.length; i++){if (L.elem[i]==e)return ++i;}if (i == L.length) return0;}Status PriorElem(SqList L, ElemType e, ElemType &pre_e) //求直接前驱{int LocateElem(SqList L, ElemType e);int i = LocateElem(L, e);if ((i == 0) || (i == 1)) return ERROR;pre_e = L.elem[i - 2];return OK;}Status GetLength(SqList *L) //求长度{return L->length;}void PrnList(SqList *L) //遍历{int i;for (i = 0; i<(*L).length; i++){if (i == 0)printf("(");printf(" %d ", L->elem[i]);if (i == (*L).length - 1)printf(")\n");}}Status ClearList(SqList *L) //清空{L->length = 0;return OK;}Status Destroy(SqList *L) //销毁{free(L->elem);L->elem = NULL;L->length = 0;L->listsize = 0;return OK;}int main(){int n = 0, rc;int a, i;int e, e1;SqList L;if (InitList(&L)) printf("OK\n");FILE *fp = fopen("D:/1.txt", "r");if (fp == NULL){printf("打开⽂件失败");}printf("从1.txt⽂件读⼊⼏个数:");scanf("%d", &n);for (i = 0; i< n; i++){fscanf(fp, "%d", &a);ListInsert(&L, i+1, a);}fclose(fp);PrnList(&L);char k;printf("\n1.插⼊\n2.删除\n3.取值\n4.定位\n5.直接前驱\n6.求长度\n7.遍历\n8.清空\n9.销毁\n"); while (1){k = getchar();switch (k){case'1':printf("在第⼏个位置插⼊何数:");scanf("%d%d", &i, &e);if (ListInsert(&L, i, e))printf("i=%d,e=%d 已经插⼊\n", i, e);else printf("插⼊失败\n");break;case'2':printf("删除第⼏个数:\n");scanf("%d", &i);if (ListDelete(&L, i, &e))printf("i=%d,e=%d 已经删除\n", i, e);else printf("删除失败\n");break;case'3':printf("取第⼏个数:\n");scanf("%d", &i);if (GetElem(&L, i, &e))printf("第i=%d号,e=%d 被取出!\n", i, e);else printf("取值失败\n");break;case'4':printf("定位数字:");scanf("%d", &e);if (LocateElem(L, e) != 0) printf("OK,位序为:%d\n", LocateElem(L, e));else printf("ERROR\n");break;case'5':printf("寻找何数直接前驱:");scanf("%d", &e);if (PriorElem(L, e, e1)) printf("前驱为:%d\n", e1);else printf("ERROR\n");break;case'6':printf("表长为%d\n", GetLength(&L));break;case'7':printf("遍历:\n");PrnList(&L);break;case'8':if (ClearList(&L)) printf("清空成功\n");else printf("清空失败\n");break;case'9':printf("销毁\n");Destroy(&L);printf("销毁成功\n");exit(0);return0;}}return0;}View Code第三种写法:读数组⽣成线性表--完整代码如下:#include<stdlib.h>#define OK 1#define ERROR 0#define OVERFLOW -1#define TRUE 1#define FALSE 0#define INIT_LIST_SIZE 100#define LISTINCREMENT 10typedef int Status;typedef int ElemType;typedef struct{ElemType *elem;int length;int listsize;}Sqlist;Status InitList(Sqlist *L){L->elem = (ElemType *)malloc(INIT_LIST_SIZE *sizeof(ElemType));if (!L->elem)exit(OVERFLOW);L->length = 0;L->listsize = INIT_LIST_SIZE;return OK;}Status ListEmpty(Sqlist L){if (L.length = 0)return ERROR;else return FALSE;}Status ListInsert(Sqlist *L, int i, ElemType e){ElemType *newbase, *p, *q;if (i<1 || i>L->length + 1)return ERROR;if (L->length > L->listsize){newbase = (ElemType *)realloc(L, (L->listsize + LISTINCREMENT)*sizeof(ElemType));if (!newbase)exit(OVERFLOW);L->elem = newbase;L->listsize += LISTINCREMENT;}p = L->elem + i - 1;for (q = L->elem + L->length - 1; q >= p; q--){*(q + 1) = *q;}*p = e;L->length++;return OK;}Status CreateList(Sqlist *L, ElemType element[], int n) // 从数组⽣成线性表{int i;for (i = 0; i < n; ++i){if (!ListInsert(L, i + 1, element[i])) return ERROR;}return OK;}Status ListDelete(Sqlist *L, int i, ElemType *e){ElemType *p, *q;if (i<1 || i>L->length)return ERROR;p = L->elem + i - 1;q = L->elem + L->length - 1;*e = *p;for (p++; q >= p; p++){*(p - 1) = *p;}L->length--;return OK;}Status GetElem(Sqlist *L, int i, ElemType *e){if (i<1 || i>L->length)return ERROR;return OK;}int LocateElem(Sqlist L, ElemType e){int i;for (i = 0; i < L.length; i++)if (L.elem[i] == e)return i + 1;}Status PriorElem(Sqlist L, ElemType e, ElemType &pr_e){int LocateElem(Sqlist L, ElemType e);int i = LocateElem(L, e);if (i<1 || i>L.length)return ERROR;pr_e = L.elem[i - 2];return OK;}Status GetLength(Sqlist *L){return L->length;}void PrnList(Sqlist *L){int i;for (i = 0; i < L->length; i++)printf("%d ", L->elem[i]);printf("\n");}Status ClearList(Sqlist *L){L->length = 0;return OK;}Status Destroy(Sqlist *L){free(L->elem);L->elem = NULL;L->length = 0;L->listsize = 0;return OK;}int main(){int i;int a, n = 0;int e, e1;Sqlist L;ElemType element[] = { 15, 3, 59, 27, 8, 11, 32 };if (InitList(&L))printf("OK\n");CreateList(&L, element, 7);PrnList(&L);char k;printf("\n1.插⼊\n2.删除\n3.取值\n4.定位\n5.直接前驱\n6.求长度\n7.遍历\n8.清空\n9.销毁\n"); while (1){k = getchar();switch (k){case'1':printf("在第⼏个位置插⼊何数:");scanf("%d%d", &i, &e);if (ListInsert(&L, i, e))printf("i=%d e=%d已经插⼊\n", i, e);break;case'2':printf("删除第⼏个数:");scanf("%d", &i);if (ListDelete(&L, i, &e))printf("i=%d e=%d已经删除\n", i, e);break;case'3':printf("取第⼏个数:");scanf("%d", &i);if (GetElem(&L, i, &e))printf("第i=%d e=%d已经取出\n", i, e);break;case'4':printf("定位何数:");scanf("%d", &e);if (LocateElem(L, e))printf("位序为:%d\n", LocateElem(L, e));break;case'5':printf("寻找何数的直接前驱:");scanf("%d", &e);if (PriorElem(L, e, e1))printf("前驱为:%d\n", e1);break;case'6':printf("表长为:%d\n", GetLength(&L));break;case'7':printf("遍历:\n");PrnList(&L);break;case'8':if (ClearList(&L))printf("清空成功!\n");break;case'9':if (Destroy(&L))printf("销毁成功!\n");exit(0);return0;}}return0;}View Code看懂了左⼿给你个栗⼦,给我关注点赞;看不懂右⼿给你个锤⼦,砸开脑壳看看有没有带脑⼦。
顺序表基本操作的实现代码
顺序表基本操作的实现代码1. 顺序表简介顺序表是一种常见的数据结构,它通过用一组连续的内存空间来存储元素,从而支持快速随机访问。
每个元素在内存中占据固定的空间大小,并按照顺序依次存储在表中。
顺序表有两个重要特点:固定容量和线性有序。
在顺序表的基本操作中,我们需要实现插入、删除、查找和遍历等功能。
这些操作的实现代码通常都比较简单,但需要考虑到许多细节问题。
下面我们将逐一介绍这些基本操作的实现思路和代码。
2. 顺序表的数据结构定义首先,我们需要定义顺序表的数据结构,这里我们可以借助结构体来完成:``` #define MAXSIZE 100 // 顺序表的最大容量typedef struct { int data[MAXSIZE]; // 存储元素的数组 int length; // 当前元素个数 } SqList; ```其中,MAXSIZE为顺序表的最大容量,data数组用于存储元素,length表示当前元素个数。
3. 顺序表的基本操作实现3.1 插入操作插入操作是将一个元素插入到顺序表的指定位置。
对于非空的顺序表,我们可以在指定的下标位置前面插入。
这需要将原位置以及后面的元素全部向后移动一位。
具体实现思路如下:``` bool Insert(SqList &L, int i, int e){ // 首先判断i的值是否合法 if (i < 1 ||i > L.length + 1 || L.length >= MAXSIZE){ return false; } // 将i及其后面的元素全部向后移动一位 for (int j = L.length;j >= i; j--) { L.data[j] = L.data[j -1]; } // 在i的位置插入元素e L.data[i - 1] = e; L.length++; return true; } ```在这个实现代码中,我们首先判断i的合法性,然后循环将i及其后面的元素全部向后移动一位,然后在i的位置插入元素e。
顺序表的基本操作实验报告
顺序表的基本操作实验报告一、实验目的。
本实验旨在通过对顺序表的基本操作进行实验,加深对顺序表的理解,掌握顺序表的基本操作方法,提高编程实践能力。
二、实验内容。
1. 初始化顺序表,包括建立空的顺序表和建立有元素的顺序表。
2. 插入元素,在指定位置插入元素。
3. 删除元素,删除指定位置的元素。
4. 查找元素,根据元素值查找元素所在位置。
5. 输出顺序表,将顺序表中的元素依次输出。
三、实验步骤。
1. 初始化顺序表。
(1)建立空的顺序表,首先定义一个顺序表的结构体,包括数据存储区和表长两个成员变量。
然后通过动态内存分配为顺序表分配存储空间,并初始化表长为0,即建立了一个空的顺序表。
(2)建立有元素的顺序表,定义一个包含初始元素的数组,然后将数组中的元素依次复制到顺序表的数据存储区中,并更新表长。
2. 插入元素。
在指定位置插入元素时,需要先判断插入位置是否合法,然后将插入位置后的元素依次后移,为插入元素腾出位置,并更新表长。
3. 删除元素。
删除指定位置的元素时,同样需要先判断删除位置是否合法,然后将删除位置后的元素依次前移,覆盖被删除的元素,并更新表长。
4. 查找元素。
根据元素值查找元素所在位置时,需要遍历顺序表中的元素,逐个比较元素值,找到匹配的元素位置后返回位置信息。
5. 输出顺序表。
将顺序表中的元素依次输出时,可以通过循环遍历顺序表中的元素,并逐个输出。
四、实验结果与分析。
经过实验操作,成功实现了顺序表的初始化、插入、删除、查找和输出等基本操作。
通过对顺序表的操作,加深了对顺序表结构和操作方法的理解,掌握了顺序表的基本操作技巧。
在实际编程中,顺序表的基本操作是非常常见的,对于处理线性表数据具有重要意义。
五、实验总结。
通过本次实验,深入理解了顺序表的基本操作方法,掌握了顺序表的初始化、插入、删除、查找和输出等操作技巧。
在今后的学习和工作中,将能更加熟练地运用顺序表的基本操作,提高编程实践能力,为实际问题的解决提供更加有效的数据结构支持。
顺序表基本操作的实现
1、顺序表基本操作的实现[问题描述] 在顺序表中查找值为x 的元素的位置,在线性表的某个位置插入一个元素,删除线性表某个位置的元素。
[基本要求]要求建立生成顺序表,可以键盘上读取元素,用顺序存储结构实现存储。
[实现提示]要实现基本操作,可用实现的基本操作,也可设计简单的算法实现。
[ 建议步骤] 1)建立顺序表的存储结构;2)利用1)的存储结构建立有实际数据的数据表;3)实现查找操作;4)实现插入操作;5)实现删除操作。
6)写出main 函数测试上述操作。
实验源码:#include <stdio.h>#define MAX 300typedef int ElemType;typedef struct{ElemType data[MAX];int length;}SqList;SqList L;//打印菜单void menu(){printf("**************************************\n");printf(" 顺序表操作的验证实验\n");printf("**************************************\n");printf(" 1、初始化表\n");printf(" printf(" 2、创建表\n");3、按值查询\n");printf(" 4、在指定位置插入一个元素\n");printf(" 5、删除指定位置上的一个元素\n");printf(" 6、输出表\n");printf(" 0、退出\n");printf("***************************************\n");}//初始化表,置表长为0void Init(SqList *L){L->length=0;}//创建表void Creat(SqList *L){int n,i;printf(" 请确定表的长度:");scanf("%d",&n);L->length=n;printf(" 请输入数据元素:\n");for(i=1;i<=n;i++)scanf("%d",&L->data[i]);printf("\n\n 按任意任意键继续...\n");getch();}//显示列表void PrintL(SqList *L){int i;if(L->length==0)printf(" 空表,请首先创建表!\n");else{printf("\n 当前表元素是:\n");for(i=1;i<=L->length;i++){printf("%d ",L->data[i]);if(i%10==0) printf("\n");}printf("\n");}printf("\n\n 按任意任意键继续...\n");getch();}//按值查询void Search(SqList *L){int i,x;printf(" 请输入要查询元素的值:");scanf("%d",&x);for(i=1;i<=L->length&&L->data[i]!=x;i++);if(i<=L->length)printf("\n 元素%d 第一次出现在表中第%d 个位置上!\n",x,i);else printf("\n 表中没有元素%d !\n",x);printf("\n");printf("\n\n 按任意任意键继续...\n");getch();}//在指定位置上插入一个元素void Insert(SqList *L){int i,j,x;printf(" 请确定要插入的位置:");scanf("%d",&i);printf(" 请输入要插入的元素值:");scanf("%d",&x);if(L->length>MAX){printf(" 表满!\n");return;}。
顺序表基本操作的实现
顺序表基本操作的实现顺序表基本操作的实现,主要包括顺序表的初始化、建⽴、输出、插⼊、删除、位置查询、数据查询。
#include<iostream.h>#define MAXSIZE 100typedef int elemtype;typedef struct{elemtype *data;int length;}SequenList; //后⾯的逗号⼀定不能省略,这是初学者很容易犯的错误这⼀段是对结构体的定义,此处省略了struct后⾯的结构体名称,这是因为在⼤括号⾥没有指向本类型的指针。
//顺序表的初始化void Init_SequenList(SequenList &L){L.data=new elemtype[MAXSIZE]; //申请分配内存空间if(!L.data)cout<<"空间分配失败!\n";else{cout<<"空间分配成功!\n";L.length=0;}}//顺序表的建⽴void Creat_SequenList(SequenList &L){cout<<"顺序表建⽴成功\n请输⼊表长:";cin>>L.length;cout<<"表中元素为:";for(int i=0;i<L.length;i++)cin>>L.data[i]; //这⾥⽐较容易出现错误,要记得后⾯的⼀维数组}//顺序表的输出void Print_SequenList(SequenList &L){for(int i=0;i<L.length;i++){cout<<L.data[i]<<'\t';}cout<<endl;}//顺序表数据的插⼊void Insert_SequenList(SequenList &L,int i,elemtype x){if(i<0||i>L.length)cout<<"位置不合理"<<endl;elseif(L.length==MAXSIZE)cout<<"表满"<<endl;else{for(int j=L.length-1;j>=i;j--)L.data[j+1]=L.data[j]; //这⾥不⼤好理解,可以画图理解L.data[i]=x;L.length++;}Print_SequenList(L);}//顺序表数据的删除void Delete_SequenList(SequenList &L,int i){if(i<0||i>L.length-1)cout<<"位置不合理"<<endl;elseif(L.length==0)cout<<"空表"<<endl;else{for(int j=i+1;j<L.length;j++)L.data[j-1]=L.data[j];L.length--;}Print_SequenList(L);}//顺序表对数据的位置寻找void Getelem_SequenList(SequenList &L,int i,elemtype &e){if(i<0||i>L.length-1)cout<<"查找的位置不存在"<<endl;else{e=L.data[i];cout<<e<<endl;}}//顺序表对数据的查找int Search_SequenList(SequenList &L,elemtype e){for(int i=0;i<L.length;i++)if(L.data[i]==e)return i+1;return 0;}main函数的实现void main(){SequenList L;Init_SequenList(L);Creat_SequenList(L);Print_SequenList(L);int i;elemtype x;cout<<"请输⼊插⼊的位置和元素:";cin>>i>>x;Insert_SequenList(L,i,x);cout<<"请输⼊删除的位置:";cin>>i;Delete_SequenList(L,i);elemtype e;cout<<"请输⼊查找的位置:";cin>>i;Getelem_SequenList(L,i,e);cout<<"请输⼊查找的元素:";cin>>e;if(!Search_SequenList(L,e))cout<<"输⼊的元素"<<e<<"不在顺序表中"<<endl;elsecout<<"输⼊的元素"<<e<<"在顺序表的第"<<Search_SequenList(L,e)<<"位中"<<endl;}值得注意的是,有⼀定C/C++基础的同学可以复习⼀下指针的知识,会给你带来惊喜哦!。
顺序表的基本操作和实现实验报告
顺序表的基本操作和实现实验报告顺序表的基本操作和实现实验报告引言顺序表是一种常用的数据结构,它能够在连续的存储空间中存储元素,并通过索引来访问和修改这些元素。
本实验旨在通过实现基本操作,包括插入、删除、获取等,来深入理解顺序表的原理和实现方式。
实验目的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),根据指定位置和值,在顺序表中插入新元素。
数据结构 顺序表基本运算实现
; //依次打印输出顺序表中的元素
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);
顺序表基本操作的实现
顺序表基本操作的实现顺序表是数据结构中最基本的组织形式,是一种使用一组连续存储单元依次存储相关结构数据的存储方式。
它的特点是支持随机存取、增删操作效率较高,但是当表长度超过存储容量时需要调整存储位置,空间利用率较低。
在各种数据结构中,顺序表发挥着重要作用,其基本操作也亟待实现。
顺序表基本操作主要有查找、插入、删除、更新、查看、排序等,这些操作是实现顺序表服务的基础,它们可以有效地应用到基于顺序表的算法中,这也是数据结构开发过程中比较重要的环节。
下面就来讲述如何实现顺序表基本操作。
1.查找:实现顺序表查找操作有多种方法,其中最常用的是顺序查找和二分查找。
顺序查找就是从表的首位开始,顺序比较元素和查找条件,若相等则查找成功,若不相等则继续扫描后续元素,直至查找条件不满足或遍历完表。
二分查找则是先使用中间元素和查找条件进行比较,若相等则查找成功,若不相等则根据比较结果重新确定查找范围,如此反复查找,直至查找到目标元素或查找失败。
2.插入:实现顺序表插入操作的基本思想是,在插入一个新的元素之前,先将在其之后的元素依次向后移动,然后再插入新的元素,完成插入操作。
插入操作的复杂度主要取决于表长度,当表较短时时间复杂度较低,但是当表长度较长时,插入操作所需时间复杂度较高。
3.删除:实现顺序表删除操作的思路是找到要删除的元素,然后将其后的元素依次向前移动,最后将表长度减一,完成删除操作。
删除操作的时间复杂度也是与表长度有关,当表长度较短时,时间复杂度较低,但当表长度较长时,时间复杂度较高。
4.更新:更新操作是查找、删除和插入操作的综合,首先根据查找操作查找待更新元素,然后根据删除操作删除该元素,最后根据插入操作将更新后的元素插入到正确的位置,完成更新操作。
更新操作的时间复杂度也是由查找、删除和插入操作的复杂度决定的,当表长度较短时,时间复杂度较低,但当表长度较长时,时间复杂度较高。
5.查看:实现顺序表查看操作其实非常简单,只需要逐个检索表中的元素即可,查看操作的时间复杂度和表长度成正比,当表长度较长时,查看操作所需时间也较长。
实验一顺序表的基本操作实验报告
元素之后的所有数据都前移一个位置,最将线性表长减1。
3.顺序表查找操作的基本步骤:要在顺序表中查找一个给定值的数据元素则可以采用顺序查找的方法,从表中第 1 个数据元素开始依次将值与给定值进行比较,若相等则返回该数据元素在顺序表中的位置,否则返回0 值。
线性表的动态分配顺序存储结构—C语言实现#define MaxSize 50//存储空间的分配量Typedef char ElemType;Typedef struct{ElemType data[MaxSize];int length; //表长度(表中有多少个元素)}SqList;动态创建一个空顺序表的算法:void InitList(SqList *&L) //初始化线性表{L=(SqList *)malloc(sizeof(SqList)); //分配存放线性表的空间L->length=0; //置空线性表长度为0}线性表的插入:status Sqlist_insert(Sqlist &L,int i,Elemtype x)/*在顺序表L中第i个元素前插入新元素x*/{ if (i<1||i>L.length+1) return ERROR; /*插入位置不正确则出错*/if (L.length>=MAXLEN)return OVERFLOW;/*顺序表L中已放满元素,再做插入操作则溢出*/for(j=L.length-1;j>=i-1;j--)L.elem[j+1]=L.elem[j]; /*将第i个元素及后续元素位置向后移一位*/L.elem[i-1]=x; /*在第i个元素位置处插入新元素x*/L.length++; /*顺序表L的长度加1*/return OK;}线性表的删除:status Sqlist_delete(Sqlist &L,int i,Elemtype &e)/*在顺序表L中删除第i个元素*{ if (i<1||i>L.length) return ERROR; /*删除位置不正确则出错*/for(j=i;j<=L.length-1;j++)L.elem[j-1]=L.elem[j]; /*将第i+1个元素及后继元素位置向前移一位*/L.length--;/*顺序表L的长度减1*/return OK;}线性表元素的查找:int LocateElem(SqList *L, ElemType e) //按元素值查找{int i=0;while (i<L->length && L->data[i]!=e)i++; //查找元素eif (i>=L->length) //未找到时返回0return 0;elsereturn i+1; //找到后返回其逻辑序号}输出线性表:void DispList(SqList *L) //输出线性表{int i;if (ListEmpty(L)) return;for (i=0;i<L->length;i++)printf("%c ",L->data[i]);printf("\n");}输出线性表第i个元素的值:bool GetElem(SqList *L,int i,ElemType &e)//求线性表中某个数据元素值{if (i<1 || i>L->length)return false; //参数错误时返回falsee=L->data[i-1]; //取元素值return true; //成功找到元素时返回true}代码:#include <stdio.h>#include <malloc.h>#define MaxSize 50typedef char ElemType;typedef struct{ElemType data[MaxSize];int length;} SqList;void InitList(SqList *&L);void DestroyList(SqList *L);bool ListEmpty(SqList *L);int ListLength(SqList *L);void DispList(SqList *L);bool GetElem(SqList *L,int i,ElemType &e);int LocateElem(SqList *L, ElemType e);bool ListInsert(SqList *&L,int i,ElemType e);bool ListDelete(SqList *&L,int i,ElemType &e);void InitList(SqList *&L)//初始化线性表{L=(SqList *)malloc(sizeof(SqList));//分配存放线性表的空间L->length=0;//置空线性表长度为0 }void DestroyList(SqList *L)//销毁线性表{free(L);}bool ListEmpty(SqList *L)//判线性表是否为空表{return(L->length==0);}int ListLength(SqList *L)//求线性表的长度{return(L->length);}void DispList(SqList *L)//输出线性表{int i;if (ListEmpty(L)) return;for (i=0;i<L->length;i++)printf("%c ",L->data[i]);printf("\n");}bool GetElem(SqList *L,int i,ElemType &e)//求线性表中某个数据元素值{if (i<1 || i>L->length)return false;//参数错误时返回falsee=L->data[i-1];//取元素值return true;//成功找到元素时返回true}int LocateElem(SqList *L, ElemType e)//按元素值查找{int i=0;while (i<L->length && L->data[i]!=e)i++;//查找元素eif (i>=L->length)//未找到时返回0return 0;elsereturn i+1;//找到后返回其逻辑序号}bool ListInsert(SqList *&L,int i,ElemType e)//插入数据元素{int j;if (i<1 || i>L->length+1)return false;//参数错误时返回falsei--;//将顺序表逻辑序号转化为物理序号for (j=L->length;j>i;j--)//将data[i]及后面元素后移一个位置L->data[j]=L->data[j-1];L->data[i]=e;//插入元素eL->length++;//顺序表长度增1return true;//成功插入返回true}bool ListDelete(SqList *&L,int i,ElemType &e)//删除数据元素{int j;if (i<1 || i>L->length)//参数错误时返回falsereturn false;i--;//将顺序表逻辑序号转化为物理序号e=L->data[i];for (j=i;j<L->length-1;j++)//将data[i]之后的元素前移一个位置L->data[j]=L->data[j+1];L->length--;//顺序表长度减1return true;//成功删除返回true}void main(){SqList *L;ElemType e;printf("顺序表的基本运算如下:\n");printf(" (1)初始化顺序表L\n");InitList(L);printf(" (2)依次采用尾插法插入a,b,c,d,e元素\n");ListInsert(L,1,'a');ListInsert(L,2,'b');ListInsert(L,3,'c');ListInsert(L,4,'d');ListInsert(L,5,'e');printf(" (3)输出顺序表L:");DispList(L);printf(" (4)顺序表L长度=%d\n",ListLength(L));printf(" (5)顺序表L为%s\n",(ListEmpty(L)?"空":"非空"));GetElem(L,3,e);printf(" (6)顺序表L的第3个元素=%c\n",e);实验结果:心得体会:通过本次实验,实现了数据结构在程序设计上的作用,了解了数据结构语言,加深了对c语言的认识掌并掌握了线性表的顺序存储结构的表示和实现方法,掌握顺序表基本操作的算法实现,同时了解了顺序表的应用。
顺序表的基本操作
2.输入5个数,分别为1,2,3,4,5
3.求线性表是否为空:
4.求线性表的长度:
5.输出顺序表的第4个元素:
6.输出第一次出现元素3的位置:
7.向线性表中插入一个元素:
8.删除元素4,并输出
9.输出线性表的元素:
10.在线性表的-1位置插入数据:
11.清空线性表的所有元素
五、实验总结
1.由于线性表是采用的是数组存储,因此,在第i个位置添加或删除
一个元素时,需要移动n-i个位置,其时间复杂度为O(n)
2.顺序表的删除并非真正意义的删除,由于数组的特殊原因,只是
显示的一种“假象”,如果采用动态的扩展空间,可以实现真正意。
顺序表基本操作技巧的实现
{
int m=0;
for(int i=0;i<length;i++)
{
m=m+list[i];
}
return m;
}
void main()
{
SeqList mylist;
int i,n,flag=1,select;
DataType x;
cout<<" 1.建立顺序表\n";
DataType SLSum();//求和
int SLIsEmpty();//判断顺序表是否为空
void SLPrint();//将顺序表显示在屏幕上
};
//创建顺序表
void SeqList::SLCreat (int n)
{
DataType x;
cout<<"请输入数据元素值: ";
for(int i=0;i<n;i++)
{
cin>>x;
list[i]=x;
length++;
}
}
//在顺序表L中的i位置插入数据元素x
void SeqList::SLInsert (int i,DataType x)
{
int k;
if(length>=MaxSize)
cout<<"表已满,无法插入!"<<endl;
else if(i<0||i>length)
case 4:
cout<<"请输入要删除的数值的位置: ";
数据结构实验报告-实验一顺序表、单链表基本操作的实现
数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现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、掌握使用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. 分析顺序表的存储结构和实现方式,发现其适用于元素数量较少且频繁查找的场景。
六、实验总结。
通过本次实验,我们深入了解了顺序表的基本概念和操作方法,掌握了顺序表的插入、删除、查找等操作。
同时,我们对比了顺序表和链表的优缺点,分析了顺序表的存储结构和实现方式,加深了对顺序表的理解和应用。
在今后的学习和工作中,我们将根据实验结果的分析,合理选择顺序表或链表作为数据结构,以满足不同场景下的需求。
顺序表的基本操作--插入,删除,合并
scanf("%d",&i);
printf("Please input the elemvalue:\n");
scanf("%d",&e);
if(ListInsert_Sq(&La,i,e)==OK)
{
for(i=1;i<=;i++)
for(i=1;i<=n;i++)
{
scanf("%d",&e) ;
if(ListInsert_Sq(&La,i,e)!=OK)break;
}
for(i=1;i<=;i++)
printf("e[%d]=%d\n",i-1,[i-1]);
printf("Length: %d\n\n",;
/*-------------INSERT-----------------*/
printf("Length: %d\n",;
printf("Listsize: %d\n\n",;
}
else
printf("error!");
/*------------------INIT-----------------*/
if(InitList_sq(&Lc))
{
printf("Init is ok!\n");
printf("Please input the values of Lb:\n");
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
1、顺序表基本操作的实现[问题描述] 在顺序表中查找值为x的元素的位置,在线性表的某个位置插入一个元素,删除线性表某个位置的元素。
[基本要求] 要求建立生成顺序表,可以键盘上读取元素,用顺序存储结构实现存储。
[实现提示] 要实现基本操作,可用实现的基本操作,也可设计简单的算法实现。
[建议步骤]1)建立顺序表的存储结构;2)利用1)的存储结构建立有实际数据的数据表;3)实现查找操作;4)实现插入操作;5)实现删除操作。
6)写出main函数测试上述操作。
实验源码:#include <stdio.h>#define MAX 300typedef int ElemType;typedef struct{ElemType data[MAX];int length;}SqList;SqList L;//打印菜单void menu(){printf("**************************************\n");printf(" 顺序表操作的验证实验\n");printf("**************************************\n");printf(" 1、初始化表\n");printf(" 2、创建表\n");printf(" 3、按值查询\n");printf(" 4、在指定位置插入一个元素\n");printf(" 5、删除指定位置上的一个元素\n");printf(" 6、输出表\n");printf(" 0、退出\n");printf("***************************************\n");}//初始化表,置表长为0void Init(SqList *L){L->length=0;}//创建表void Creat(SqList *L){int n,i;printf("请确定表的长度:");scanf("%d",&n);L->length=n;printf("请输入数据元素:\n");for(i=1;i<=n;i++)scanf("%d",&L->data[i]);printf("\n\n按任意任意键继续...\n");getch();}//显示列表void PrintL(SqList *L){int i;if(L->length==0)printf("空表,请首先创建表!\n");else{printf("\n当前表元素是:\n");for(i=1;i<=L->length;i++){printf("%d ",L->data[i]);if(i%10==0) printf("\n");}printf("\n");}printf("\n\n按任意任意键继续...\n");getch();}//按值查询void Search(SqList *L){int i,x;printf("请输入要查询元素的值:");scanf("%d",&x);for(i=1;i<=L->length&&L->data[i]!=x;i++);if(i<=L->length)printf("\n元素%d第一次出现在表中第%d个位置上!\n",x,i);else printf("\n表中没有元素%d !\n",x);printf("\n");printf("\n\n按任意任意键继续...\n");getch();}//在指定位置上插入一个元素void Insert(SqList *L){int i,j,x;printf("请确定要插入的位置:");scanf("%d",&i);printf("请输入要插入的元素值:");scanf("%d",&x);if(L->length>MAX){printf("表满!\n");return;}if(i<1||i>L->length+1)printf("位置错!\n");else{for(j=L->length;j>=i;j--)L->data[j+1]=L->data[j];L->data[i]=x;L->length++;}PrintL(L);printf("\n\n插入成功!!!按任意任意键继续...\n");getch();}//删除指定位置上的一个元素void Del(SqList *L){int i,j;printf("请确定要删除元素的位置:");scanf("%d",&i);if(L->length==0)printf("空表!\n");elseif(i<1||i>L->length)printf("位置错!\n");else{for(j=i+1;j<=L->length;j++)L->data[j-1] = L->data[j];L->length--;}PrintL(L);printf("\n\n删除成功!!!按任意任意键继续...\n");getch();}main(){int t;while(1){system("cls");menu();printf("请选择一个操作:");scanf("%d",&t);switch(t){case 1: Init(&L);break;case 2: Creat(&L);break;case 3: Search(&L);break;case 4: Insert(&L);break;case 5: Del(&L);break;case 6: PrintL(&L);break;case 0:exit(0);default:printf("输入错误!请按任意键继续...\n");getchar();}}}运行截图:2、有序顺序表的合并[问题描述] 已知顺序表la和lb中的数据元素按非递减有序排列,将la和lb表中的数据元素,合并成为一个新的顺序表lc。
[基本要求] lc中的数据元素仍按非递减有序排列,并且不破坏la和lb表。
实验源码:#include <stdio.h>#define MAX 200typedef int ElemType;typedef struct{ElemType data[MAX];int length;}SqList;SqList La,Lb,Lc;//初始化表void Init_List(SqList *L){L->length=0;}//创建表void Creat_List(SqList *L){int n,i;printf("请确定表的长度:");scanf("%d",&n);L->length=n;printf("请输入数据元素:\n");for(i=1;i<=n;i++)scanf("%d",&L->data[i]);}//输出表void Print_List(SqList *L){int i;if(L->length==0)printf("空表,请首先创建表!\n");else{printf("\n当前表元素是:\n");for(i=1;i<=L->length;i++){printf("%d ",L->data[i]);if(i%10==0) printf("\n");}printf("\n");}}//从表中取值void GetElem(SqList *L,int i,ElemType *e) {if(i>=1&&i<=L->length)*e=L->data[i];}//插入:void Insert_List(SqList *L,int i,ElemType e) {int j;if(L->length>MAX){printf("表满!\n");return;}if(i<1||i>L->length+1)printf("位置错!\n");else{for(j=L->length;j>=i;j--)L->data[j+1]=L->data[j];L->data[i]=e;++L->length;}}//合成新表void MergeList(){int i,j;ElemType ai,bj;int k=0;i=j=1;while ((i<=La.length)&&(j<=Lb.length)){ // La和Lb均非空GetElem(&La,i,&ai);GetElem(&Lb,j,&bj);if (ai<=bj){Insert_List(&Lc,++k,ai);++i;}else{Insert_List(&Lc,++k,bj);++j;}}while (i<=La.length){GetElem(&La, i++, &ai);Insert_List(&Lc, ++k,ai);}while (j<=Lb.length){GetElem(&Lb,j++,&bj);Insert_List(&Lc,++k,bj);}Lc.length=La.length+Lb.length;} // merge_listmain(){//初始化表Init_List(&La);Init_List(&Lb);Init_List(&Lc);//创建一个测试表Creat_List(&La);Creat_List(&Lb);Print_List(&La);Print_List(&Lb);MergeList();Print_List(&Lc); }运行截图:。