C语言数据结构线性表的基本操作实验报告

合集下载

数据结构线性表的基本操作及应用实验报告

实验日期2010.4.19 教师签字成绩实验报告【实验名称】第二章线性表的基本操作及应用【实验目的】（1）熟练掌握线性表的基本操作的实现；（2）以线性表的各种操作（建立、插入、删除等）的实现为重点；（3）通过本次实验加深对C语言的使用（特别是函数的参数调用、指针类型的应用和链表的建立等各种基本操作）。

【实验内容】1.顺序表的基本操作（顺序表的插入、访问、删除操作）#include <stdio.h>#include <stdlib.h>#define OK 1#define ERROR 0#define OVERFLOW -1typedef int ElemType;typedef int Status;#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef struct{ElemType *elem;int length;int listsize;}SqList;Status InitList_Sq(SqList *L){int i,n;L->elem = (ElemType * )malloc(LIST_INIT_SIZE*sizeof(ElemType));if (! L->elem) exit (OVERFLOW);printf("您希望您的顺序表有几个元素: ");scanf("%d",&n);printf("\n");printf("输入您的%d个元素，以构建顺序表: \n",n);for(i=1;i<=n;i++)scanf("%d",&L->elem[i-1]);L->length = n;L->listsize = LIST_INIT_SIZE;return OK;}//InitList_SqStatus PrintList_Sq(SqList L){int i;printf("顺序表中的元素为：");for (i=1;i<=L.length;i++)printf("%d ",L.elem[i-1]);printf("\n");return OK;}//PrintList_Sqint ListInsert_Sq(SqList* L,int i,ElemType x) //对顺序表进行插入操作{int j;if (L->length==L->listsize){printf("\t\t\t顺序表已满");return 0;}else{if (i<1||i>L->length){printf("\t\t\t位置不合法");return 0;}else{for(j=L->length-1;j>=i-1;--j)L->elem[j+1]=L->elem[j];L->elem[i-1]=x;L->length++;return 1;}}}int ListDelete_Sq(SqList* L,int i) //对顺序表进行删除操作{int j;if (i<1||i>L->length){printf("\t\t\t不存在第i个元素");return 0;}else{for (j=i-1;j<L->length;j++){L->elem[j]=L->elem[j+1];}L->length--;return 1;}}int LocateElem(SqList *L, int i) {if(i<1||i>L->length)return ERROR;else return L->elem[i-1];}int scan(){int choose;printf("选择要执行的基本操作:\n1.插入元素；2.删除元素；3.访问元素.\n");printf("输入其他值退出程序……\n");scanf("%d",&choose);return(choose);}void main(){SqList L;ElemType e;int i;int quit=0;if (InitList_Sq(&L)==OVERFLOW)printf("分配失败，退出程序！");printf("输出程序中的元素\n");PrintList_Sq(L);while(!quit)switch(scan()){case 1:printf("\n请输入你所需要插入的位置和你要插入的元素:");printf("\n请输入i和e的值:");scanf("%d%d",&i,&e);if (ListInsert_Sq(&L,i,e)==OK) PrintList_Sq(L);break;case 2:printf("\n请输入你所需要删除元素的位置:");scanf("%d",&i);if(ListDelete_Sq(&L,i)==OK) PrintList_Sq(L);break;case 3:printf("请输入所要查找元素的位置:\n");scanf("%d",&i);if(LocateElem(&L,i))printf("该位置元素的值为:%d!\n",LocateElem(&L,i));else printf("该位置的元素不存在!\n");break;default:quit=1;printf("操作结束!");printf("\n");}}2.单向链表的基本操作（单向链表的插入、删除、查找以及并表操作）#include<stdio.h>#include<malloc.h>typedef int ElemType;#define OK 1#define ERROR 0#define flag 0typedef struct LNode{ElemType data;struct LNode *next;} LNode,*LinkList;LinkList InitLinkList(){LinkList L;L=(LinkList)malloc(sizeof(LNode));L->next=NULL;return L;}LinkList LocateLinkList(LinkList L,int i){LinkList p;int j;p=L->next;j=1;while(p!=NULL&&j<i){p=p->next; j++;}if (j==i)return p;else return NULL;}void LinkListInsert(LinkList L, int i, ElemType e)//插入元素{LinkList p,s;int j;j=1;p=L;while(p&&j<i){p=p->next;j++;}if(p==NULL||j>i)printf("插入位置不正确\n");else {s=(LNode *)malloc(sizeof(LNode));s->data=e;s->next=p->next;p->next=s;printf("%d已插入到链表中\n",e);}}void LinkListDelete(LinkList L,int i) //删除元素{LinkList p,q;int j;j=1;p=L;while(p->next&&j<i){p=p->next;j++;}if(p->next==NULL)printf("删除位置不正确\n");else{q=p->next;p->next=q->next;free(q);printf("第%d个元素已从链表中删除\n",i);}}LinkList CreatLinkList( )//建立单向链表{LinkList L=InitLinkList(),p,r;ElemType e;r=L;printf("请依次输入链表中的元素,输入0结束\n"); scanf("%d",&e);while (e!=flag){p=(LinkList)malloc(sizeof(LNode));p->data=e;r->next=p;r=p;scanf("%d",&e);}r->next=NULL;return L;}int LinkListLength(LinkList L){LinkList p;int j;p=L->next;j=0;while(p!=NULL){j++;p=p->next;}return j;}void LinkListPrint(LinkList L){LinkList p;p=L->next;if(p==NULL) printf("单链表为空表\n");else{printf("链表中的元素为:\n");while(p!=NULL){printf("%d ",p->data);p=p->next;}}printf("\n");}void Mergelist_L(LinkList La,LinkList Lb,LinkList Lc) {LNode *pa,*pb,*pc,*p;pa=La->next;pb=Lb->next;Lc=La;pc=Lc;while(pa&&pb){if(pa->data<=pb->data){pc->next=pa;pc=pa;pa=pa->next;}else {pc->next=pb;pc=pb;pb=pb->next;}}pc->next=pa?pa:pb;p=Lc->next;printf("合并结果:");while(p) {printf("%4d",p->data);p=p->next;}free(Lb);}int scan(){int d;printf("请选择你所要执行的单向链表的基本操作:\n1.插入元素;2.删除元素;3.访问元素;4.两个单向链表的合并.\n");printf("其他键退出程序……");printf("\n");scanf("%d",&d);return(d);}void main(){ LinkList La,Lb,Lc;int quit=0;int i,locate;ElemType e;LinkList L,p;L=CreatLinkList();while(!quit)switch(scan()){case 1:printf("请输入插入元素的位置和值(中间以空格或回车分隔):\n");scanf("%d%d",&i,&e);LinkListInsert(L,i,e);LinkListPrint(L);break;case 2:if(LinkListLength(L)==0)printf("链表已经为空,不能删除\n\n");else{printf("请输入待删除元素的位置:\n");scanf("%d",&i);LinkListDelete(L,i);}LinkListPrint(L);break;case 3:printf("请输入待查询元素在链表中的位置:");scanf("%d",&i);p=LocateLinkList(L,i);if(p)printf("链表中第%d个元素的值为:%d\n",i,p->data);elseprintf("查询位置不正确\n\n");break;case 4:La=CreatLinkList();Lb=CreatLinkList();Mergelist_L( La, Lb, Lc);printf("\n");break;default:quit=1;printf("操作结束!");printf("\n");}}3.单向循环链表的基本操作（单向链表的插入、删除、查找操作）#include<stdio.h>#include<malloc.h>typedef int ElemType;#define OK 1#define ERROR 0#define flag 0typedef struct LNode{ElemType data;struct LNode *next;} LNode,*LinkList;LinkList InitLinkList(){LinkList L;L=(LinkList)malloc(sizeof(LNode));L->next=L;return L;}LinkList LocateLinkList(LinkList L,int i){LinkList p;int j;p=L->next;j=1;while(p!=L&&j<i){p=p->next; j++;}if (j==i)return p;else return NULL;}void LinkListInsert(LinkList L, int i, ElemType e)//插入元素{LinkList p,s;int j;j=1;p=L;while(p->next!=L&&j<i){p=p->next;j++;}if(p==L||j>i)printf("插入位置不正确\n");else {s=(LNode *)malloc(sizeof(LNode));s->data=e;s->next=p->next;p->next=s;printf("%d已插入到链表中\n",e);}}void LinkListDelete(LinkList L,int i) //删除元素{LinkList p,q;int j;j=1;p=L;while(p->next!=L&&j<i){p=p->next;j++;}if(p->next==L)printf("删除位置不正确\n");else{q=p->next;p->next=q->next;free(q);printf("第%d个元素已从链表中删除\n",i);}}LinkList CreatLinkList( )//建立单向链表{LinkList L=InitLinkList(),p,r;ElemType e;r=L;printf("请依次输入链表中的元素,输入0结束\n"); scanf("%d",&e);while (e!=flag){p=(LinkList)malloc(sizeof(LNode));p->data=e;r->next=p;r=p;scanf("%d",&e);}r->next=L;return L;}int LinkListLength(LinkList L){LinkList p;int j;p=L->next;j=0;while(p!=L){j++;p=p->next;}return j;}void LinkListPrint(LinkList L){LinkList p;p=L->next;printf("链表中的元素为:\n");while(p!=L){printf("%d ",p->data);p=p->next;}printf("\n");}int scan(){int d;printf("请选择你所要执行的单向链表的基本操作:\n1.插入元素;2.删除元素;3.访问元素.\n");printf("其他键退出程序……");printf("\n");scanf("%d",&d);return(d);}void main(){int quit=0;int i;ElemType e;LinkList L,p;L=CreatLinkList();while(!quit)switch(scan()){case 1:printf("请输入插入元素的位置和值(中间以空格或回车分隔):\n");scanf("%d%d",&i,&e);LinkListInsert(L,i,e);LinkListPrint(L);break;case 2:if(LinkListLength(L)==0)printf("链表已经为空,不能删除\n\n");else{printf("请输入待删除元素的位置:\n");scanf("%d",&i);LinkListDelete(L,i);}LinkListPrint(L);break;case 3:printf("请输入待查询元素在链表中的位置:");scanf("%d",&i);p=LocateLinkList(L,i);if(p)printf("链表中第%d个元素的值为:%d\n",i,p->data);elseprintf("查询位置不正确\n\n");break;default:quit=1;printf("操作结束!");printf("\n");}}4.双向链表的基本操作（双向链表的插入、删除、查找以及并表操作）#include<stdio.h>#include<malloc.h>#define flag 0typedef int status;typedef int ElemType;typedef struct DuLNode{ElemType data;struct DuLNode *prior;struct DuLNode *next;}DuLNode,*DuLinkList;DuLinkList InitDuLinkList(){DuLinkList L;L=(DuLinkList)malloc(sizeof(DuLNode));L->next=L->prior=NULL;return L;}DuLinkList CreatDuLinkList(){DuLinkList L=InitDuLinkList(),p,r;ElemType e;r=L;printf("请依次输入链表中的元素,输入0结束\n");scanf("%d",&e);while (e!=flag){p=(DuLinkList)malloc(sizeof(DuLNode));p->data=e;r->next=p;p->prior=r->next;r=p;scanf("%d",&e);}r->next=NULL;return L;}void ListInsert_DuL(DuLinkList L, int i, ElemType e){ DuLinkList p,s;int j;j=1;p=L;while(p&&j<i){p=p->next;j++;}if(p==NULL||j>i)printf("插入位置不正确\n");else {s=(DuLinkList)malloc(sizeof(DuLNode));s->data=e;s->next=p->next; p->next->prior=s;s->prior=p; p->next=s;printf("%d已插入到双向链表中\n",e); }}void ListDelete_DuL(DuLinkList L,int i) //删除元素{DuLinkList p,q;int j;j=1;p=L;while(p->next&&j<i){p=p->next;j++;}if(p->next==NULL)printf("删除位置不正确\n");else{q=p->next;p->next=q->next;q->next->prior=p;free(q);printf("第%d个元素已从链表中删除\n",i); }}void LinkListPrint_DuL(DuLinkList L){DuLinkList p;p=L->next;if(p==NULL) printf("双链表为空表\n");else{printf("链表中的元素为:\n");while(p!=NULL){printf("%d ",p->data);p=p->next;}}printf("\n");}int DuLinkListLength(DuLinkList L){DuLinkList p;int j;p=L->next;j=0;while(p!=NULL){j++;p=p->next;}return j;}DuLinkList LocateDuLinkList(DuLinkList L,int i) {DuLinkList p;int j;p=L->next;j=1;while(p!=NULL&&j<i)p=p->next; j++;}if (j==i)return p;else return NULL;}void Mergelist_L(DuLinkList La,DuLinkList Lb,DuLinkList Lc){DuLNode *pa,*pb,*pc,*p;pa=La->next;pb=Lb->next;Lc=La;pc=Lc;while(pa&&pb){if(pa->data<=pb->data){pc->next=pa;pc=pa;pa=pa->next;}else {pc->next=pb;pc=pb;pb=pb->next;}}pc->next=pa?pa:pb;p=Lc->next;printf("合并结果:");while(p) {printf("%4d",p->data);p=p->next;}free(Lb);}int scan(){int d;printf("请选择你所要执行的双向链表的基本操作:\n1.插入元素;2.删除元素;3.访问元素;4.两个双向链表的合并.\n");printf("其他键退出程序……");printf("\n");scanf("%d",&d);return(d);}void main(){int quit=0;int i;ElemType e;DuLinkList L,p;DuLinkList La,Lb,Lc;L=CreatDuLinkList();while(!quit){switch(scan())case 1:printf("请输入插入元素的位置和值(中间以空格或回车分隔):\n");scanf("%d%d",&i,&e);ListInsert_DuL(L,i,e);LinkListPrint_DuL(L);break;case 2:if(DuLinkListLength(L)==0)printf("链表已经为空,不能删除\n\n");else{printf("请输入待删除元素的位置:\n");scanf("%d",&i);ListDelete_DuL(L,i);}LinkListPrint_DuL(L);break;case 3:printf("请输入待查询元素在链表中的位置:");scanf("%d",&i);p=LocateDuLinkList(L,i);if(p)printf("链表中第%d个元素的值为:%d\n",i,p->data);elseprintf("查询位置不正确\n\n");break;case 4:La=CreatDuLinkList();Lb=CreatDuLinkList();Mergelist_L( La, Lb, Lc);printf("\n");break;default:quit=1;printf("操作结束!");printf("\n");}}5.双向循环链表的基本操作（双向循环链表的插入、删除以及访问操作）#include<stdio.h>#include<malloc.h>#define flag 0typedef int status;typedef int ElemType;typedef struct DuLNode{ElemType data;struct DuLNode *prior;struct DuLNode *next;}DuLNode,*DuLinkList;DuLinkList InitDuLinkList(){DuLinkList L;L=(DuLinkList)malloc(sizeof(DuLNode));L->next=L; L->prior=L;return L;}DuLinkList CreatDuLinkList(){DuLinkList L=InitDuLinkList(),p,r;ElemType e;r=L;printf("请依次输入链表中的元素,输入0结束\n"); scanf("%d",&e);while (e!=flag){p=(DuLinkList)malloc(sizeof(DuLNode));p->data=e;r->next=p;p->prior=r->next;r=p;scanf("%d",&e);}r->next=L; L->prior=r;return L;}void ListInsert_DuL(DuLinkList L, int i, ElemType e){ DuLinkList p,s;int j;j=1;p=L;while(j<i){p=p->next;j++;}if(j>i)printf("插入位置不正确\n");else {s=(DuLinkList)malloc(sizeof(DuLNode));s->data=e;s->next=p->next; p->next->prior=s;s->prior=p; p->next=s;printf("%d已插入到双向循环链表中\n",e); }}void ListDelete_DuL(DuLinkList L,int i) //删除元素{DuLinkList p,q;int j;j=1;p=L;while(p->next!=L&&j<i){p=p->next;j++;}if(p->next==L)printf("删除位置不正确\n");else{q=p->next;p->next=q->next;q->next->prior=p;free(q);printf("第%d个元素已从双向循环链表中删除\n",i); }}void LinkListPrint_DuL(DuLinkList L){DuLinkList p;p=L->next;if(p->next==L) printf("双链表为空表\n");else{printf("链表中的元素为:\n");while(p!=L){printf("%d ",p->data);p=p->next;}}printf("\n");}int DuLinkListLength(DuLinkList L){DuLinkList p;int j;p=L->next;j=0;while(p->next!=L){j++;p=p->next;}return j;}DuLinkList LocateDuLinkList(DuLinkList L,int i){DuLinkList p;int j=1;p=L->next;while(p->next!=L&&j<i){p=p->next; j++;}if (j==i)return p;else return NULL;}int scan(){int d;printf("请选择你所要执行的双向链表的基本操作:\n1.插入元素;2.删除元素;3.访问元素.\n");printf("其他键退出程序……");printf("\n");scanf("%d",&d);return(d);}void main(){ int quit=0;int i,locate;ElemType e;DuLinkList L,p;L=CreatDuLinkList();while(!quit)switch(scan()){case 1:printf("请输入插入元素的位置和值(中间以空格或回车分隔):\n");scanf("%d%d",&i,&e);ListInsert_DuL(L,i,e);LinkListPrint_DuL(L);break;case 2:if(DuLinkListLength(L)==0)printf("链表已经为空,不能删除\n\n");else{printf("请输入待删除元素的位置:\n");scanf("%d",&i);ListDelete_DuL(L,i);}LinkListPrint_DuL(L);break;case 3:printf("请输入待查询元素在链表中的位置:");scanf("%d",&i);p=LocateDuLinkList(L,i);if(p)printf("链表中第%d个元素的值为:%d\n",i,p->data);elseprintf("查询位置不正确\n\n");break;default:quit=1;printf("操作结束!");printf("\n");}}【小结讨论】1.通过实验，我加深了对C的工作环境及其基本操作，进一步掌握了基本函数的调用以及使用方法。

