顺序表的建立及基本操作

实验一：线性表的基本操作【实验目的】学习掌握线性表的顺序存储结构、链式存储结构的设计与操作。

对顺序表建立、插入、删除的基本操作，对单链表建立、插入、删除的基本操作算法.【实验内容】1.顺序表的实践1）建立4个元素的顺序表s=sqlist[］={1，2,3，4,5}，实现顺序表建立的基本操作。

2）在sqlist [］={1,2，3,4,5}的元素4和5之间插入一个元素9,实现顺序表插入的基本操作。

3）在sqlist [］={1,2，3，4,9，5}中删除指定位置(i=5)上的元素9，实现顺序表的删除的基本操作.2.单链表的实践3.1）建立一个包括头结点和4个结点的(5，4,2,1）的单链表,实现单链表建立的基本操作。

2）将该单链表的所有元素显示出来.3）在已建好的单链表中的指定位置(i=3）插入一个结点3，实现单链表插入的基本操作。

4）在一个包括头结点和5个结点的(5，4,3,2,1）的单链表的指定位置（如i=2）删除一个结点，实现单链表删除的基本操作。

5）实现单链表的求表长操作。

【实验步骤】1。

打开VC++。

2.建立工程:点File—〉New,选Project标签,在列表中选Win32 Console Application，再在右边的框里为工程起好名字，选好路径，点OK—>finish.至此工程建立完毕。

3。

创建源文件或头文件：点File-〉New，选File标签，在列表里选C++ Source File。

给文件起好名字，选好路径，点OK.至此一个源文件就被添加到了刚创建的工程之中。

4．写好代码5．编译－＞链接－＞调试1、#include "stdio。

h”#include ”malloc.h"#define OK 1＃define OVERFLOW -2#define ERROR 0#define LIST_INIT_SIZE 100＃define LISTINCREMENT 10typedef int ElemType；typedef int Status;typedef struct {ElemType ＊elem;int length;int listsize；} SqList;Status InitList( SqList &L ) ｛int i，n;L.elem = (ElemType*） malloc (LIST_INIT_SIZE＊sizeof （ElemType))； if （!L.elem） return（OVERFLOW);printf（”输入元素的个数：”）;scanf（”%d”，＆n);printf(”输入各元素的值：”)；for（i=0;i〈n；i++)scanf（"％d",＆L.elem[i］)；L.length = n；L。

实验报告附：源程序：#include<stdio.h>#define Maxsize 100#define error 0#define ok 1typedef struct{int elem[Maxsize];int last;}SeqList;int InsList(SeqList *L,int a,int i); int Locate(SeqList L,int e);int Del(SeqList *L,int i);void main(){int i,e,a;int list1,list2;SeqList L;st=0;for(i=0;i<100;i++){printf("请输入顺序表元素\n");scanf("%d",&L.elem[i]);if(L.elem[i]==-1)break;st++;}if(L.elem[st]==-1)st--;printf("要插入的元素,位置为\n"); scanf("%d,%d",&a,&i);list1=InsList(&L,a,i);if(list1){printf("插入后的顺序表为:\n");for(i=0;i<=st;i++)printf("%d",L.elem[i]);printf("\n");}elseprintf("插入失败！");printf("要查找的元素为\n");scanf("%d",&e);list2=Locate(L,e);if(!list2)printf("该元素不存在\n");elseprintf("该元素所在位置的序号为:%d\n",list2);/*删除元素*/printf("是否要删除该元素？<是请输入1 ，否请输入0 >\n");int m;scanf("%d",&m);if(m){Del(&L,list2);printf("删除后的顺序表为:\n");for(i=0;i<=st;i++)printf("%d",L.elem[i]);printf("\n");}else printf("未删除元素%d\n",e);}int InsList(SeqList *L,int a,int i)//i位置，下标i-1{int p;if(L->last>=Maxsize-1){printf("表已满，无法插入");return(error);}for(p=L->last;p>=i-1;p--)L->elem[p+1]=L->elem[p];L->elem[i-1]=a;L->last++;return(ok);}int Locate(SeqList L,int e){int i=0;while((i<=st)&&(L.elem[i]!=e)) i++;if (i<=st)return(i+1);else return(error);}int Del(SeqList *L,int i){int k;for(k=i;k<=L->last;k++)L->elem[k-1]=L->elem[k];L->last--;return ok;}。

一、实验目的：. 掌握线性表的逻辑特征. 掌握线性表顺序存储结构的特点，熟练掌握顺序表的基本运算. 熟练掌握线性表的链式存储结构定义及基本操作. 理解循环链表和双链表的特点和基本运算. 加深对顺序存储数据结构的理解和链式存储数据结构的理解，逐步培养解决实际问题的编程能力二、实验内容：（一）基本实验内容（顺序表）：建立顺序表，完成顺序表的基本操作：初始化、插入、删除、逆转、输出、销毁, 置空表、求表长、查找元素、判线性表是否为空；1．问题描述：利用顺序表,设计一组输入数据（假定为一组整数），能够对顺序表进行如下操作：. 创建一个新的顺序表，实现动态空间分配的初始化；. 根据顺序表结点的位置插入一个新结点(位置插入)，也可以根据给定的值进行插入(值插入)，形成有序顺序表；. 根据顺序表结点的位置删除一个结点(位置删除)，也可以根据给定的值删除对应的第一个结点，或者删除指定值的所有结点(值删除)；. 利用最少的空间实现顺序表元素的逆转；. 实现顺序表的各个元素的输出；. 彻底销毁顺序线性表，回收所分配的空间；. 对顺序线性表的所有元素删除，置为空表；. 返回其数据元素个数；. 按序号查找，根据顺序表的特点，可以随机存取，直接可以定位于第i 个结点，查找该元素的值，对查找结果进行返回；. 按值查找，根据给定数据元素的值，只能顺序比较，查找该元素的位置，对查找结果进行返回；. 判断顺序表中是否有元素存在，对判断结果进行返回；. 编写主程序，实现对各不同的算法调用。

2．实现要求：对顺序表的各项操作一定要编写成为C（C++）语言函数，组合成模块化的形式，每个算法的实现要从时间复杂度和空间复杂度上进行评价；. “初始化算法”的操作结果：构造一个空的顺序线性表。

对顺序表的空间进行动态管理，实现动态分配、回收和增加存储空间；. “位置插入算法”的初始条件：顺序线性表L 已存在，给定的元素位置为i，且1≤i≤ListLength(L)+1 ；操作结果：在L 中第i 个位置之前插入新的数据元素e，L 的长度加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．掌握数据结构中的一些基本概念。

数据、数据项、数据元素、数据类型和数据结构，以及它们之间的关系。

2．了解数据的逻辑结构和数据的存储结构之间的区别与联系；数据的运算与数据的逻辑结构的关系。

3．掌握顺序表和链表的基本操作：插入、删除、查找以及表的合并等运算。

4．掌握运用C语言上机调试线性表的基本方法。

二、实验条件1．硬件：一台微机2．软件：操作系统和C语言系统三、实验方法确定存储结构后，上机调试实现线性表的基本运算。

四、实验内容1．建立顺序表，基本操作包括：初始化，建立一个顺序存储的链表，输出顺序表，判断是否为空，取表中第i个元素，定位函数（返回第一个与x相等的元素位置），插入，删除。

2．建立单链表，基本操作包括：初始化，建立一个链式存储的链表，输出顺序表，判断是否为空，取表中第i个元素，定位函数（返回第一个与x相等的元素位置），插入，删除。

3．假设有两个按数据元素值非递减有序排列的线性表A和B，均以顺序表作为存储结构。

编写算法将A表和B表归并成一个按元素值非递增有序（允许值相同）排列的线性表C。

（可以利用将B中元素插入A中，或新建C表）4．假设有两个按数据元素值非递减有序排列的线性表A和B，均以单链表作为存储结构。

编写算法将A表和B表归并成一个按元素值递减有序（即非递增有序，允许值相同）排列的线性表C。

五、附源程序及算法程序流程图1.源程序（1）源程序(实验要求1和3)#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef struct arr{int * elem;int length;int listsize;}Sqlist;void menu(); //菜单void InitList(Sqlist *p); // 创建线性表void ShowList(Sqlist *p); // 输出顺序线性表void ListDelete(Sqlist *p,int i,int &e); // 在顺序线性表中删除第i个元素，并用e返回其值void ListInsert(Sqlist *p); // 在顺序线性表中第i个元素前插入新元素evoid ListEmpty(Sqlist *p); // 判断L是否为空表void GetList(Sqlist *p,int i,int &e); // 用e返回L中第i个数据元素的值void ListInsert(Sqlist *p,int i,int e);bool compare(int a,int b);void LocateElem(Sqlist *L,int e); // 在顺序线性表L中查找第1个值与e满足compare()d元素的位序void MergeList_L(Sqlist *La,Sqlist *Lb); // 归并void main(){Sqlist La;Sqlist Lb;int n,m,x;menu();scanf("%d",&n);while(n){switch(n){case 0: ; break;case 1:InitList(&La);break;case 2:ListEmpty(&La);break;case 3:printf("请输入插入的位序:\n");scanf("%d",&m);printf("请出入要插入的数:\n");scanf("%d",&x);ListInsert(&La,m,x);break;case 4:printf("请输入删除元素的位序:\n");scanf("%d",&m);ListDelete(&La,m,x);printf("删除的元素为:%d\n",x);break;case 5:printf("请输入要找的与线性表中相等的数:\n");scanf("%d",&m);LocateElem(&La,m);break;case 6:printf("请输入查找的位序:\n");scanf("%d",&m);GetList(&La,m,x);printf("La中第%d个元素的值为%d\n",m,x);break;case 7:ShowList(&La);break;case 8:InitList(&Lb);break;case 9:MergeList_L(&La,&Lb);printf("归并成功!");break;}menu();scanf("%d",&n);}}/*菜单*/void menu(){printf("********************\n\n");printf(" 0.退出\n\n");printf(" 1.创建线性表La\n\n");printf(" 2.判断La是否为空表\n\n");printf(" 3.插入元素(La)\n\n");printf(" 4.删除元素(La)\n\n");printf(" 5.定位元素(La)\n\n");printf(" 6.取元素(La)\n\n");printf(" 7.输出线性表\n\n");printf(" 8.创建线性表Lb\n\n");printf(" 9.归并为一个线性表La\n\n");printf("********************\n\n");}/*创建顺序线性表L*/void InitList(Sqlist *L){int n;int i=0;L->elem=(int *)malloc(LIST_INIT_SIZE*sizeof(int));if(NULL==L->elem)printf("储存分配失败!\n");else{L->length=0;L->listsize=LIST_INIT_SIZE;printf("输入顺序表a:\n");scanf("%d",&n);while(n){L->elem[i]=n;i++;L->length++;L->listsize=L->listsize-4;scanf("%d",&n);}}}/*输出顺序线性表*/void ShowList(Sqlist *p){int i;if(0==p->length)printf("数组为空!\n");elsefor(i=0;i<p->length;i++)printf("%d ",p->elem[i]);printf("\n");}/*判断L是否为空表*/void ListEmpty(Sqlist *p)if(0==p->length)printf("L是空表!\n");elseprintf("L不是空表!\n");}/*在顺序线性表中第i个元素前插入新元素e */void ListInsert(Sqlist *p,int i,int e){int *newbase;int *q1;int *q2;while(i<1||i>p->length+1){printf("您输入的i超出范围!\n请重新输入要插入的位置\n:");scanf("%d",&i);}if(p->length>=p->listsize){newbase=(int *)realloc(p->elem,(p->listsize+LISTINCREMENT)*sizeof(int));if(!newbase)exit(0);else{p->elem=newbase;p->listsize+=LISTINCREMENT;}}q1=&(p->elem[i-1]);for(q2=&(p->elem[p->length-1]);q2>=q1;--q2)*(q2+1)=*q2;*q1=e;++p->length;}/*/在顺序线性表中删除第i个元素，并用e返回其值*/void ListDelete(Sqlist *p,int i,int &e){int *q1,*q2;while(i<1||i>p->length){printf("您输入的i超出范围!请重新输入:");scanf("%d",&i);}q1=&(p->elem[i-1]);e=*q1;q2=p->elem+p->length-1;for(++q1;q1<=q2;++q1)*(q1-1)=*q1;--p->length;}/*对比a与b相等*/bool compare(int a,int b){if(a==b)return 1;elsereturn 0;}/*在顺序线性表L中查找第1个值与e满足compare()d元素的位序*/ void LocateElem(Sqlist *L,int e){int i=1;int *p;p=L->elem;while(i<=L->length && !compare(*p++,e))++i;if(i<=L->length)printf("第1个与e相等的元素的位序为%d\n",i);elseprintf("没有该元素!\n");}/*用e返回L中第i个数据元素的值*/void GetList(Sqlist *p,int i,int &e){Sqlist *p1;p1=p;e=p1->elem[i-1];}/* 已知顺序线性表La和Lb是元素按值非递减排列*//* 把La和Lb归并到La上,La的元素也是按值非递减*/void MergeList_L(Sqlist *La,Sqlist *Lb){int i=0,j=0,k,t;int *newbase;Sqlist *pa,*pb;pa=La;pb=Lb;while(i<pa->length && j<pb->length){if(pa->elem[i] >= pb->elem[j]){if(pa->listsize==0){newbase=(int*)realloc(pa->elem,(pa->listsize+LISTINCREMENT)*sizeof(int));if(!newbase)exit(0);}for(k=pa->length-1; k>=i; k--)pa->elem[k+1]=pa->elem[k];pa->length++;pa->elem[i]=pb->elem[j];i++;j++;}elsei++;}while(j<pb->length){if( pa->listsize < pb->length-j ){newbase=(int*)realloc(pa->elem,(pa->listsize+LISTINCREMENT)*sizeof(int));if(!newbase)exit(0);}for(j;j<pb->length;j++,i++){pa->elem[i]=pb->elem[j];pa->length++;}}for(i=0;i<pa->length/2;i++){t=pa->elem[i];pa->elem[i]=pa->elem[pa->length-i-1];pa->elem[pa->length-i-1]=t;}}（2）源程序(实验要求2和4)#include<stdio.h>#include<malloc.h>#include<stdlib.h>typedef struct LNode{int data;struct LNode *next;}LNode, *LinkList;void menu();LinkList InitList();void ShowList(LinkList L);void ListDelete(LinkList L,int i,int &e);void ListEmpty(LinkList L);void GetList(LinkList L,int i,int &e);void ListInsert(LinkList L,int i,int e);bool compare(int a,int b);void LocateElem(LinkList L,int e);LinkList MergeList_L(LinkList La,LinkList Lb);int total=0;void main(){LinkList La;LinkList Lb;La=(LinkList)malloc(sizeof(struct LNode));La->next=NULL;Lb=(LinkList)malloc(sizeof(struct LNode));Lb->next=NULL;int n;int m;int x;menu();scanf("%d",&n);while(n){switch(n){case 0: ; break;case 1:La->next=InitList();break;case 2:ListEmpty(La);break;case 3:printf("请输入要插入到第几个节点前:\n");scanf("%d",&m);printf("请输入插入的数据:\n");scanf("%d",&x);ListInsert(La,m,x);break;case 4:printf("请输入删除元素的位序:\n");scanf("%d",&m);ListDelete(La,m,x);printf("删除的元素为:%d\n",x);break;case 5:printf("请输入要找的与线性表中相等的数:\n");scanf("%d",&m);LocateElem(La,m);break;case 6:printf("请输入查找的位序:\n");scanf("%d",&m);GetList(La,m,x);printf("La中第%d个元素的值为%d\n",m,x);break;case 7:ShowList(La);break;case 8:Lb->next=InitList();break;case 9:La=MergeList_L(La,Lb);printf("归并成功\n");break;}menu();scanf("%d",&n);}}void menu(){printf("********************\n\n");printf(" 0.退出\n\n");printf(" 1.创建线性表La\n\n");printf(" 2.判断是否为空表\n\n");printf(" 3.插入元素\n\n");printf(" 4.删除元素\n\n");printf(" 5.定位元素\n\n");printf(" 6.取元素\n\n");printf(" 7.输出线性表\n\n");printf(" 8.创建线性表Lb\n\n");printf(" 9.归并两线性表\n\n");printf("********************\n\n");}// 创建链式线性表LLinkList InitList(){int count=0;LinkList pHead=NULL;LinkList pEnd,pNew;pEnd=pNew=(LinkList)malloc(sizeof(struct LNode));printf("请输入数据:\n");scanf("%d",&pNew->data);while(pNew->data){count++;if(count==1){pNew->next=pHead;pEnd=pNew;pHead=pNew;}else{pNew->next=NULL;pEnd->next=pNew;pEnd=pNew;}pNew=(LinkList)malloc(sizeof(struct LNode));printf("请输入数据:\n");scanf("%d",&pNew->data);}free(pNew);total=total+count;return pHead;}// 判断L是否为空表void ListEmpty(LinkList L){if(NULL==L->next)printf("此表为空表!\n");elseprintf("此表不为空表!\n");}// 在链式线性表中第i个元素前插入新元素e void ListInsert(LinkList L,int i,int e){LinkList p;LinkList s;p=L;int j=0;while(p&&j<i-1){p=p->next;++j;}if(!p||j>i-1)printf("不存在您要找的节点!\n");else{s=(LinkList)malloc(sizeof(int));s->data=e;s->next=p->next;p->next=s;printf("插入节点成功!\n");}}// 输出链式线性表void ShowList(LinkList L){LinkList p;p=L->next;if(p==NULL)printf("此表为空表!\n");elsewhile(p){printf("%d ",p->data);p=p->next;}printf("\n");}// 在链式线性表中删除第i个元素，并用e返回其值void ListDelete(LinkList L,int i,int &e){LinkList p;LinkList q;p=L;int j=0;while(p->next && j<i-1){p=p->next;++j;}if(!(p->next)||j>i-1)printf("没有找到要删除的位置!");else{q=p->next;p->next=q->next;e=q->data;free(q);}}// 用e返回L中第i个数据元素的值void GetList(LinkList L,int i,int &e){LinkList p;p=L->next;int j=0;while(p->next && j<i-1){p=p->next;++j;}if(!(p)||j>i-1)printf("没有找到要查找的位置!");elsee=p->data;}// 对比a与b相等bool compare(int a,int b){if(a==b)return 1;elsereturn 0;}// 在链式线性表L中查找第1个值与e满足compare()d元素的位序void LocateElem(LinkList L,int e){int i=0;LinkList p;p=L;while(p->next && !compare(p->data,e)){p=p->next;i++;}if(NULL==p->next){if(0==compare(p->data,e))printf("没有该元素!\n");elseprintf("第1个与e相等的元素的位序为%d\n",i);}elseif(compare(p->data,e))printf("没有该元素!\n");}LinkList MergeList_L(LinkList La,LinkList Lb){int i,j,k;LinkList pa_1,pb_1,pa_2,pb_2,pc,pd;pa_1=La->next;pc=pa_2=La;pb_1=pb_2=Lb->next;if(pa_1->data > pb_1->data){pc=pa_2=Lb;pa_1=Lb->next;pb_1=pb_2=La->next;}while(pa_1 && pb_1){if(pa_1->data >= pb_1->data){pa_2->next=pb_1;pb_2=pb_1->next;pb_1->next=pa_1;pb_1=pb_2;pa_2=pa_2->next;}else{pa_1=pa_1->next;pa_2=pa_2->next;}}if(pb_1)pa_2->next=pb_1;pd=(LinkList)malloc(sizeof(struct LNode));pd->next=NULL;pa_2=pd;k=total;for(i=0;i<total;i++){pa_1=pc->next;for(j=1;j<k;j++)pa_1=pa_1->next;pb_1=(LinkList)malloc(sizeof(struct LNode));pa_2->next=pb_1;pa_2=pa_2->next;pa_2->data=pa_1->data;k--;}pa_2->next=NULL;return pd;}2.流程图(实验要求1和3)图1 主函数流程图图2创建线性表La流程图图3判断La是否为空表流程图图4 插入元素(La)流程图图5删除元素(La)流程图图6定位元素(La)流程图图7取元素(La)流程图图8输出线性表流程图图9输出线性表流程图流程图(实验要求2和4)图10主函数流程图图11创建线性表La流程图图12判断是否为空表流程图图13插入元素流程图图14删除元素流程图图15定位元素流程图图图16取元素流程图图17创建Lb流程图图18归并两表流程图六、运行结果1. (实验要求1和3)点击运行，首先出现的是菜单界面，选择菜单选项进行操作，如图所示。

实验一顺序表的基本操作及其应用一、需求分析1.本演示程序实现顺序表的初始化，依次从键盘读入数据，建立顺序表、表中元素的连续追加、求顺序表的长度、检查顺序表是否为空、检查顺序表是否为满、显示顺序表、从顺序表中查找元素、给定元素值找位置、向顺序表中插入元素、从顺序表中删除元素、顺序表的逆序排列等基本操作。

2.演示程序以用户和计算机的对话方式执行，即在计算机终端上显示“提示信息”之后，由用户在键盘上输入演示程序中规定的运算命令。

3.程序执行命令包过1）顺序表的初始化；2）连续追加元素建表；3）求顺序表长度；4）检查顺序表是否为空；5）检查顺序表是否为满；6）显示顺序表；7）从顺序表中查找元素；8）给定元素值找位置；9）向顺序表中插入元素；10）从顺序表中删除元素；11）逆序二、概要设计抽象化数据类型线性表的定义如下：ADT List｛数据对象：D=｛ai|ai属于ElemSet，i=1，2，....,n,n>=0｝数据关系：R1={<ai-1,ai>|ai-1,ai属于D，i=2，.....n}基本操作：ListEmpty（L）初始条件：线性表L已存在。

操作结果：若L为空表，则返回TURE，否则返回FLASE。

ListLength（L）初始条件：线性表L已存在。

操作结果：返回L中数据元素个数。

ListInsert（&L，i，e）初始条件：线性表L已存在，1<=i<=ListLength(L)+1。

操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1。

ListDelete（&L,i,&e）初始条件：线性表L已存在且非空，1<=i<=ListLength(L)。

操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减一。

ListTraverse（L，visit()）初始条件：线性表L已存在。

操作结果：依次对L的每个数据元素调用函数visit（）。

顺序表的建立与基本操作实验报告
实验目的：
1、理解顺序表的概念和工作机制。

2、掌握顺序表的建立方法和基本操作。

实验仪器：
1、计算机
2、编程软件
实验原理：
顺序表是一种线性结构，它可以用一段地址连续的存储单元依次存储线性表中的数据元素。

其中，数据元素在存储区中的位置是按其逻辑次序依次存放的。

实验步骤：
1、定义顺序表结构体。

顺序表的结构体包含两个元素：顺序表存储的数据和顺序表存储的长度。

2、初始化顺序表。

初始化顺序表其实就是将顺序表长度设为0。

3、增加数据元素。

当往顺序表中增加元素时，需要先判断顺序表中是否还有剩余的可存储空间，如果没有，需要扩展顺序表空间。

4、删除数据元素。

删除顺序表中的元素时，需要先判断该元素是否在顺序表中存在，然后将该元素后面的元素依次往前移动一位。

5、查找数据元素。

查找顺序表中的元素时，需要先判断该元素是否在顺序表中存在，然后返回该元素在顺序表中的下标。

实验结果：
根据以上步骤和原理，我们创建了一个简单的顺序表程序。

通过该程序的运行，我们可以看到以下结果：
1、创建了一个长度为0的顺序表。

2、在顺序表中增加了8个整数数据。

3、删除了顺序表中下标为2的元素。

4、查找了顺序表中值为7的元素并返回其下标。

结论：
通过这次实验，我们掌握了顺序表的建立方法和基本操作。

顺序表在实际编程中十分常见，因此这次实验为我们今后的编程实践提供了有用的知识和工具。

云南大学物理实验教学中心实验报告课程名称：计算机软件技术基础实验项目：实验二、线性表（顺序存储）及其应用学生姓名：学号：学院系级专业成绩指导教师：实验时间：年日时分至时分实验地点：实验类型：教学（演示□验证□综合█设计□）学生科研□课外开放□测试□其它□一、实验目的：掌握顺序表的建立及基本操作。

二、问题：建立一个顺序表，表中元素为学生，每个学生信息包含姓名、学号和成绩三部分，对该表实现：①输出、②插入、③删除、④查找功能，并计算出平均成绩和总成绩。

三、程序的编写与调试1、原程序：#include <iostream>using namespace std;typedef struct{ long double num; char name[10]; int score; } STUDENT; class sq_LList{ private:int mm;int nn;STUDENT *v;public:sq_LList(int);void prt_sq_LList();void ins_sq_LList(int, STUDENT);void del_sq_LList(int);void sea_num_sq_LList(int);voidvoid cal_sq_LList(int);};/*输出*/sq_LList ::sq_LList(int m){ mm=m;v=new STUDENT [mm];v[0].num=970156; strcpy(v[0].name,"张小明"); v[0].score=87; v[1].num=970157; strcpy(v[1].name,"李小青"); v[1].score=96;v[2].num=970158; strcpy(v[2].name,"刘华");v[2].score=85; v[3].num=970159; strcpy(v[3].name,"王伟");v[3].score=93; v[4].num=970160; strcpy(v[4].name,"李启明"); v[4].score=88;nn=5;}void sq_LList ::prt_sq_LList(){ int i;for(i=0; i<nn; i++){ cout<<"学号: "<<v[i].num<<" 姓名: "<<v[i].name<<" "<<"分数: "<<v[i].score<<endl;}}/*插入*/void sq_LList ::ins_sq_LList(int i, STUDENT b){ int k;if(nn==mm){cout<<"overflow"; return ;}if(i>nn) i=nn+1;if(i<1) i=1;for(k=nn; k>=i; k--)v[k]=v[k-1];v[i-1]=b; nn=nn+1;}/*删除*/void sq_LList ::del_sq_LList(int i){ int k;if(nn==0){cout<<"underflow"<<endl; return ;}if((i<1)||(i>nn)){cout<<"Not this element in the list!"<<endl; return ;}for(k=i; k<nn; k++)v[k-1]=v[k];nn=nn-1;}/*按学号查找*/void sq_LList ::sea_num_sq_LList(int i){ int k,t ;＿＿＿＿t=0;for(i=0;i<nn;i++){ if(v[i].num==k){ t=t+1;cout<<"学号: "<<v[i].num<<" 姓名: "<<v[i].name<<" "<<"分数: "<<v[i].score<<endl;}}if(t==0)cout<<"No this student in the list!"<<endl;}/*按姓名查找*/void sq_LList ::sea_name_sq_LList(int i, char y[]){ int t;＿＿＿＿t=0;for(i=0;i<nn;i++){ if(strcmp(y,v[i].name)=0){t=t+1cout<<"学号: "<<v[i].num<<" 姓名: "<<v[i].name<<" "<<"分数: "<<v[i].score<<endl;}}if(t==0) cout<<"No this student in the list!"<<endl }/*计算*/void sq_LList ::cal_sq_LList(int m){ int i;float sum,avr;{ sum=0;for(i=0;i<nn;i++){sum=sum+v[i].score;avr=sum/(i+1);}}cout<<"总分："<<sum<<endl；cout<<"平均分："<<avr<<endl;}int main(){ int mx; sq_LList s1(100);while (1){ cout<<"1.输出 2.插入 3.删除 4.查找 5.计算 0.退出\n";cout<<"输入0-5:";cin>>mx;switch(mx){ case 1: s1.prt_sq_LList(); break;case 2: int i; STUDENT b;cout<<"输入插入点位置和插入元素值：";cin>>i>>b.num>>>>b.score;s1.ins_sq_LList(i,b); s1.prt_sq_LList(); break; case 3: cout<<"请输入删除学生的位置：";cin>>i;s1.del_sq_LList(i);s1.prt_sq_LList(); break; case 4: int main(){ int mx;while (1){cout<<"1.按学号查找 2.按姓名查找 0.返"<<endl;cout<<"输入0-2：";cin>>mx;switch (mx){casecout<<"请输入要查找学生的学号:";s1.sea_num_sq_LList(i); break;casecout<<"请输入要查找学生的姓名:";s1.sea_name_sq_LList(); break;case 0: cout<<"返回"<<endl; return ;}}return 0;} break;case 5: s1.cal_sq_LList(); break;case 0: cout<<"程序结束"<<endl; return 0;}}return 0;2、正确程序：#include <iostream>using namespace std;typedef struct{ long double num; char name[10]; int score; } STUDENT; class sq_LList{ private:int mm;int nn;STUDENT *v;public:sq_LList(int);void prt_sq_LList();void ins_sq_LList(int, STUDENT);void del_sq_LList(int);void sea_num_sq_LList(int);void sea_name_sq_LList();void cal_sq_LList(int);/*输出*/sq_LList ::sq_LList(int m){ mm=m;v=new STUDENT [mm];v[0].num=970156; strcpy(v[0].name,"张小明"); v[0].score=87; v[1].num=970157; strcpy(v[1].name,"李小青"); v[1].score=96;v[2].num=970158; strcpy(v[2].name,"刘华");v[2].score=85; v[3].num=970159; strcpy(v[3].name,"王伟");v[3].score=93; v[4].num=970160; strcpy(v[4].name,"李启明"); v[4].score=88;nn=5;}void sq_LList ::prt_sq_LList(){ int i;for(i=0; i<nn; i++){ cout<<"学号: "<<v[i].num<<" 姓名: "<<v[i].name<<" "<<"分数: "<<v[i].score<<endl;}}/*插入*/void sq_LList ::ins_sq_LList(int i, STUDENT b){ int k;if(nn==mm){cout<<"overflow"; return ;}if(i>nn) i=nn+1;if(i<1) i=1;for(k=nn; k>=i; k--)v[k]=v[k-1];v[i-1]=b; nn=nn+1;}/*删除*/void sq_LList ::del_sq_LList(int i){ int k;if(nn==0){cout<<"underflow"<<endl; return ;}if((i<1)||(i>nn)){cout<<"Not this element in the list!"<<endl; return ;}for(k=i; k<nn; k++)v[k-1]=v[k];nn=nn-1;}/*按学号查找*/void sq_LList ::sea_num_sq_LList(int i){ int k,t ;cin>>k;t=0;for(i=0;i<nn;i++){ if(v[i].num==k){ t=t+1;cout<<"学号: "<<v[i].num<<" 姓名: "<<v[i].name<<" "<<"分数: "<<v[i].score<<endl;}}if(t==0)cout<<"No this student in the list!"<<endl;}/*按姓名查找*/void sq_LList ::sea_name_sq_LList(){ char y[10]; int i,t;cin>>y;t=0;for(i=0;i<nn;i++){ if(strcmp(y,v[i].name)==0){t=t+1;cout<<"学号: "<<v[i].num<<" 姓名: "<<v[i].name<<" "<<"分数: "<<v[i].score<<endl;}}if(t==0) cout<<"No this student in the list!"<<endl; }/*计算*/void sq_LList ::cal_sq_LList(int m){ int i;float sum,avr;{ sum=0;for(i=0;i<nn;i++){sum=sum+v[i].score;avr=sum/(i+1);}}cout<<"总分："<<sum<<endl;cout<<"平均分："<<avr<<endl;}int main(){ int mx; sq_LList s1(100);while (1){ cout<<"1.输出 2.插入 3.删除 4.查找 5.计算 0.退出\n";cout<<"输入0-5:";cin>>mx;switch(mx){ case 1: s1.prt_sq_LList(); break;case 2: int i; STUDENT b;cout<<"输入插入点位置和插入元素值：";cin>>i>>b.num>>>>b.score;s1.ins_sq_LList(i,b); s1.prt_sq_LList(); break; case 3: cout<<"请输入删除学生的位置：";cin>>i;s1.del_sq_LList(i);s1.prt_sq_LList(); break; case 4:{ int mx;while (1){cout<<"1.按学号查找 2.按姓名查找 0.返"<<endl;cout<<"输入0-2：";cin>>mx;switch (mx){case 1: cout<<"请输入要查找学生的学号:";s1.sea_num_sq_LList(i); break;case 2: cout<<"请输入要查找学生的姓名:";s1.sea_name_sq_LList(); break;case 0: cout<<"返回"<<endl; return 0;}}return 0;} break;case 5: s1.cal_sq_LList(i); break;case 0: cout<<"程序结束"<<endl; return 0;}}return 0;}四、实验总结通过此次试验，我对线性表（顺序存储）有了全面的认识，知道了什么是线性表，以及线性表有什么作用；并学会了如何根据要求建立一个实际的线性表，包括线性表的输出、插入、删除、查。

数据结构实验一1、实验目的∙掌握线性表的逻辑特征∙掌握线性表顺序存储结构的特点，熟练掌握顺序表的基本运算2、实验内容：建立顺序表，完成顺序表的基本操作：初始化、插入、删除、逆转、输出、销毁, 置空表、求表长、查找元素、判线性表是否为空；1．问题描述：利用顺序表,设计一组输入数据（假定为一组整数），能够对顺序表进行如下操作：∙创建一个新的顺序表，实现动态空间分配的初始化；∙根据顺序表结点的位置插入一个新结点(位置插入)，也可以根据给定的值进行插入(值插入)，形成有序顺序表；∙根据顺序表结点的位置删除一个结点(位置删除)，也可以根据给定的值删除对应的第一个结点，或者删除指定值的所有结点(值删除)；∙利用最少的空间实现顺序表元素的逆转；∙实现顺序表的各个元素的输出；∙彻底销毁顺序线性表，回收所分配的空间；∙对顺序线性表的所有元素删除，置为空表；∙返回其数据元素个数；∙按序号查找，根据顺序表的特点，可以随机存取，直接可以定位于第i 个结点，查找该元素的值，对查找结果进行返回；∙按值查找，根据给定数据元素的值，只能顺序比较，查找该元素的位置，对查找结果进行返回；∙判断顺序表中是否有元素存在，对判断结果进行返回；.编写主程序，实现对各不同的算法调用。

2．实现要求：∙“初始化算法”的操作结果：构造一个空的顺序线性表。

对顺序表的空间进行动态管理，实现动态分配、回收和增加存储空间；∙“位置插入算法”的初始条件：顺序线性表L 已存在，给定的元素位置为i，且1≤i≤ListLength(L)+1 ；操作结果：在L 中第i 个位置之前插入新的数据元素e，L 的长度加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. 顺序表的建立2. 顺序表的遍历3. 顺序表的元素查找4. 顺序表的元素插入5. 顺序表的元素删除6. 有序表的建立7. 有序表的遍历8. 有序表的元素插入9. 有序表的合并二、实验原理基本原理：通过连续的地址空间实现逻辑上和物理上连续的储存的一系列元素。

并在此基础上进行元素的添加，查找，删除操作。

有序表的插入算法：元素插入之前的，先跟有序表中的逐个元素进行对比，以找到合适的插入位置。

例如，已有有序表L，要向L 中插入元素18L={13,15,17,19,20,35,40}第一步：将18与L1进行比较，18 > L1，不是合适的插入位置。

第二步：将18与L2进行比较，18>L2，仍然不是不是的插入位置。

重复上述步骤，知道找到18≤Ln，然后在(n-1) 和n之间插入元素。

（如果元素比有序表中的所有元素都要大，则把该元素放到有序表的最后）此例子中，L n-1 = 17，L n = 19插入元素之后的有序表L为：L′={13,15,17,18,19,20,35,40}仍然保持有序。

重置光标的位置：程序接受两种方式的输入。

一种是输入数字后按回车，一种是利用空格间隔的连续几个数字。

然而，在使用后者输入数字的时候，会出现提示输出不正确的问题。

（如图）这个问题的原因简单如下：当程序输出“请输入第2个数字：”的时候，应该等待用户输入；然而，在程序等待输入第一个数字的时候，用户输入了五个数字。

因此，程序输出“输入第2个提示以后”，程序发现仍然有数据没有进行处理，因此把上次输入但未处理的字符当成是用户的输入。

所以没让用户输入数据就自动继续执行。

解决这个问题的思路：每次输出提示时，将光标移动到行首，因此，输出提示的时候会自动覆盖已经输出的提示信息。

效果如下：具体的解决方法：#include<windows.h>// 将光标移动到行首void ResetCursor(){HANDLE hOut;COORD cTarget;CONSOLE_SCREEN_BUFFER_INFO info;int y = 0;hOut = GetStdHandle(STD_OUTPUT_HANDLE);GetConsoleScreenBufferInfo(hOut, &info);y = info.dwCursorPosition.Y;cTarget.X = 0;cTarget.Y = y;SetConsoleCursorPosition(hOut, cTarget);}三、程序流程图四、实现步骤4.1 创建顺序表的实现①通过scanf 函数从键盘中读入数据，并通过scanf函数的返回值判断用户输入的是数字还是非数字，作为判断输入结束的判断。

顺序表的基本操作实验报告一、实验目的。

本实验旨在通过对顺序表的基本操作进行实验，加深对顺序表的理解，掌握顺序表的基本操作方法，提高编程实践能力。

二、实验内容。

1. 初始化顺序表，包括建立空的顺序表和建立有元素的顺序表。

2. 插入元素，在指定位置插入元素。

3. 删除元素，删除指定位置的元素。

4. 查找元素，根据元素值查找元素所在位置。

5. 输出顺序表，将顺序表中的元素依次输出。

三、实验步骤。

1. 初始化顺序表。

（1）建立空的顺序表，首先定义一个顺序表的结构体，包括数据存储区和表长两个成员变量。

然后通过动态内存分配为顺序表分配存储空间，并初始化表长为0，即建立了一个空的顺序表。

（2）建立有元素的顺序表，定义一个包含初始元素的数组，然后将数组中的元素依次复制到顺序表的数据存储区中，并更新表长。

2. 插入元素。

在指定位置插入元素时，需要先判断插入位置是否合法，然后将插入位置后的元素依次后移，为插入元素腾出位置，并更新表长。

3. 删除元素。

删除指定位置的元素时，同样需要先判断删除位置是否合法，然后将删除位置后的元素依次前移，覆盖被删除的元素，并更新表长。

4. 查找元素。

根据元素值查找元素所在位置时，需要遍历顺序表中的元素，逐个比较元素值，找到匹配的元素位置后返回位置信息。

5. 输出顺序表。

将顺序表中的元素依次输出时，可以通过循环遍历顺序表中的元素，并逐个输出。

四、实验结果与分析。

经过实验操作，成功实现了顺序表的初始化、插入、删除、查找和输出等基本操作。

通过对顺序表的操作，加深了对顺序表结构和操作方法的理解，掌握了顺序表的基本操作技巧。

在实际编程中，顺序表的基本操作是非常常见的，对于处理线性表数据具有重要意义。

五、实验总结。

通过本次实验，深入理解了顺序表的基本操作方法，掌握了顺序表的初始化、插入、删除、查找和输出等操作技巧。

在今后的学习和工作中，将能更加熟练地运用顺序表的基本操作，提高编程实践能力，为实际问题的解决提供更加有效的数据结构支持。

《数据结构》课程实验指导《数据结构》实验教学大纲课程代码：0806523006 开课学期：3 开课专业：信息管理与信息系统总学时/实验学时：64/16 总学分/实验学分：3.5/0.5一、课程简介数据结构是计算机各专业的重要技术基础课。

在计算机科学中，数据结构不仅是一般程序设计的基础，而且是编译原理、操作系统、数据库系统及其它系统程序和大型应用程序开发的重要基础。

数据结构课程主要讨论各种主要数据结构的特点、计算机内的表示方法、处理数据的算法以及对算法性能的分析。

通过对本课程的系统学习使学生掌握各种数据结构的特点、存储表示、运算的原理和方法，学会从问题入手，分析研究计算机加工的数据结构的特性，以便为应用所涉及的数据选择适当的逻辑结构、存储机构及其相应的操作算法，并初步掌握时间和空间分析技术。

另一方面，本课程的学习过程也是进行复杂程序设计的训练过程，通过对本课程算法设计和上机实践的训练，还应培养学生的数据抽象能力和程序设计的能力。

二、实验的地位、作用和目的数据结构是一门实践性较强的基础课程，本课程实验主要是着眼于原理和应用的结合，通过实验，一方面能使学生学会把书上学到的知识用于解决实际问题，加强培养学生如何根据计算机所处理对象的特点来组织数据存储和编写性能好的操作算法的能力，为以后相关课程的学习和大型软件的开发打下扎实的基础。

另一方面使书上的知识变活，起到深化理解和灵活掌握教学内容的目的。

三、实验方式与基本要求实验方式是上机编写完成实验项目指定功能的程序，并调试、运行，最终得出正确结果。

具体实验要求如下：1.问题分析充分地分析和理解问题本身，弄清要求，包括功能要求、性能要求、设计要求和约束，以及基本数据特性、数据间联系等等。

2.数据结构设计针对要解决的问题，考虑各种可能的数据结构，并且力求从中选出最佳方案（必须连同算法实现一起考虑），确定主要的数据结构和全程变量。

对引入的每种数据结构和全程变量要详细说明其功用、初值和操作的特点。

顺序表的基本操作【c语⾔】【创建、插⼊、删除、输出】作为数据结构初学者，上课时对⼀些知识点掌握得不是很透彻，所以利⽤课余时间通过微博平台总结所学知识，加深对知识的见解，记录学习历程便于后需要时参考。

1 #include<stdio.h>2 #include<malloc.h>3#define OK 14#define ERROR 05#define LIST_INIT_SIZE 1006#define LISTINCREMENT 107#define ElemType int顺序表的基本操作之结构体的创建：1 typedef struct2 {3int *elem;//存储空间基址，也就是该数据得到的内存分配的起始地址4int length;//当前长度5int listsize;//当前分配的存储容量6 } SqList;构造⼀个空的线性表：int InitList_Sq(SqList &L) //&此符号不是c语⾔⾥的取地址符号，⽽是C++⾥的引⽤符号，⽤法为为主函数⾥的T，取⼀个别名，这样⼦对L操作即相当于对T操作{// 该线性表预定义⼤⼩为LIST_INIT_SIZEL.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));//ElemType即为intif(!L.elem) return0;//malloc返回值为void*,void* 类型可以强制转换为任何其它类型的指针，在这⾥L.elem为⾮零。

L.length=0;L.listsize=LIST_INIT_SIZE;//LIST_INIT_SIZE=100return OK;}在顺序线性表L中第i个位置之前插⼊新的元素e：1int ListInsert_Sq(SqList &L,int i,int e)2 {3int *newbase;//声明整型指针变量4int *q,*p;5if(i<1||i>L.length+1) return ERROR;//判断i值是否合法，1<i<L.length+16if(L.length>=L.listsize)//判断当前长度是否⼤于当前的存储容量，如果⼤于，则增加LISTINCREMENT长度，即107 {8 newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));9if(!newbase) return0;10 L.elem=newbase;11 L.listsize+=LISTINCREMENT;12 }13 q=&(L.elem[i-1]);//把插⼊位置的地址赋值给q14for(p=&(L.elem[L.length-1]); p>=q; p--)15 *(p+1)=*p;//把i后⾯的元素都向后移⼀位16 *q=e;//在i位置插⼊e17 ++L.length;//长度增加18return OK;19 }在顺序线性表L中删除第i个位置的元素，并⽤e返回其值：int ListDelete_Sq(SqList &L,int i, int &e){// i的合法值为1≤i≤L.lengthint *p;int *q;if(i<1||i>L.length) return ERROR;p=&(L.elem[i-1]);//把i位置的地址赋值给pe=*p;//把i位置的值赋值给eq=L.elem+L.length-1;for(++p; p<=q; ++p)*(p-1)=*p;//i后⾯的元素向前移⼀位，直接覆盖i位置的值--L.length;//长度减少return OK;}顺序表基本操作之输出：int Load_Sq(SqList &L){// 输出顺序表中的所有元素int i;if(L.length==0) printf("The List is empty!");else{printf("The List is: ");for( i=0; i<L.length; i++) printf("%d ",L.elem[i]); // 请填空}printf("\n");return OK;}下⾯是主函数：1int main()2 {3 SqList T;4int a, i;5 ElemType e, x;6if(InitList_Sq(T)) // 判断顺序表是否创建成功7 {8 printf("A Sequence List Has Created.\n");9 }10while(1)11 {12 printf("1:Insert element\n2:Delete element\n3:Load all elements\n0:Exit\nPlease choose:\n");13 scanf("%d",&a);14switch(a)15 {16case1:17 scanf("%d%d",&i,&x);18if(!ListInsert_Sq(T,i,x)) printf("Insert Error!\n"); // 判断i值是否合法19else printf("The Element %d is Successfully Inserted!\n", x);20break;21case2:22 scanf("%d",&i);23if(!ListDelete_Sq(T,i,e)) printf("Delete Error!\n"); // 判断i值是否合法24else printf("The Element %d is Successfully Deleted!\n", e);25break;26case3:27 Load_Sq(T);28break;29case0:30return1;31 }32 }33 }。

数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现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.顺序表的基本操作实践。

(1)建⽴4个元素的顺序表list[]={2，3，4，5}，实现顺序表建⽴的基本操作。

(2)在list[]={2，3，4，5}的元素4和5之间插⼊⼀个元素9，实现顺序表插⼊的基本操作。

(3)在list[]={2，3，4，9，5}中删除指定位置（i=3）上的元素4，实现顺序表的删除的基本操作。

#include <stdio.h>#include <stdlib.h>#include <iostream>#define MAXSIZE 10using namespace std;typedef int ElemType;typedef struct {ElemType a[MAXSIZE];int length;} S;void CreatList(S &L) {scanf("%d", &L.length);for(int i = 1; i <= L.length; i ++) scanf("%d",&L.a[i]);} //创建列表void PutList(S L) {for(int i = 1; i <= L.length; i ++) {printf("%d ",L.a[i]);}printf("\n");} //输出列表void InserElem(S &L, int i, ElemType x) { j iif(i < 1 || i > L.length) return; 2 3 4 5 9for(int j = L.length+1; j > i; j --) { j-1jL.a[j] = L.a[j-1]; 2 3 4 9 5}L.a[i] = x;L.length++;} //插⼊void DeleElem(S &L, int i) {for(int j = i; j < L.length; j ++) {L.a[j] = L.a[j+1]; j j+1} 2 3 4 9 5L.length--;}//删除int main() {S L;CreatList(L);InserElem(L,4,9);PutList(L);DeleElem(L,3);PutList(L);return0;}结果E:\c++>b42345234952395。

c++有序顺序表的建立与基本操作【C++有序顺序表的建立与基本操作】一、引言在C++编程中，有序顺序表是非常常见的数据结构之一。

它可以帮助我们存储和操作一组有序的数据，是程序中非常实用的工具。

本文将从有序顺序表的概念入手，逐步深入探讨其建立和基本操作，帮助读者更好地理解和运用这一数据结构。

二、有序顺序表的概念有序顺序表是一种线性表，其中元素按照一定的顺序排列。

在C++中，我们通常使用数组来实现有序顺序表。

通过数组，我们可以轻松地存储一组有序的数据，并且可以方便地进行各种基本操作，如插入、删除、查找等。

三、有序顺序表的建立1. 定义结构体或类我们需要定义一个结构体或类，用于表示有序顺序表。

结构体或类中应包含元素存储的数组，以及记录当前元素个数和表长的变量。

2. 初始化在建立有序顺序表时，我们需要对其进行初始化。

可以通过动态内存分配来分配数组空间，并对其他变量进行初始化。

需要注意的是，数组的大小应该根据实际需要进行调整，以防止空间浪费。

3. 插入元素在有序顺序表中插入元素是一个常见的操作。

当插入元素时，我们需要保持顺序表的有序性。

可以通过比较元素大小的方式，找到合适的位置并将元素插入其中。

四、有序顺序表的基本操作1. 插入操作有序顺序表的插入操作是比较常见的操作之一。

当我们需要向顺序表中插入新元素时，我们首先需要找到合适的位置，然后将其插入其中。

2. 删除操作删除操作是有序顺序表中另一个重要的操作。

当我们需要删除某个元素时，我们可以通过查找元素的方式找到需要删除的元素，然后将其后的元素向前移动，从而达到删除的目的。

3. 查找操作有序顺序表中的查找操作也是常见的操作之一。

当我们需要查找某个元素时，可以通过顺序查找或二分查找的方式进行查找，以获取所需的元素。

五、个人观点和理解有序顺序表是C++编程中非常常见的数据结构之一。

它能够帮助我们高效地存储和操作数据，是程序中的重要工具。

在实际应用中，我们需要灵活地运用有序顺序表的建立和基本操作，以解决实际问题。

数据结构实验课教案数据结构教案实验一：线性表的顺序表示与实现实验学时：2学时一．实验目的：1．掌握线性表的顺序存储结构；2．掌握在顺序表上进行的插入、删除、查找、修改等操作。

二．实验内容：1．分别建立顺序表，并输入初始数据；2．对顺序表分别编写插入、删除、查找、修改等函数。

三．实验重点：顺序表的建立及操作。

四．实验要求：1．用C语言编写程序源代码；2．要分别完成建立、插入、删除、查找、修改五种功能。

3．源程序必须编译调试成功，独立完成。

五．实验器材：一个装有C语言编译环境的计算机。

六．实验步骤：顺序表：1．定义头文件和顺序表的存储结构类型等 #define ok 1 #define error 0 #define overflow 0 #define null 0 #include #include #define list_init_size 100 #define listincrement 10 typedef int elemtype; typedef int status; typedef struct{ elemtype *elem; int length; int listsize; }sqlist;1 2．编写构造空顺序表的函数status listinit(sqlist *l) { l->elem=(elemtype *)malloc(list_init_size*sizeof(elemtype)); if(!l->elem)return overflow; l->length=0; l->listsize=list_init_size; return ok; }3．编写对顺序表进行插入操作的函数： status listinsert(sqlist *l,int i,elemtype e) { elemtype *newbase,*q,*p; if(ilistlength(*l)+1)return error; if(l->length==l->listsize){ newbase=(elemtype *)realloc(l->elem,(l->listsize+listincrement)*sizeof(elemtype));if(!newbase)return overflow;l->listsize+=listincrement;} q=&(l->elem[i-1]); for(p=&(l->elem[l->length])-1;p>=q;--p)*(p+1)=*p; *q=e; ++l->length; return ok; }4．编写对顺序表进行删除操作的函数：status listdelete(sqlist *l,int i,elemtype *e) { elemtype *p,*q; if(il->length)return error; p=&(l->elem[i-1]); *e=*p; q=l->elem+l->length-1; for(++p;p*(p-1)=*p; --l->length;2 return ok; }5．编写对顺序表进行查找操作的函数： status getelem(sqlist l,int i,elemtype *e) { if(ilistlength(l)) return error; *e=[i-1]; return ok; }6．编写对顺序表进行修改操作的函数： status locateelem(sqlist l,elemtype e) { int i; for(i=0;iif([i]==e)return i+1; return 0; } 7．编写实现两个线性表的归并操作的函数 void mergelist(sqlist la,sqlist lb,sqlist *lc) { int i,j,k; intla_len,lb_len; elemtype ai,bj; i=j=1; k=0; listinit(lc); la_len=listlength(la); lb_len=listlength(lb); while(i{listinsert(lc,++k,ai);++i;} else{listinsert(lc,++k,bj);++j;} } while(iwhile(j{ getelem(lb,j++,&bj); listinsert(lc,++k,bj);} }8．销毁线性表、清空线性表、判空、求表长等 status destroylist(sqlist *l) { if(l->elem) free(l->elem),l->elem=null; return ok; }status clearlist(sqlist *l) { l->length=0; return ok; }status listempty(sqlist l) { return(==0); }status listlength(sqlist l) { return ; }9．打印线性表4 void print(sqlist l) { int i; printf(\”\\nlist: \”); for(i=0;i10．编写主函数 void main() { int i; int n; elemtype a; sqlist l,la,lb,lc; clrscr(); listinit(&l); listinit(&la); listinit(&lb);printf(\”please input list number\”); scanf(\”%d\”,&n); printf(\”\\n\”); for(i=0;iscanf(\”%d\”,&a);listinsert(&l,i+1,a); } print(l); printf(\”\\nlist length:%d\”,listlength(l));getelem(l,4,&a); printf(\”\\ngetelem(l,4,&a),%d\”,a);listdelete(&l,3,&a); printf(\”\\nlistdelete(&l,3,&a),%d\”,a); print(l);printf(\”\\ninput list la\”);for(i=0;iscanf(\”%d\”,&a);listinsert(&la,i+1,a); } printf(\”\\ninput list lb\”);5 for(i=0;iscanf(\”%d\”,&a);listinsert(&lb,i+1,a); } mergelist(la,lb,&lc); print(la);print(lb);print(lc); }6实验二：链表实验学时：2学时一．实验目的：11．掌握单、双向链表的存储结构；12．掌握在单、双向链表上进行的插入、删除、查找、修改等操作。

数据结构实验报告_单链表【实验目的】1、顺序表的基本操作及c语言实现【实验要求】1、用c语言建立自己的线性表结构的程序库，实现顺序表的基本操作。

2、对线性表表示的集合，集合数据由用户从键盘输入（数据类型为整型），建立相应的顺序表，且使得数据按从小到大的顺序存放，将两个集合的并的结果存储在一个新的线性表集合中，并输出。

【实验内容】1、根据教材定义的顺序表机构，用c语言实现顺序表结构的创建、插入、删除、查找等操作；2、利用上述顺序表操作实现如下程序：建立两个顺序表表示的集合（集合中无重复的元素），并求这样的两个集合的并。

【实验结果】[实验数据、结果、遇到的问题及解决]一．statusinsertorderlist(sqlist&va,elemtypex){}二．statusdeletek(sqlist&a,inti,intk){//在非递减的顺序表va中插入元素x并使其仍成为顺序表的算法inti;if(v==ze)return(overflow);for(i=v;i>0,x }//注意i的编号从0开始intj;if(i<0||i>-1||k<0||k>-i)returninfeasible;for(j=0;j<=k;j++)[j+i]=[j+i+k];=-k;returnok;三．//将合并逆置后的结果放在c表中，并删除b表statuslistmergeoppose_l(linklist&a,linklist&b,linklist& c){linklistpa,pb,qa,qb;pa=a;pb=b;qa=pa;qb=pb;//保存pa的前驱指针//保存pb的前驱指针pa=pa->next;pb=pb->next;a->next=null;c=a;while(pa&&pb){}whi le(pa){}qa=pa;pa=pa->next;qa->next=a->next;a->next=qa;if(pa ->datadata){}else{}qb=pb;pb=pb->next;qb->next=a->next;//将当前最小结点插入a表表头a->next=qb;qa=pa;pa=pa->next;qa->next=a->next;//将当前最小结点插入a表表头a->next=qa;}}pb=b;free(pb);returnok;qb=pb;pb=pb->next;qb->next=a->n ext;a->next=qb;顺序表就是把线性表的元素存储在数组中，元素之间的关系直接通过相邻元素的位置来表达。

实验名称线性表实验室实验日期
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;。