数据结构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;｝｀｀｀实验结果：成功实现顺序表的初始化、插入、删除、查找等操作，输出结果符合预期。

数据结构实验报告——线性表

实验报告：线性表的基本操作实验1：实现顺序表各种基本运算的算法一、实验目的学会并运用顺序表存储结构及各种运算。

二、实验环境VC++6.0三、实验准备(1) 复习课件中理论知识(2)练习课堂所讲的例子四、实验内容编写一个程序实现SqList.cpp,实现顺序表基本运算，并在此基础上设计个主程序exp1.cpp，完成如下功能：（1）初始化顺序表L;（2）依次插入a、b、c、d、e元素；（3）输出顺序表L;（4）输出顺序表L长度；（5）判断顺序表L是否为空：（6）输出顺序表L的第3个元素；（7）输出元素a的位置；（8）在第4个位置上插入f元素；（9）输出顺序表L；（10）删除顺序表L的第3 个元素；（11）输出顺序表L;（12）顺序表L;五、实验步骤1、构造一个空的线形表并分配内存空间Status InitList_Sql(SqList &L){L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!L.elem) exit(OVERFLOW);L.length=0; L.listsize=LIST_INIT_SIZE; return OK; }2、求线性表的长度Status ListLength(SqList L) {return L.length; }3、线性表清空void ClearList(SqList &L){ L.length = 0; }4、在顺序线形表 L 中第 i 个位置之前插入新的元素 eStatus ListInsert_Sq(SqList &L,int i,ElemType e)5、查找'm'在顺序表中的位序e = 'm'; i = LocateElem_Sq(L,e);printf("元素 m 在顺序表中的位序是：%d\n",i);6、在第4个位置上插入f元素printf("（在第 4 个元素位置上插入 f 元素\n");ListInsert_Sq(L,4,'f');7、删除第 3 个元素printf("（删除顺序表 L 中第 3 个元素:"); ListDelete_Sq(L, 3, e);printf("被删除的第 3 个元素值是：%c",e);8、重新申请空间ElemType*newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof( ElemType)); if(!newbase) exit(OVERFLOW);L.elem=newbase;新的存储空间基址 L.listsize+=LISTINCREMENT;9、初始化并插入元素InitList_Sql(L); printf("依次插入 a,b,c,d,e 元素\n");10、输出顺序表、释放顺序表printf("输出顺序表 L:"); ListTraverse(L); printf("（释放顺序表L\n"); DestroyList(L);六、实验总结通过该实验的学习，对课堂内容再次巩固，对顺序表也有了更深的了解。

数据结构线性表试验报告（最终定稿）

数据结构线性表试验报告（最终定稿）第一篇：数据结构线性表试验报告线性表上机实习1、实验目的（1）熟悉将算法转换为程序代码的过程。

（2）了解顺序表的逻辑结构特性，熟练掌握顺序表存储结构的C 语言描述方法。

（3）熟练掌握顺序表的基本运算：查找、插入、删除等，掌握顺序表的随机存取特性。

（4）了解线性表的链式存储结构，熟练掌握线性表的链式存储结构的C语言描述方法。

（5）熟练掌握线性链表（单链表）的基本运算：查找、插入、删除等，能在实际应用中灵活选择适当的链表结构。

2、实验要求（1）熟悉顺序表的插入、删除和查找。

（2）熟悉单链表的插入、删除和查找。

3、实验内容: ① 顺序表（1）抽象数据类型定义typedef struct {TypeData data[maxsize];//容量为maxsize的静态顺手表int n;//顺序表中的实际元素个数}SeqList;//静态顺序表的定义在本次实验中，首先建立一个空的静态顺序表，然后键盘输入数据存入表中，然后进入菜单选择界面，通过不同的数字输入，实现对顺序表，删除，插入，查找，显示等操作。

（2）存储结构定义及算法思想在顺序表结构体的定义中，typedef int TypeData 为整型，存储结构如下：for(n=0;ncout<<“请输入线性表数据”<cin>>L.data[n];//顺序将数据存入顺序表}//其他存储与此类似，都是直接赋值与数组的某一位插入版块子函数：void insert(SeqList &L)//插入数据 {int a,b,c,k;cout<<“请输入插入的数及其插入的位置”<cin>>a>>b;if(b<=0||b>(L.n+1)){cout<<“不能在该位置插入”<k=L.data[b-1];L.data[b-1]=a;c=L.n;L.n=L.n+1;while(c>b){L.data[c]=L.data[c-1];c--;//通过循环，实现插入位置后的数据挨个往后移动一位}L.data[b]=k;} 顺序表的插入与删除操作类似，在插入与删除后，都要循环调整后面数组的每一位元素，同时记录数据元素的长度的标示符也要跟着改变。

数据结构线性表实验报告

数据结构线性表实验报告数据结构线性表实验报告1.简介本实验报告旨在介绍数据结构中线性表的实现和应用。

线性表是一种重要的数据结构，它的特点是数据元素之间存在一对一的前后关系，且具有唯一的起点和终点。

本实验通过实现线性表的基本操作，加深对线性表的理解，并通过实例应用展示线性表在实际问题中的应用。

2.实验环境本次实验采用的是编程语言C，并搭配使用一些常用的开发工具和库。

具体环境如下：________●操作系统：________Windows 10●编程语言：________C●开发工具：________Visual Studio Code●辅助库：________Stdio.h、stdlib.h、conio.h3.实验内容3.1 线性表的定义和基本操作3.1.1 线性表的定义线性表是由n（n ≥ 0）个数据元素组成的有限序列，数据元素之间存在一对一的前后关系。

3.1.2 线性表的基本操作●初始化线性表：________创建一个空的线性表。

●插入元素：________在指定位置插入一个新的元素。

●删除元素：________删除指定位置的元素。

●查找元素：________根据值或位置查找指定元素。

●修改元素：________根据位置修改指定元素的值。

●清空线性表：________将线性表中的所有元素清空。

3.2 线性表的顺序存储结构3.2.1 顺序存储结构的定义顺序存储结构是指使用一段连续的存储空间，依次存储线性表中的元素。

3.2.2 顺序存储结构的实现●初始化顺序表：________创建一个空的顺序表，并指定最大容量。

续元素依次后移。

●删除元素：________删除指定位置的元素，并将后续元素依次前移。

●查找元素：________根据值或位置查找指定元素，并返回其位置或值。

●修改元素：________根据位置修改指定元素的值。

●清空顺序表：________将顺序表中的所有元素清空。

●扩容：________当顺序表容量不足时，自动进行扩容。

数据结构--实验报告线性表的基本操作

数据结构..实验报告线性表的基本操作数据结构实验报告线性表的基本操作1.引言本实验报告旨在介绍线性表的基本操作。

线性表是一种常见的数据结构，它是一组有限元素的有序集合，其中每个元素之间存在一个特定的顺序关系。

线性表的操作包括插入、删除、查找等，这些操作对于有效地管理和利用数据非常重要。

2.实验目的本实验的目的是通过实践理解线性表的基本操作，包括初始化、插入、删除、查找等。

通过编写相应的代码，加深对线性表的理解，并掌握相应的编程技巧。

3.实验内容3.1 初始化线性表初始化线性表是指创建一个空的线性表，为后续的操作做准备。

初始化线性表的方法有多种，如顺序表和链表等。

下面以顺序表为例进行说明。

顺序表的初始化包括定义表头指针和设置表的长度等操作。

3.2 插入元素插入元素是指将一个新的元素插入到线性表的指定位置。

插入元素有两种情况：插入到表的开头和插入到表的中间。

插入元素的操作包括移动其他元素的位置以腾出空间，并将新的元素插入到指定位置。

3.3 删除元素删除元素是指将线性表中的某个元素删除。

删除元素有两种情况：删除表的开头元素和删除表的中间元素。

删除元素的操作包括将被删除元素的前一个元素与后一个元素进行连接，断开被删除元素与表的联系。

3.4 查找元素查找元素是指在线性表中寻找指定的元素。

查找元素的方法有多种，如遍历线性表、二分查找等。

查找元素的操作包括比较目标元素与线性表中的元素进行匹配，直到找到目标元素或遍历完整个线性表。

4.实验步骤4.1 初始化线性表根据线性表的类型选择相应的初始化方法，如创建一个空的顺序表并设置表的长度。

4.2 插入元素输入要插入的元素值和插入的位置，判断插入的位置是否合法。

如果合法，移动其他元素的位置以腾出空间，将新的元素插入到指定位置。

如果不合法，输出插入位置非法的提示信息。

4.3 删除元素输入要删除的元素值，判断元素是否在线性表中。

如果在，则找到目标元素的前一个元素和后一个元素，进行连接删除操作。

数据结构--实验报告线性表的基本操作

数据结构--实验报告线性表的基本操作数据结构--实验报告线性表的基本操作一、引言本实验报告旨在通过实际操作，掌握线性表的基本操作，包括初始化、插入、删除、查找等。

线性表是最基本的数据结构之一，对于理解和应用其他数据结构具有重要的作用。

二、实验目的1·了解线性表的定义和基本特性。

2·掌握线性表的初始化操作。

3·掌握线性表的插入和删除操作。

4·掌握线性表的查找操作。

5·通过实验巩固和加深对线性表的理解。

三、线性表的基本操作1·初始化线性表线性表的初始化是将一个线性表变量设置为空表的过程。

具体步骤如下：（1）创建一个线性表的数据结构，包括表头指针和数据元素的存储空间。

（2）将表头指针指向一个空的数据元素。

2·插入元素插入元素是向线性表中指定位置插入一个元素的操作。

具体步骤如下：（1）判断线性表是否已满，如果已满则无法插入元素。

（2）判断插入位置是否合法，如果不合法则无法插入元素。

（3）将插入位置及其后面的元素都向后移动一个位置。

（4）将待插入的元素放入插入位置。

3·删除元素删除元素是从线性表中删除指定位置的元素的操作。

具体步骤如下：（1）判断线性表是否为空，如果为空则无法删除元素。

（2）判断删除位置是否合法，如果不合法则无法删除元素。

（3）将删除位置后面的元素都向前移动一个位置。

（4）删除最后一个元素。

4·查找元素查找元素是在线性表中查找指定元素值的操作。

具体步骤如下：（1）从线性表的第一个元素开始，逐个比较每个元素的值，直到找到目标元素或遍历完整个线性表。

（2）如果找到目标元素，则返回该元素的位置。

（3）如果未找到目标元素，则返回找不到的信息。

四、实验步骤1·初始化线性表（1）定义线性表的数据结构，包括表头指针和数据元素的存储空间。

（2）将表头指针指向一个空的数据元素。

2·插入元素（1）判断线性表是否已满。

C语言-线性表实验报告

一．实验名称1.线性表基本操作；2.处理约瑟夫环问题二．试验目的：1．熟悉C语言的上机环境,掌握C语言的基本结构.2．定义单链表的结点类型。

3．熟悉对单链表的一些基本操作和具体的函数定义.4．通过单链表的定义掌握线性表的链式存储结构的特点.5．熟悉对单链表的一些其它操作。

三．实验内容1.编制一个演示单链表初始化、建立、遍历、求长度、查询、插入、删除等操作的程序.2。

编制一个能求解除约瑟夫环问题答案的程序.实验一线性表表的基本操作问题描述：1. 实现单链表的定义和基本操作。

该程序包括单链表结构类型以及对单链表操作的具体的函数定义程序中的单链表（带头结点）结点为结构类型，结点值为整型。

/＊定义DataType为int类型*/typedef int DataType；/* 单链表的结点类型＊/typedef struct LNode{DataType data;struct LNode ＊next;｝LNode,＊LinkedList；LinkedList LinkedListInit（）//初始化单链表void LinkedListClear（LinkedList L）// 清空单链表int LinkedListEmpty(LinkedList L）//检查单链表是否为空void LinkedListTraverse（LinkedList L）// 遍历单链表int LinkedListLength(LinkedList L）//求单链表的长度/＊从单链表表中查找元素＊/LinkedList LinkedListGet(LinkedList L，int i）/＊从单链表表中查找与给定元素值相同的元素在链表中的位置*/int LinkedListLocate(LinkedList L, DataType x）void LinkedListInsert（LinkedList L,int i，DataType x）//向单链表中插入元素/* 从单链表中删除元素＊/void LinkedListDel（LinkedList L,DataType x）/＊用尾插法建立单链表*/LinkedList LinkedListCreat( ）2。

数据结构--实验报告线性表的基本操作

数据结构--实验报告线性表的基本操作数据结构实验报告[引言]在本次实验中,我们将学习线性表的基本操作,包括插入、删除、查找等。

通过实践操作,加深对线性表的理解和掌握。

[实验目的]1．学习线性表的基本概念和操作。

2.熟悉线性表的插入、删除和查找等基本操作。

3.掌握线性表的实现方式及其相应的算法。

［实验内容]１.线性表的定义与表示1．1 线性表的定义1.2 线性表的顺序存储结构１.3 线性表的链式存储结构2.线性表的基本操作２．１初始化线性表2.２判断线性表是否为空2.3 插入操作２.3.1 在指定位置插入元素2.3.2 在表尾插入元素2．4 删除操作2．4.1 删除指定位置的元素2．４．2 删除指定值的元素2．5 查找操作2.5.1 按位置查找元素2．5.2 按值查找元素２．6 修改操作2．６．１修改指定位置的元素 2.6.2 修改指定值的元素2.7 清空线性表2．8 销毁线性表[实验步骤]1.初始化线性表1.1 创建一个空的线性表对象１.2 初始化线性表的容量和长度2.插入操作2.１在指定位置插入元素2.1.1 检查插入位置的合法性2.1.2 将插入位置后的元素依次后移2.1．３在指定位置插入新元素2.2 在表尾插入元素２.2．1 将表尾指针后移2.2.2 在表尾插入新元素３.删除操作3.1 删除指定位置的元素３.1.1 检查删除位置的合法性3.１．2 将删除位置后的元素依次前移3.1.3 修改线性表的长度3.2 删除指定值的元素3.2.1 查找指定值的元素位置3.２.２调用删除指定位置的元素操作4.查找操作４.1 按位置查找元素4．1．1 检查查找位置的合法性4.1.2 返回指定位置的元素4.2 按值查找元素4.2．1 从头到尾依次查找元素4.2．2 返回第一个匹配到的元素5.修改操作5.１修改指定位置的元素５.１.1 检查修改位置的合法性5.1.２修改指定位置的元素值5.２修改指定值的元素5.2．1 查找指定值的元素位置5．２．２调用修改指定位置的元素操作6.清空线性表6．1 设置线性表长度为07.销毁线性表７.1 释放线性表的内存空间[实验结果]使用线性表进行各种基本操作的测试,并记录操作的结果和运行时间。

数据结构线性表实验报告

数据结构线性表实验报告数据结构线性表实验报告实验目的：本次实验主要是为了学习和掌握线性表的基本操作和实现方式。

通过实验，我们可以加深对线性表的理解，并能够熟悉线性表的基本操作。

实验设备与环境：本次实验所需的设备包括计算机和编程环境。

我们选择使用C语言来实现线性表的操作，并在Visual Studio Code编程软件中进行编写和调试。

实验内容：1.线性表的定义和基本操作1.1 线性表的定义：线性表是一种有序的数据结构，其中的元素按照一定的顺序存储，可以插入、删除和访问元素。

1.2 线性表的基本操作：1.2.1 初始化线性表：创建一个空的线性表。

1.2.2 判断线性表是否为空：判断线性表是否不含有任何元素。

1.2.3 获取线性表的长度：返回线性表中元素的个数。

1.2.4 在线性表的指定位置插入元素：在线性表的第i个位置插入元素x，原第i个及其之后的元素依次后移。

1.2.5 删除线性表中指定位置的元素：删除线性表中第i个位置的元素，原第i+1个及其之后的元素依次前移。

1.2.6 获取线性表中指定位置的元素：返回线性表中第i个位置的元素的值。

1.2.7 清空线性表：将线性表中的元素全部删除，使其变为空表。

2.线性表的顺序存储结构实现2.1 线性表的顺序存储结构：使用数组来实现线性表的存储方式。

2.2 线性表的顺序存储结构的基本操作：2.2.1 初始化线性表：创建一个指定长度的数组，并将数组中的每个元素初始化为空值。

2.2.2 判断线性表是否为空：判断线性表的长度是否为0。

2.2.3 获取线性表的长度：返回线性表数组的长度。

2.2.4 在线性表的指定位置插入元素：将要插入的元素放入指定位置，并将原位置及其之后的元素依次后移。

2.2.5 删除线性表中指定位置的元素：将指定位置的元素删除，并将原位置之后的元素依次前移。

2.2.6 获取线性表中指定位置的元素：返回指定位置的元素的值。

2.2.7 清空线性表：将线性表数组中的每个元素赋空值。

数据结构--实验报告线性表的基本操作

数据结构--实验报告线性表的基本操作线性表的基本操作实验报告1.引言线性表是最基本的数据结构之一，它可以用来存储一系列具有相同数据类型的元素。

本实验旨在通过实践掌握线性表的基本操作，包括插入、删除、查找和修改元素等。

本文档将详细介绍实验所需的步骤和操作方法。

2.实验目的1.掌握线性表的插入和删除操作。

2.理解线性表的查找和修改元素的方法。

3.熟悉线性表的基本操作在算法中的应用。

3.实验环境本实验使用编程语言/软件名称作为开发环境，具体要求如下：________●操作系统：________操作系统名称和版本●编程语言：________编程语言名称和版本4.实验步骤4.1 初始化线性表在程序中创建一个空的线性表，用于存储元素。

实现方法：________具体的初始化方法和代码示例 4.2 插入元素在线性表中指定位置插入一个新元素。

实现方法：________具体的插入元素方法和代码示例 4.3 删除元素删除线性表中指定位置的元素。

实现方法：________具体的删除元素方法和代码示例 4.4 查找元素在线性表中查找指定元素的位置。

实现方法：________具体的查找元素方法和代码示例 4.5 修改元素修改线性表中指定位置的元素值。

实现方法：________具体的修改元素方法和代码示例5.实验结果在完成上述步骤后，我们得到了一个可以进行插入、删除、查找和修改元素的线性表。

具体操作结果如下：________●插入元素操作结果：________插入元素的具体操作结果●删除元素操作结果：________删除元素的具体操作结果●查找元素操作结果：________查找元素的具体操作结果●修改元素操作结果：________修改元素的具体操作结果6.实验总结通过本次实验，我们深入理解了线性表的基本操作，并且掌握了这些操作的实现方法。

线性表在实际应用中十分常见，熟练掌握线性表的操作对于开发高效的算法和数据结构具有重要意义。

数据结构线性表实验报告

实验一线性表一、实验目的1.掌握实现线性表的基本操作方法；2.掌握线性表的基本操作:建表、插入、删除、输出等运算在顺序存储结构和链式存储结构上的实现；3.通过本次实习加深对高级语言C语言的使用(特别是函数参数、指针类型、链表的使用)。

熟悉线性表的基本运算在两种存储结构(顺序结构和链式结构)上的实现。

二、实验环境装有VisualC++6.0的普通PC机三、源程序#include"string.h"#include "stdio.h"#include "stdlib.h"#include "conio.h"#define MaxLine 100 /*顺序存储的最大个数*/ typedef int ElemType;typedef struct SqList{ElemType data[MaxLine];/*存放顺序表的数组*/ int length;/*顺序表的长度*/} L;/*初始化顺序表*/void InitList(SqList&L){L.length = 0;//L.length =0;}/*得到顺序表的长度*/int GetLength(SqList &L){return L.length;}/*得到顺序表中的第i个元素*/ElemType GetElem(SqList &L,int i){if(i < 1 || i > L.length) 开始{printf("error");exit(1);}return L.data[i-1];}void ListInsert(SqList &L,int i,ElemType x)/*添加线性表中第i个位置上的元素,i从1开始*/{int j;if(i < 1 || i > L.length+1) /*检查添加位置的合法性*/{printf("error");exit(1);}if(L.length >= MaxLine){printf("overflow!");exit(1);}j = L.length;while(j>=i)/*此处语句相对参考语句有较大改变*/{L.data[j]=L.data[j-1];j--;}L.data[i-1] = x;L.length++;}void ListDelete(SqList &L,int i) /* 删除线性表中第i个位置上的元素*/ {int j;if(i<1 || i>L.length) /* 检查空表及删除位置的合法性*/ {printf ("不存在第i个元素");exit(0);}for(j=i;j<=L.length-1;j++)L.data[j-1]=L.data[j]; /* 向前移动元素*/L.length--;}int main(){FILE *fp;struct SqList A;InitList(A);/*初始化顺序表*/int Judge2=0;printf(" ***线性表操作实验***\n \n\n请输入0对长度为8的线性表输入数据或者其他任意数进行其他操作^_^\n");scanf("%d",&Judge2);if(Judge2==0){int t = 1,d=1;for(t=1;t<=8;t++)/*此处为顺序表首先输入8个元素*/{printf("请输入第%d个线性表元素:",t);scanf("%d",&d);ListInsert(A,t,d);}}int Judge=0;printf("输入0结束程序或者输入其他任意数继续对该表进行操作^_^\n");scanf("%d",&Judge);while(Judge)/*判断是结束程序还是要继续操作该顺序表*/{int a=0;int pos=0;int c=0;int Judge1=0;int P;/*给出顺序表操作选择菜单分别为输入，删除，显示长度，打印顺序表*/printf(" ***************\n *输入1进行插入*\n");printf(" *输入2进行删除*\n");printf(" *输入3显示长度*\n");printf(" *输入4打印该表*\n");printf(" *输入5保存数据*\n");printf(" *输入6进行排序*\n");printf(" *输入7查找数据*\n ***************\n");printf("请选择:");/*选择要进行的操作*/scanf("%d",&P);if(P==0)return 0;else if(P>=1&&P<=7)switch(P){case 1:printf("请输入想进行插入操作的位置:");/*选择待插入位置*/scanf("%d",&pos);int PP;printf("请输入待插入的元素:\n");/*输入要插入的元素*/scanf("%d",&PP);ListInsert(A,pos,PP);c=GetLength(A);printf("该线性表的长度为：%d!\n",c);/*此处选择是重新选择操作还是按顺序进行下一项操作*/printf("请输入0结束操作或者其他任意数继续其他操作^_^\n");scanf("%d",&Judge1);if(Judge1==1)continue;else break;case 2:printf("输入要删除元素的位置:");/*选择要删除的元素位置*/scanf("%d",&a);ListDelete(A,a);c=GetLength(A);printf("该线性表的长度为：%d!\n",c);/*此处选择是重新选择操作还是按顺序进行下一项操作*/printf("请输入0结束操作或者其他任意数继续进行其他操作^_^\n");scanf("%d",&Judge1);if(Judge1==1)continue;else break;case 3:c=GetLength(A);printf("该线性表的长度为：%d!\n",c);printf("请输入0结束操作或者其他任意数继续进行其他操作^_^\n");scanf("%d",&Judge1);if(Judge1==1)continue;else break;case 4:{c=GetLength(A);int d=0;printf("%s"," 该线性表数据记录如下\n");printf("%s","*****************************************************\n");for(int aa=0;aa<c;aa++){printf(" ");printf("%d \t",A.data[aa]); d++;/*打印该线性表*/if( d%4 ==0) printf("\n");}printf("\n");printf("%s","*****************************************************\n");printf("请输入0结束操作或者其他任意数继续进行其他操作^_^\n");scanf("%d",&Judge1);if(Judge1==1)continue;else break;}case 5:{fp=fopen("Test.txt","wt+");int i=0,j=0;fprintf(fp,"%s"," 文件Test数据记录\n");fprintf(fp,"%s","_________________________\n");for(i=0;i<GetLength(A);){fprintf(fp,"%d",A.data[i]);i++;fputc('\t',fp);j++;if(j%4==0) fputc(10,fp);} ;fprintf(fp,"%s","\n_________________________");fclose(fp);printf("相关数据已经存入文件Test.txt中^_^\n");printf("请输入0结束操作或者其他任意数继续进行其他操作^_^\n");scanf("%d",&Judge1);if(Judge1==1)continue;else break;}case 6:{int i,j,temp;for(i=0;i<GetLength(A)-1;i++)for(j=i+1;j<GetLength(A);j++) /*注意循环的上下限*/{if(A.data[i]>A.data[j]){temp=A.data[i];A.data[i]=A.data[j];A.data[j]=temp;}}c=GetLength(A);int d=0;printf("%s","排序后该线性表数据记录如下\n");printf("%s","**************************\n");for(int aa=0;aa<c;aa++){printf("%d \t",A.data[aa]); d++;/*打印该线性表*/if( d%4 ==0) printf("\n");}printf("\n");printf("%s","**************************\n");printf("请输入0结束操作或者其他任意数继续进行其他操作^_^\n");scanf("%d",&Judge1);if(Judge1==1)continue;else break;}case 7:{int value;printf("请输入待查找的数据：\n");scanf("%d",&value);for(int i=0;i<GetLength(A);){if(A.data[i] == value)printf("待查找的是表中第%d个数据%d^_^\n",i+1,value);else if(i>=(GetLength(A)-1)) printf("待查找的数据不存在+_+\n");i++;}printf("请输入0结束操作或者其他任意数继续进行其他操作^_^\n");scanf("%d",&Judge1);if(Judge1==1)continue;else break;}}printf("请输入0 结束程序或者输入其他任意数继续进行操作^_^\n");scanf("%d",&Judge);}return 0;}四、实验数据记录1，生成长度为8的线性表2，选择插入数据3，删除数据4，打印表5，保存数据6，排序7，查找数据五、实验总结实验在编写源程序是由于参考给的参考程序较多，但是参考程序存在一定的问题且相当不完善，走了弯路。

数据结构c语言实验报告

数据结构c语言实验报告数据结构C语言实验报告引言：数据结构是计算机科学中的重要概念，它是指一组数据的组织方式和存储结构，以及对这组数据进行操作的方法。

在本次实验中，我们将使用C语言来实现一些常见的数据结构，并测试其功能和性能。

一、线性表线性表是最基本的数据结构之一，它是一种有序的数据元素序列。

我们使用C语言中的数组来实现线性表，并实现了插入、删除、查找等操作。

通过实验，我们发现在插入和删除操作频繁的情况下，使用链表实现的线性表性能更好。

二、栈栈是一种特殊的线性表，它的插入和删除操作只能在同一端进行。

我们使用C语言中的数组来实现栈，并实现了入栈和出栈操作。

通过实验，我们发现栈在递归算法、表达式求值等场景中有着重要的应用。

三、队列队列也是一种特殊的线性表，它的插入操作在一端进行，删除操作在另一端进行。

我们使用C语言中的数组来实现队列，并实现了入队和出队操作。

通过实验，我们发现队列在模拟排队、调度算法等场景中有着广泛的应用。

四、二叉树二叉树是一种特殊的树形结构，每个节点最多有两个子节点。

我们使用C语言中的结构体来实现二叉树，并实现了先序、中序和后序遍历等操作。

通过实验，我们发现二叉树在搜索算法、排序算法等场景中有着重要的应用。

五、图图是一种复杂的非线性结构，它由节点和边组成。

我们使用C语言中的邻接矩阵和邻接表来实现图，并实现了深度优先搜索和广度优先搜索等操作。

通过实验，我们发现图在社交网络分析、路径规划等领域有着广泛的应用。

六、排序算法排序算法是数据结构中的重要内容，它用于将一组无序的数据按照某种规则进行排序。

我们使用C语言实现了常见的排序算法，如冒泡排序、插入排序、选择排序、快速排序等。

通过实验，我们比较了这些排序算法的性能和稳定性。

七、性能分析在实验过程中，我们使用了时间复杂度和空间复杂度来评估数据结构的性能。

时间复杂度表示算法执行所需的时间，空间复杂度表示算法执行所需的内存空间。

通过实验，我们了解了不同数据结构和算法的性能特点，为实际应用提供了参考依据。

数据结构--实验报告_线性表的基本操作备用

实验目的实验内容和要求源代码顺序表的代码单链表的代码测试结果顺序表的测试结果单链表的测试结果五、心得体会实验一线性表的基本操作及其应用一、实验目的1.帮助读者复习C++语言程序设计中的知识。

2.熟悉线性表的逻辑结构。

3.熟悉线性表的基本运算在两种存储结构上的实现。

4.掌握顺序表的存储结构形式及其描述和基本运算的实现。

5.熟练掌握动态链表结构及有关算法的设计二、实验内容题目一: 顺序表的基本操作[问题描述]实现顺序表的建立、求长度, 取元素、修改元素、插入、删除等顺序表的基本操作。

[基本要求]（1）依次从键盘读入数据, 建立带头结点的顺序表；（2）输出顺序表中的数据元素（3）求顺序表的长度；（4）根据指定条件能够取元素和修改元素；（5）实现在指定位置插入和删除元素的功能。

（6）根据算法, 将两个有序的顺序表合并成一个有序顺序表。

[测试数据] 由学生任意指定。

题目二: 单链表的基本操作[问题描述]实现带头结点的单链表的建立、求长度, 取元素、修改元素、插入、删除等单链表的基本操作。

[基本要求]（1）依次从键盘读入数据, 建立带头结点的单链表；（2）输出单链表中的数据元素（3）求单链表的长度；（4）根据指定条件能够取元素和修改元素；（5）实现在指定位置插入和删除元素的功能。

（6）根据算法, 将两个有序的单链表合并成一个有序单链表。

[测试数据]由学生任意指定。

三、源代码顺序表的基本操作#include<iostream>using namespace std;#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;typedef int ElemType;#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef struct { //结构体ElemType *elem;int length;int listsize;}SqList;SqList Lx;Status InitList_Sq(SqList &L) //分配空间{ L.elem=new ElemType[LIST_INIT_SIZE];if(!L.elem)exit(OVERFLOW);L.length =0;L.listsize=LIST_INIT_SIZE;return OK;}Status ListInsert(SqList &L,int i,ElemType e) //插入新元素{ int *q,*p;ElemType *newbase;if(i<1 || i>L.length+1) return ERROR;if(L.length>=L.listsize){ newbase=new ElemType[L.listsize+LISTINCREMENT];if(!newbase) exit(OVERFLOW);L.elem=newbase;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;}Status Listlength(SqList L) //长度{ int *p=L.elem; //判断线形表是否存在while(p){ return (L.length); }}Status GetElem(SqList L, int i,ElemType &e) //取元素{ if(i<1 || i>L.length)return ERROR;else{ e=L.elem[i-1];return e;}}void MergeList(SqList La,SqList Lb,SqList &Lc) //合并{ ElemType ai,bj;InitList_Sq(Lc);int i=1,j=1,k=0;int La_len,Lb_len;La_len=Listlength(La);Lb_len=Listlength(Lb);while((i<=La_len)&&(j<=Lb_len)){ GetElem(La,i,ai);GetElem(Lb,j,bj);if(ai<=bj){ ListInsert(Lc,++k,ai);++i; }else{ ListInsert(Lc,++k,bj);++j; }}while(i<=La_len){ GetElem(La,i++,ai);ListInsert(Lc,++k,ai);}while(j<=Lb_len){ GetElem(Lb,j++,bj);ListInsert(Lc,++k,bj);}}void show(SqList L,int i) //显示{ int j;ElemType k;cout<<"顺序表显示如下:"<<endl;for(j=0;j<i-1;j++){ k=L.elem[j];cout<<k<<"->"; }if(j==i-1 && i>0){ k=L.elem[j]; cout<<k; }cout<<endl;}void create(SqList &L,int n) //输入元素{ int e;for(int i=0;i<n;i++){ cin>>e;L.elem[i]=e;L.length=i+1; }}Status ListDelete_Sq(SqList &L,int i,ElemType &e) //删除{ ElemType *p, *q;if(i<1 || i>L.length) return ERROR;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 Listxiugei(SqList &L,int i,ElemType &e) //修改{ if(i<1 || i>L.length)return ERROR;else{ L.elem[i-1]=e;return OK; }}void shuru(SqList &L1) //顺序表的创建{ int a;InitList_Sq(L1);cout<<"请输入顺序表的长度: ";cin>>a;cout<<"请输入顺序表的元素(共"<<a<<"个)"<<endl;create(L1,a);show(L1,a);}void chaxun(SqList &L1) //取第i个位置的元素{ int j;ElemType e1;cout<<"请选择所要取出元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误, 请重新输入"<<endl;cout<<"请选择所要取出元素的位置:";cin>>j; }GetElem(L1,j,e1);cout<<"取出的元素为:"<<e1<<endl; }void xiugai(SqList &L1) //修改第i个位置的元素{ int a;int j; ElemType e1;a=L1.length;cout<<"请选择所要修改元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误, 请重新输入"<<endl;cout<<"请选择所要修改元素的位置:";cin>>j; }cout<<"要修改成的元素:";cin>>e1;Listxiugei(L1,j,e1);cout<<"修改后的顺序表数据:"<<endl;show(L1,a);}void shanchu(SqList &L1) //删除顺序表里的元素{ int a;int j; ElemType e1;a=L1.length;cout<<"请选择所要删除元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误, 请重新输入"<<endl;cout<<"请选择所要删除元素的位置:";cin>>j; }ListDelete_Sq(L1,j,e1);cout<<"修改后的顺序表数据:"<<endl;show(L1,a-1);}void charu(SqList &L1) //插入元素到顺序表里{ int a; int j; ElemType e1;a=L1.length;cout<<"请选择所要插入元素的位置:";cin>>j;while(j<0||j>Listlength(L1)){ cout<<"输入有误, 请重新输入"<<endl;cout<<"请选择所要插入元素的位置:";cin>>j; }cout<<"要插入的元素:";cin>>e1;ListInsert(L1,j,e1);cout<<"修改后的顺序表数据:"<<endl;show(L1,a+1);}void hebing(SqList &L3) //合并两个顺序表{ SqList L1,L2;int a,b;InitList_Sq(L1); InitList_Sq(L2);cout<<"请输入第一个有序表的长度: "; cin>>a;cout<<"请输入第一个有序表的元素(共"<<a<<"个)"<<endl;create(L1,a);show(L1,a);cout<<"请输入第二个有序表的长度: "; cin>>b;cout<<"请输入第二个有序表的元素(共"<<b<<"个)"<<endl;create(L2,b);show(L2,b);MergeList(L1,L2,L3);cout<<"合并后的有序表如下: "; show(L3,a+b);}void main() //主菜单{ int choice;for(;;){ cout<<" 顺序表的基本操作"<<endl;cout<<" 1.顺序表的创建"<<endl;cout<<" 2.顺序表的显示"<<endl;cout<<" 3.顺序表的长度"<<endl;cout<<" 4.取第i个位置的元素"<<endl;cout<<" 5.修改第i个位置的元素"<<endl;cout<<" 6.插入元素到顺序表里"<<endl;cout<<" 7.删除顺序表里的元素"<<endl;cout<<" 8.合并两个顺序表"<<endl;cout<<" 9.退出系统"<<endl;cout<<"请选择: ";cin>>choice;switch(choice){ case 1: shuru(Lx);break;case 2: show(Lx,Lx.length);break;case 3: cout<<"顺序表的长度:"<<Listlength(Lx)<<endl;break;case 4: chaxun(Lx);break;case 5: xiugai(Lx);break;case 6: charu(Lx);break;case 7: shanchu(Lx);break;case 8: hebing(Lx);break;case 9: cout<<"退出系统!"<<endl;exit(0);break;default : cout<<"输入有误, 请重新选择"<<endl;break; } }}单链表的基本操作#include<iostream>using namespace std;#define true 1#define false 0#define ok 1#define error 0#define overflow -2typedef int Status;typedef int ElemType;typedef struct LNode //存储结构{ ElemType data;struct LNode *next;}LNode,*LinkList;void CreateList(LinkList &L,int n) //尾插法创建单链表{ LinkList p;L=new LNode;L->next=NULL; //建立一个带头结点的单链表LinkList q=L; //使q指向表尾for(int i=1;i<=n;i++){ p=new LNode;cin>>p->data;p->next=NULL;q->next=p;q=p; }}Status GetElem(LinkList L,int i,ElemType &e)//取第i个元素{ LinkList p=L->next;int j=1;while(p&&j<i){ p=p->next;++j; }if(!p||j>i) return error; //第i个元素不存在e=p->data;return ok;}Status LinkInsert(LinkList &L,int i,ElemType e) //插入{ LinkList p=L;int j=0;while(p&&j<i-1){ p=p->next;++j; } //寻找第i-1个结点if(!p||j>i-1)return error; //i小于1或者大于表长加1 LinkList s=new LNode; //生成新结点s->data=e;s->next=p->next; //插入L中p->next=s;return ok;}Status ListDelete(LinkList &L,int i,ElemType &e) // 删除{ LinkList p=L;LinkList q;int j=0;while(p->next&&j<i-1){ //寻找第i个结点, 并令p指向其前驱p=p->next;++j; }if(!(p->next)||j>i-1) return error; //删除位置不合理q=p->next;p->next=q->next; //删除并释放结点e=q->data;delete(q);return ok;}void MergeList(LinkList &La,LinkList &Lb,LinkList &Lc){ //合并两个顺序链表LinkList pa,pc,pb;pa=La->next;pb=Lb->next;Lc=pc=La;while(pa&&pb){ if(pa->data<=pb->data){ pc->next=pa;pc=pa;pa=pa->next; }else{ pc->next=pb;pc=pb;pb=pb->next; }}pc->next=pa?pa:pb;delete(Lb);}void show(LinkList L) //显示{ LinkList p;p=L->next;while(p){ cout<<p->data<<"-->";p=p->next; }cout<<endl;}int Length(LinkList L,int i) //表长{ i=0;LinkList p=L->next;while(p){ ++i;p=p->next; }return i;}void xiugai(LinkList L) //修改{ int i,j=1;ElemType k;ElemType e,m;LinkList p=L->next;cout<<"请输入要修改的元素位置(0<i<length):";cin>>i;GetElem(L,i,e);cout<<"该位置的元素:"<<e<<endl;cout<<"修改后的元素值:";cin>>k;while(p&&j<i){ p=p->next;++j; }m=p->data;p->data=k;cout<<"修改后的单链表显示如下:"<<endl;show(L);}void hebing() //合并两个单链表{ int a,b;LinkList La,Lb,Lc;cout<<"请输入第一个有序链表的长度:"<<endl;cin>>a;cout<<"请输入第一个有序链表的元素共（"<<a<<"个）: "<<endl;CreateList(La,a);show(La);cout<<"请输入第二个有序链表的长度:"<<endl;cin>>b;cout<<"请输入第二个有序链表的元素共（"<<b<<"个）: "<<endl;CreateList(Lb,b);show (Lb);MergeList(La,Lb,Lc);cout<<"合并后的有序链表如下: "<<endl;show(Lc);}void main() //主函数{ int select;int x;ElemType y;LinkList list;for(;;){ cout<<" 单链表的基本操作"<<endl;cout<<" 1.单链表的创建"<<endl;cout<<" 2.单链表的显示"<<endl;cout<<" 3.单链表的长度"<<endl;cout<<" 4.取第i个位置的元素"<<endl;cout<<" 5.修改第i个位置的元素"<<endl;cout<<" 6.插入元素到单链表里"<<endl;cout<<" 7.删除单链表里的元素"<<endl;cout<<" 8.合并两个单链表"<<endl;cout<<" 9.退出系统"<<endl;cout<<"请选择:";cin>>select;switch(select){ case 1:cout<<"请输入单链表的长度:"<<endl;cin>>x;cout<<"请输入"<<x<<"个元素"<<endl;CreateList(list,x);break;case 2: cout<<"单链表显示如下:"<<endl;show(list);break;case 3: int s;cout<<"单链表的长度为:"<<Length(list,s)<<endl;break;case 4: cout<<"请选择所要取出元素的位置:";cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误, 请重新输入"<<endl;cout<<"请选择所要取出元素的位置:";cin>>x; }GetElem(list,x,y);cout<<"该位置的元素为:"<<y<<endl;break;case 5: xiugai(list); break;case 6: cout<<"请选择要插入的位置:"; cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误, 请重新输入"<<endl;cout<<"请选择所要插入元素的位置:";cin>>x; }cout<<"要插入的元素值:";cin>>y;LinkInsert( list,x,y);cout<<"插入后单链表显示如下:"<<endl;show(list);break;case 7: cout<<"请选择要删除的位置:"; cin>>x;while(x<0||x>Length(list,s)){ cout<<"输入有误, 请重新输入"<<endl;cout<<"请选择所要删除元素的位置:";cin>>x; }ListDelete(list,x,y);cout<<"要删除的元素值:"<<y<<endl;cout<<"删除后的单链表显示如下:"<<endl;show(list);break;case 8: hebing();break;case 9: exit(0);break;default : cout<<"输入有误, 请重新输入"<<endl;break;}}}四、测试结果顺序表的测试结果单链表的测试结果五、心得体会当听到老师说写数据结构实验报告时, 我有点惊讶, 才学了不到一个月, 就要写实验报告。

数据结构线性表操作实验报告

《数据结构》实验报告实验题目：线性表的操作实验目的：1.掌握上机调试线性表的基本方法；2.掌握线性表的一些基本操作；实验内容：将两个有序链表合并为一个有序链表一、需求分析1.实验程序中先创建两个有序链表，演示程序以用户和计算机的对话方式执行，即在计算机终端上显示“提示信息”之后，由用户在键盘上输入两个链表中的相应数据。

2.将两个链表合并时可按数据从大到小或从小到大合并，用户根据提示可选择一种排序方式。

3.程序执行命令包括：（1）构造链表；（2）输入数据；（3）合并两个链表，根据用户需求选择一种排序方式；（4）将合并结果输出；（5）结束4.测试数据：链表1数据为：2，4，6，7，10链表2数据为：1，3，5，6，7，12按从小到达合并为：1，2，3，4，5，6，6，7，7，10，12；按从大到小合并为：12，10，7，7，6，6，5，4，3，2，1；二、概要设计1.基本操作Linklist creat （）操作结果：构造一个链表，并输入数据，返回头节点指针。

void print(Linklist head)初始条件：链表已存在；操作结果：将链表输出。

void MergeList_1(Linklist La,Linklist Lb)初始条件：有序线性链表La 和Lb 已存在；操作结果：将La 和Lb 两个链表按从小到大的顺序合并。

void MergeList_2(Linklist La,Linklist Lb)初始条件：有序线性链表La 和Lb 已存在；操作结果：将La 和Lb 两个链表按从大到小的顺序合并。

2.本程序包括四个模块：（1）主程序模块；（2）链表数据输入模块；（3）链表合并模块；（4）链表输出模块；三、详细设计1.元素类型，节点类型，指针类型主程序模块数据输入按从小到大合并两链表按从大到小合并两链表将新链表输出将新链表输出typedef struct LNode //定义节点{int data;struct LNode *next;}LNode,* Linklist;2.每个模块的分析（1）主函数模块int main(){Linklist head1,head2;int i;printf("请输入链表1数据（由小到大，输入0表示输入结束）：\n");head1=creat(); //创建链表1，将头结点指针返回为head1printf("请输入链表2数据（由小到大，输入0表示输入结束）：\n");head2=creat();printf("请选择排序方式（输入1则从小到达合并，输入其它整数则按从大到小合并）：");scanf("%d",&i); //创建链表2，将头结点指针返回为head2if(i==1) //选择两种排序方式，如果输入1，则合并后按从小到大输出；输入其它数，合成链表按从大到小输出{printf("按小到大将两表合并得：\n");MergeList1(head1,head2); //将创建好的两表的头结点地址head1，head2作为函数参数}else{ printf("按从大到小将两表合并得：\n");MergeList2(head1,head2); //将创建好的两表的头结点地址head1，head2作为函数参数}return 0;}（2）数据输入创建链表模块Linklist creat() //创建链表函数，并将创建链表的头结点指针返回{Linklist head,p,s;int z=1,x;head=(LNode *) malloc(sizeof(LNode));p=head;while(z){scanf("%d",&x);if(x!=0) //输入0表示链表数据输入结束{s=(LNode *)malloc(sizeof(LNode));s->data=x;p->next=s;s->next=NULL;p=s;}elsez=0;}return(head);}（3）合并链表模块，两个函数分别表示两种排序方式，将链表合并后直接在函数中调用链表输出函数void print(Linklist head)将链表输出void MergeList_1(Linklist La,Linklist Lb)//已知链表La和Lb元素都按从小到大排列，将La和Lb合并成新链表，其中元素也按从小到大排列{Linklist pa,pb,pc,Lc;pa = La->next; pb = Lb->next;Lc = pc = La; //把La的头节点作为新建链表Lc的头结点while (pa && pb){if (pa->data <= pb->data){pc->next = pa;pc = pa;pa = pa->next;}else{pc->next = pb;pc = pb;pb = pb->next;}}pc->next = pa ? pa : pb; //插入剩余段print(Lc); //将链表Lc输出}void MergeList_2(Linklist La,Linklist Lb)//已知链表La和Lb的元素都按从小到大排列，合并La和Lb得到新链表，其中元素按照从大到小的顺序排列{Linklist pa,qa,pb,qb,Lc; //设指针qa,qb,分别作为pa,pb的前驱的指针pa=La->next;pb=Lb->next;Lc=La;Lc->next=NULL;while(pa&&pb){if(pa->data<=pb->data){qa=pa;pa=pa->next;qa->next=Lc->next;Lc->next=qa;}else{qb=pb;pb=pb->next;qb->next=Lc->next;Lc->next=qb;}}while(pa) //如果pa不为空，则将La链的剩余段倒叙插入到头节点的后面{qa=pa;pa=pa->next;qa->next=Lc->next;Lc->next=qa;}while(pb) //如果pb不为空，则将Lb链的剩余段倒叙插入到头结点的后面{qb=pb;pb=pb->next;qb->next=Lc->next;Lc->next=qb;}print(Lc); //将新合成的链表Lc输出}(4)链表输出模块，实现最终链表的输出void print(Linklist head) //链表输出函数，将链表输出{LNode *p;p=head->next;if(head!=NULL)do{printf("%d ",p->data);p=p->next;} while (p);printf("\n");四、程序使用说明及测试结果1.程序使用说明（1）本程序的运行环境为VC6.0；（2）进入演示程序后显示提示信息：请输入链表1数据（由小到大，输入0表示输入结束）：按要求输入数据请输入链表2数据（由小到大，输入0表示输入结束）：按要求输入数据请选择排序方式（输入1则从小到达合并，输入其它整数则按从大到小合并）：输入数据选择合并方式2.测试结果对链表1输入数据2，4，6，7，10，0对链表2输入数据1，3，5，6，7，12，0输入数据选择排序方式：如果输入：1 输出结果为：1，2，3，4，5，6，6，7，7，10，12如果输入：3（整数非1）输出结果为：12，10，7，7，6，6，5，4，3，2，13.调试中遇到的错误分析第一次运行时有问题，看以看出它的排序方式是对的，但是输出是多出前面一个很大的数，可能是输出函数void print(Linklist head)有问题，检查程序：此处逻辑出错，直接将p指针指向head，然后就将p->data输出，因此第一个数是头指针head所对应节点的值，所以可将p=head;改为p=head->next;这样p就指向第一个节点。

数据结构线性表实验报告五篇

数据结构线性表实验报告五篇第一篇：数据结构线性表实验报告实验报告课程名：数据结构实验名：线性表及其操作姓名：班级：学号：撰写时间：2014.09.24一实验目的与要求1.掌握线性表的实现2.掌握线性表的基本操作的实现二实验内容• 分别完成线性表的顺序表示及链式表示• 在两种表示上, 分别实现一些线性表的操作, 至少应该包括–在第i个位置插入一个元素–删除第i个元素–返回线性表长–返回第i个元素的值三实验结果与分析#include #include //---------线性表链式表示-----------struct V//声明一个结构体类型struct V { int value;struct V * next;//定义结构体变量};void PrintLink(struct V*p)//定义一个结构体指针{ while(p!=NULL)//只要指针指向的变量不为NULL；就会一直循环链表指向下一个结构体{printf(“%d, ”,(*p).value);p=(*p).next;//指针指向下一个结构体} printf(“n”);} void Link(){struct V*head;head=(struct V*)malloc(sizeof(struct V));//开辟一个长度为size的内存(*head).value=-100;//表头为-100(*head).next=NULL;printf(“------------线性表链式表示------------n”);int i,n=10;struct V*p=head;printf(“10个数据:n”);for(i=0;i(*p).next=(struct V*)malloc(sizeof(struct V));p=(*p).next;(*p).value=2*i;(*p).next=NULL;} PrintLink(head);//调用PrintLink函数printf(“删除第四个数据:n”);int k=4;p=head;for(i=1;ip=(*p).next;} struct V*temp=(*p).next;//k表示插入和删除的位置(*p).next=(*temp).next;free(temp);PrintLink(head);printf(“插入第十个数据:n”);k=10;p=head;for(i=1;ip=(*p).next;} temp=(*p).next;(*p).next=(struct V*)malloc(sizeof(struct V));(*(*p).next).value=-99;(*(*p).next).next=temp;PrintLink(head);}//---------线性表顺序表示-----------void seq1(){ int i,n=10,k=4;int a[10];//---------输出数组元素------------printf(“-------------线性表顺序表示---------n”);for(i=0;ia[i]=i;} printf(“数组元素为:n”);for(i=0;iprintf(“%3d”,a[i]);} printf(“n”);//--------插入一个数组元素---------int m=n+1,j=12;//插入元素12 int b[20];for(i=0;i if(i{b[i]=a[i];}else if(i==k){b[i]=j;}else{b[i]=a[i-1];} } printf(“输出插入一个元素的数组:n”);for(i=0;i{if(i{c[i]=a[i];}else{c[i]=a[i+1];} } printf(“输出删除一个元素的数组:n”);for(i=0;i printf(“数组元素为:n”);for(i=1;i<=a[0];i++){a[i]=i;} for(i=0;i<2*a[0];i++){printf(“%d,”,a[i]);} printf(“n”);//-----在k 位置插入一个元素------------for(i=a[0];i>=k;i--){a[i+1]=a[i];} a[k]=-100;++a[0];for(i=0;i<2*a[0];i++){printf(“%d,”,a[i]);} printf(“n”);//-------在k---------------for(i=0;i>k;i++){a[i]=a[i+1];} a[k]=-1;a[0]=n;--a[0];for(i=0;i<2*a[0];i++){printf(“%d,”,a[i]);} printf(“n”);} int main(int argc,char *argv[]){ seq1();seq2();Link();return 0;} 图1：实验结果截图实验分析：已在程序中按规定格式标注。

线性表的基本操作实验报告

线性表的基本操作实验报告线性表的基本操作1、需求分析:构建一个顺序表并实现顺序表的一些基本操作，例如创建列表，插入、删除元素，求元素的前驱等功能。

(1) 顺序表中数据元素为整形数字，范围属于int型。

(2) 输出部分操作提示以及功能操作所得到的数据(int型)。

(3) 顺序表建立、删除、插入、查询、判空、判满、查询前后驱等功能。

(4) 测试数据:a)b)2、概要设计:用一个结构定义了一个数组，和数组内容的长度。

主程序使用switch语句对将要进行的操作进行选择，调用各个功能函数。

3、实验源代码如下:#include<iostream>using namespace std;typedef struct{int date[100];int length;}SeqList;SeqList L;SeqList SeqListInit()//初始化顺序表 {cout<<"你定义的顺序表的长度(长度小于)"<<endl;cin>>L.length;cout<<"顺序表里面储存数据为"<<endl;for(int i=0;i<L.length;i++){int a;cin>>a;L.date[i]=a;}return L;}void ListClear()/* 清空顺序表*/{L.length=0;}int ListLength()/* 求顺序表长度*/{cout<<L.length<<endl;return 0;}int ListEmpty()/* 检查顺序表是否为空*/ { if(L.length==0)cout<<"为空"<<endl;elsecout<<"不为空"<<endl;return 0;}int ListFull()/*检查顺序表是否为满*/ { if(L.length==100)cout<<"为满"<<endl;elsecout<<"未满"<<endl;return 0;}void ListTraverse()/* 遍历顺序表*/{for(int i=0;i<L.length;i++)cout<<L.date[i]<<" ";cout<<endl;}int ListGet(int i)/* 从顺序表中查找元素*/ { if(i>=0&&i<L.length)cout<<L.date[i-1]<<endl;return 0;}int ListLocate(int x){for(int i=0;i<L.length;i++)if(L.date[i]==x)cout<<L.date[i];return 0;}void ListInsert(int i, int x){if(i>=0&&i<L.length){for(int m=0;i<=L.length-i;m++)L.date[L.length]=L.date[L.length-1];L.date[i-1]=x;L.length++;}}void ListDelete(int i){if(i>=0&&i<L.length){for(i;i<L.length;i++)L.date[i-1]=L.date[i];L.length--;}}int ListPrior(int e){if(e-2>=0&&e-2<L.length)cout<<L.date[e-2]<<endl;return 0;}int ListNext(int e){if(e>=0&&e<L.length)cout<<L.date[e]<<endl; return 0; }int main(){while(1){int i;cout<<"1初始化顺序表"<<endl;cout<<"2清空顺序"<<endl;cout<<"3求顺序表长度"<<endl;cout<<"4检查顺序表是否为空"<<endl;cout<<"5检查顺序表是否为满"<<endl;cout<<"6遍历顺序表"<<endl;cout<<"7从顺序表中查找元素"<<endl;cout<<"8从顺序表中查找与给定元素值相同的元素的位置"<<endl; cout<<"9向顺序表插入元素"<<endl;cout<<"10从顺序表中删除元素"<<endl;cout<<"11求元素前驱"<<endl;cout<<"12求元素后继"<<endl;cin>>i;switch (i){case 1:SeqListInit();break;case 2:ListClear();break;case 3:ListLength();break;case 4:ListEmpty();break;case 5:ListFull();break;case 6:ListTraverse();break;case 7:{int m;cout<<"请输入查找元素的位置"<<endl; cin>>m;ListGet(m);break;}case 8:{int m;cout<<"请输入查找元素"<<endl; cin>>m;ListLocate(m);break;}case 9:{int x;cout<<"请输入插入的元素"<<endl; cin>>x;ListInsert(i,x);break;}case 10:{int m;cout<<"请输入删除的元素"<<endl; cin>>m;ListDelete(m);break;}case 11:{int m;cout<<"请输入元素的位置"<<endl; cin>>m;ListPrior(m);break;}case 12:{int m;cout<<"请输入元素的位置"<<endl; cin>>m;ListNext(m);break;}default:break;}}}4、a) 遇见形参与实参搞混问题，改形参里面的内容并不影响其原本数据。

数据结构线性表实验报告

数据结构线性表实验报告一、实验目的本次实验的主要目的是深入理解和掌握数据结构中线性表的基本概念、存储结构和操作算法，并通过实际编程实现来提高对线性表的应用能力和编程技能。

二、实验环境本次实验使用的编程语言为C+＋，开发工具为Visual Studio 2019。

三、实验内容（一）线性表的顺序存储结构顺序表是用一组地址连续的存储单元依次存储线性表的数据元素。

其特点是逻辑上相邻的元素在物理位置上也相邻，便于随机存取，但插入和删除操作需要移动大量元素，效率较低。

（二）线性表的链式存储结构链表是通过指针将一组零散的存储单元链接成一个线性序列。

常见的链表有单链表、双向链表和循环链表。

链表的插入和删除操作只需修改指针，无需移动元素，但随机存取效率较低。

（三）线性表的基本操作实现1、初始化线性表2、销毁线性表3、清空线性表4、判断线性表是否为空5、获取线性表的长度6、获取指定位置的元素7、查找指定元素在线性表中的位置8、在线性表指定位置插入元素9、删除线性表指定位置的元素四、实验步骤（一）顺序表的实现1、定义顺序表的结构体，包括数据存储数组和表的长度。

2、实现顺序表的初始化函数，分配初始存储空间并设置表长度为0。

3、销毁顺序表函数，释放存储空间。

4、清空顺序表函数，将表长度置为 0。

5、判断顺序表是否为空，根据表长度判断。

6、获取顺序表长度，直接返回表长度。

7、获取指定位置元素，检查位置合法性后返回对应元素。

8、查找指定元素位置，遍历表进行比较。

9、插入元素函数，检查插入位置合法性，若合法则移动后续元素，插入新元素并更新表长度。

10、删除元素函数，检查删除位置合法性，若合法则移动后续元素，更新表长度。

（二）链表的实现1、定义链表节点结构体，包含数据域和指针域。

2、实现链表的初始化函数，创建头节点。

3、销毁链表函数，遍历链表释放节点内存。

4、清空链表函数，遍历链表删除节点但保留头节点。

5、判断链表是否为空，检查头节点的指针域是否为空。

线性表实验报告

线性表实验报告实验目的：掌握线性表的基本概念和实现方式，熟悉线性表的各种操作。

实验原理：线性表是由同类型的数据元素构成的有序序列。

在线性表中，除了第一个元素外，每个元素都有且仅有一个直接前驱元素；除了最后一个元素外，每个元素都有且仅有一个直接后继元素。

本实验主要通过C语言的实现，实现了线性表的基本操作，包括初始化、插入、删除、查找等。

实验内容：1.初始化线性表：定义一个长度为n的结构体数组，用于存储线性表的元素，同时设置线性表的长度为0。

2.插入元素：在指定位置pos后插入元素elem，首先判断线性表是否已满，若已满则无法插入；若未满，则将pos后的所有元素往后移动一位，然后将elem插入到pos位置，最后将线性表的长度加1。

3.删除元素：删除指定位置pos的元素，首先判断线性表是否为空或pos是否合法，若为空或pos不合法则无法删除；若合法，则将pos后的所有元素往前移动一位，最后将线性表的长度减1。

4.查找元素：按照元素值查找元素在线性表中的位置，首先判断线性表是否为空，若为空则无法查找；若不为空，则遍历线性表，逐一比较元素值，找到则返回其位置，找不到则返回-1。

5.输出线性表：按顺序输出线性表中的元素值。

实验结果：经过测试，线性表的各种操作均实现了。

可以正确地初始化、插入、删除、查找元素，并成功输出线性表中的元素值。

实验总结：通过本实验，我对线性表的概念和实现方式有了更深入的了解，并通过C语言的实现掌握了线性表的各种操作。

线性表是数据结构中最基本、最简单的一种，但在实际应用中非常广泛。

掌握了线性表的操作，对于理解和应用其他更复杂的数据结构具有重要的意义。

C语言数据结构线性表的基本操作实验报告

实验一线性表的基本操作一、实验目的与基本要求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)点击运行，首先出现的是菜单界面，选择菜单选项进行操作，如图所示。

C语言数据结构线性表的基本操作实验报告

数据结构线性表的基本操作及应用实验报告

数据结构C语言版 实验报告

数据结构实验报告——线性表

数据结构线性表试验报告（最终定稿）

数据结构线性表实验报告

数据结构--实验报告 线性表的基本操作

数据结构--实验报告 线性表的基本操作

C语言-线性表实验报告

数据结构--实验报告 线性表的基本操作

数据结构线性表实验报告

数据结构--实验报告 线性表的基本操作

数据结构线性表实验报告

数据结构c语言实验报告

数据结构--实验报告_线性表的基本操作备用

数据结构线性表操作实验报告

数据结构线性表实验报告五篇

线性表的基本操作实验报告

数据结构线性表实验报告

线性表实验报告

C语言数据结构线性表的基本操作实验报告

数据结构C语言版实验报告

数据结构--实验报告线性表的基本操作

数据结构--实验报告线性表的基本操作

数据结构--实验报告线性表的基本操作

数据结构--实验报告线性表的基本操作