《数据结构》实验一 线性表及其应用
数据结构线性表的基本操作及应用实验报告
实验日期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的工作环境及其基本操作,进一步掌握了基本函数的调用以及使用方法。
数据结构实验 线性表的应用
课程题目:数据结构试验学院:班级:姓名:学号:实验题目:线性表的应用实验内容:分数统计实验目的:掌握线性表的概念及原理,运用线性表的原理完成实验题目中的内容。
实验要求:为了使学生更好的掌握与理解课堂上老师所讲的概念与原理,实验前每个学生要认真预习所做的实验内容及编写源程序代码(写在纸上与盘中均可),以便在实验课中完成老师所布置的实验内容。
实验学时:4学时设计原理:本实验的核心部分为对学生成绩从两个角度进行分析,既对学生的成绩进行了排名、求出学生成绩的平均分和分出学生成绩的数值段。
为了处理学生成绩这些数据,首先必须建立一个新的线性表,新表为空,然后经由input函数程序的执行使得学生的成绩可以输入到计算机中,从键盘输入程序所提示的学生人数后,新线性表的长度得以确定,再通过循环命令语句的调用将全部学生的成绩输入。
输入后,调用output函数处理线性表中的数据,通过调用条件语句和设置变量存储次次数的累加,从而在屏幕上输出各个分数段的人数。
这之后,通过冒泡排序法处理学生成绩这些数据,得出结果后,在调用循环语句命令将结果按顺序输出。
然后再对这些数据进行求平均值的运算,处理后输出。
详细程序清单及注释说明:#include<stdio.h>#include<malloc.h>#define list_init_size 100#define listincrement 10typedef struct{int *elem; //存储空间基址int length; //当前长度int listsize; //当前分配的存储空间(以sizeof(ElemType)为单位) }sqlist;void initlist_sq(sqlist &l) //创建一个空的线性表{l.elem=(int *)malloc(list_init_size*sizeof(int));l.length=0; //空表长度为0l.listsize=list_init_size; //初始存储容量}void input(sqlist &l){//输入学生的总人数和每个人的成绩int a,b,c;loop1:printf("输入学生人数:");scanf("%d",&b);if(b<=0){printf("输入错误,请重新输入!!\n");goto loop1; //输入错误时,重新输入}printf("\n");l.length=l.length+b; //由输入的值确定线性表的长度for(a=0;a<b;a++){loop:printf("输入第%d名学生的成绩:",a+1);scanf("%d",&c);l.elem[a]=c;if(c<0 || c>100){printf("输入错误,请重新输入!!\n");goto loop; //输入错误时,重新输入}}}void output(sqlist &l){//输出学生的成绩信息printf("\n");int i,a=0,q=0,w=0,e=0,r=0,t=0,y=0;for(i=0;i<l.length;i++){a=l.elem[i]/10;switch(a) //对成绩分段{case 10:q++;break;case 9:w++;break;case 8:e++;break;case 7:r++;break;case 6:t++;break;default:y++;break;}}printf("成绩为100有%d人\n",q);printf("成绩为90~99有%d人\n",w);printf("成绩为80~89有%d人\n",e);printf("成绩为70~79有%d人\n",r);printf("成绩为60~69有%d人\n",t);printf("不及格的有%d人\n\n",y);}void order(sqlist &l){//对成绩进行排序int i,j,k;for(i=0;i<l.length;i++)for(j=0;j<l.length-i;j++)if(l.elem[j]<l.elem[j+1]){k=l.elem[j];l.elem[j]=l.elem[j+1];l.elem[j+1]=k;}printf("经过排序:\n");for(i=0;i<l.length;i++){printf("第%d名成绩为:%d\n",i+1,l.elem[i]);}}void average(sqlist &l){//求出平均成绩int i;float k=0,j=0;for(i=0;i<l.length;i++){j=j+l.elem[i];}k=j/l.length;printf("平均分为:%5.5f\n",k); }void main(){printf("分数统计\n\n");sqlist l;initlist_sq(l);input(l);output(l);order(l);average(l);}运行与测试及结果:在输入错误情况下:试验中所遇到的问题及解决办法:①、实验当中曾经出现数据结果为乱码的现象,后经查找,原因是两个for循环当中的变量i,j顺序颠倒,从而出现了指针没有指向相应的数据结果,而是指向了未知位置的数据。
实验一 线性表的基本操作实现及其应用
实验一线性表的基本操作实现及其应用一、实验目的1、熟练掌握线性表的基本操作在两种存储结构上的实现。
2、会用线性链表解决简单的实际问题。
二、实验内容题目一、该程序的功能是实现单链表的定义和操作。
该程序包括单链表结构类型以及对单链表操作的具体的函数定义和主函数。
其中,程序中的单链表(带头结点)结点为结构类型,结点值为整型。
单链表操作的选择以菜单形式出现,如下所示:please input the operation:1.初始化2.清空3.求链表长度4.检查链表是否为空5.检查链表是否为满6.遍历链表(设为输出元素)7.从链表中查找元素8.从链表中查找与给定元素值相同的元素在表中的位置9.向链表中插入元素 10. 从链表中删除元素其他键退出。
其中黑体部分必做题目二、约瑟夫环问题:设编号为1,2,3,……,n的n(n>0)个人按顺时针方向围坐一圈,每个人持有一个正整数密码。
开始时任选一个正整数做为报数上限m,从第一个人开始顺时针方向自1起顺序报数,报到m时停止报数,报m的人出列,将他的密码作为新的m值,从他的下一个人开始重新从1报数。
如此下去,直到所有人全部出列为止。
令n最大值取30。
要求设计一个程序模拟此过程,求出出列编号序列。
struct node(一)1.进入选择界面后,先选择7,进行插入:2.选择4,进行遍历,结果为:3.选择2,得出当前链表长度.4.选择3,得出当前链表为.5.选择分别选择5、6进行测试.6.选择8,分别按位置和元素值删除.7.选择9,或非1-8的字符,程序结束.(二) 实验总结通过这次实验,我对线性链表有了更深的理解,深入明白了线性存储结构与链式存储结构在内存存储的不同特点,同时我还学会了用这些知识实际解决一些问题,能够更加熟练地将算法转化为实际程序。
同时,在写程序和调试程序的过程中,学会了一些书写技巧和调试技巧,这对于自己能在短时间高效的写出正确地程序有很大作用。
四、主要算法流程图及程序清单 1. 主要算法流程图:(1) 从单链表表中查找与给定元素值相同的元素在链表中的位置p=p->nextp&&!(p->data==xtrue调用函数,传入参数L ,xp=L->next2.程序清单:#include<iostream> using namespace std; #include<>#include<>/* 预处理命令 */#define OK 1;#define ERROR 0;#define OVERFLOW -1;/* 单链表的结点类型 */typedef struct LNode{int data;struct LNode *next;}LNode,*LinkedList;/*初始化单链表*/LinkedList LinkedListInit(){空"<<endl;cout<<"\t\t\t"<<"2.求链表长度"<<endl;cout<<"\t\t\t"<<"3.检查链表是否为空"<<endl;cout<<"\t\t\t"<<"4.遍历链表"<<endl;cout<<"\t\t\t"<<"5.从链表中查找元素 "<<endl;cout<<"\t\t\t"<<"6.从链表中查找与给定元素值相同的元素在表中的位置"<<endl;cout<<"\t\t\t"<<"7.向链表中插入元素"<<endl;cout<<"\t\t\t"<<"8.从链表中删除元素"<<endl;cout<<"\t\t\t"<<"9.退出"<<endl;}/*主函数*/int main(){链表长度case 2:{cout<<"\t\t\t链表长度为:"<<LinkedListLength(L)<<endl;getch();}break;查链表是否为空case 3:{if (!LinkedListEmpty(L)){cout<<"\t\t\t链表不为空!"<<endl;}else{cout<<"\t\t\t链表为空!"<<endl;}getch();}break;历链表case 4:{LinkedListTraverse(L);getch();}break;链表中查找元素case 5:{cout<<"\t\t\t请输入要查询的位置i:";int j;cin>>j;if (LinkedListGet(L,j)){cout<<"\t\t\t位置i的元素值为:"<<LinkedListGet(L,j)->data<<endl;}else{cout<<"\t\t\ti大于链表长度!"<<endl;}getch();}break;链表中查找与给定元素值相同的元素在表中的位置case 6:{cout<<"\t\t\t请输入要查找的元素值:";int b;cin>>b;if (LinkedListGet1(L,b)){cout<<"\t\t\t要查找的元素值位置为:"<<LinkedListGet1(L,b)<<endl;cout<<"\t\t\t要查找的元素值内存地址为:"<<LinkedListLocate(L,b)<<endl;}else{cout<<"\t\t\t该值不存在!"<<endl;}getch();}break;链表中插入元素case 7:{cout<<"\t\t\t请输入要插入的值:";int x; cin>>x;cout<<"\t\t\t请输入要插入的位置:";int k; cin>>k;if(LinkedListInsert(L,k,x)){cout<<"\t\t\t插入成功!"<<endl;}else{cout<<"\t\t\t插入失败!"<<endl;}getch();}break;链表中删除元素case 8:{cout<<"\t\t\t1.按位置删除"<<endl;cout<<"\t\t\t2.按元素删除"<<endl;int d;cout<<"\t\t请选择:";cin>>d;switch(d){case 1:{cout<<"\t\t\t请输入删除位置:";cin>>d;int y;if (LinkedListDel(L,d,y)){cout<<"\t\t\t"<<y<<"被删除!"<<endl;}else{cout<<"\t\t\t删除失败!"<<endl;}}break;case 2:{cout<<"\t\t\t请输入删除元素:";int y;cin>>y;if (LinkedListDel(L,y)){cout<<"\t\t\t"<<y<<"被删除!"<<endl;}else{cout<<"\t\t\t删除失败!"<<endl;}}}getch();}break;}}return 1;}题二约瑟夫环问题算法、思想为了解决这一问题,可以先定义一个长度为30(人数)的数组作为线性存储结构,并把该数组看成是一个首尾相接的环形结构,那么每次报m的人,就要在该数组的相应位置做一个删除标记,该单元以后就不再作为计数单元。
实验一 线性表的应用
voidInitializeSource(SourceTp *source);
voidSeqInsertVote(VoteTp *vote,inti,ElemTp x);
intSeqLocate(VoteTp v,ElemTp x);
}
}
voidInitializeVote(VoteTp *vote)
{
vote->len=0;
}
voidInitializeSource(SourceTp *Source)
{/*初始化备选数表Source,在表中放入1~3 6共3 6个数,将表长置为36 */
inti;
for(i=1;i<=NN;i++)
#defineMM 7
#defineNN 36
typedefintElemTp;
typedefstruct
{ ElemTp elem[MM+1];
intlen;
} VoteTp;
typedefstruct
{ ElemTp elem[NN+1];
intlen;
} SourceTp;
SourceTp source;
判断中奖情况,就是先初始化猜对号码个数为0,再依次用中奖号码表中的每个号码,在一张彩票号码表中查找,若有,猜对号码个数加1。处理完毕,猜对号码个数即可反映中奖情况。
3.解决方案
(1)彩票号码表、备选数表的存储结构类型定义
#define MM 7/*彩票中号码的个数*/
#define NN 36/*选数的个数*/
备选数表的初始化,备选数表初始状态含有1~36这36个数,元素间的顺序没有意义。
数据结构实验报告实验总结
数据结构实验报告实验总结本次数据结构实验主要涉及线性表、栈和队列的基本操作以及链表的应用。
通过实验,我对这些数据结构的特点、操作和应用有了更深入的了解。
下面对每一部分实验进行总结。
实验一:线性表的基本操作线性表是一种常见的数据结构,本实验要求实现线性表的基本操作,包括插入、删除、查找、遍历等。
在实验过程中,我对线性表的结构和实现方式有了更清晰的认识,掌握了用数组和链表两种方式实现线性表的方法。
实验二:栈的应用栈是一种后进先出(LIFO)的数据结构,本实验要求利用栈实现简单的括号匹配和后缀表达式计算。
通过实验,我了解到栈可以方便地实现对于括号的匹配和后缀表达式的计算,有效地解决了对应的问题。
实验三:队列的应用队列是一种先进先出(FIFO)的数据结构,本实验要求利用队列实现银行排队和迷宫求解。
通过实验,我对队列的应用有了更加深入的了解,了解到队列可以解决需要按顺序处理的问题,如排队和迷宫求解等。
实验四:链表的应用链表是一种常用的数据结构,本实验要求利用链表实现学生信息管理系统。
通过实验,我对链表的应用有了更深入的了解,了解到链表可以方便地实现对于数据的插入、删除和修改等操作,并且可以动态地调整链表的长度,适应不同的需求。
通过本次实验,我掌握了线性表、栈、队列和链表的基本操作,并了解了它们的特点和应用方式。
同时,通过实际编程的过程,我对于数据结构的实现方式和效果有了更直观的认识,也锻炼了自己的编程能力和解决问题的能力。
在实验过程中,我遇到了一些问题,如程序逻辑错误和内存泄漏等,但通过调试和修改,最终成功解决了这些问题,对自己的能力也有了更多的信心。
通过本次实验,我深刻体会到了理论与实践的结合的重要性,也对于数据结构这门课程有了更加深入的理解。
总之,本次数据结构实验给予了我很多有益的启发和收获,对于数据结构的概念、特点和应用有了更深入的理解。
在以后的学习中,我会继续加强对数据结构的学习和研究,不断提高自己的编程能力和解决问题的能力。
数据结构线性表实验报告
数据结构线性表实验报告数据结构线性表实验报告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.熟悉C语言的上机环境,进一步掌握C语言的结构特点。
2.掌握线性表的顺序存储结构的定义及C语言实现。
3.掌握线性表的链式存储结构——单链表的定义及C语言实现。
4.掌握线性表在顺序存储结构即顺序表中的各种基本操作。
5.掌握线性表在链式存储结构——单链表中的各种基本操作。
二、实验内容1.顺序线性表的建立、插入及删除。
2.链式线性表的建立、插入及删除。
三、实验步骤1.建立含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度。
2.利用前面的实验先建立一个顺序表L={21,23,14,5,56,17,31},然后在第i个位置插入元素68。
3.建立一个带头结点的单链表,结点的值域为整型数据。
要求将用户输入的数据按尾插入法来建立相应单链表。
四、实现提示1.由于C语言的数组类型也有随机存取的特点,一维数组的机内表示就是顺序结构。
因此,可用C语言的一维数组实现线性表的顺序存储。
在此,我们利用C语言的结构体类型定义顺序表:#define MAXSIZE 1024typedef int elemtype; /* 线性表中存放整型元素*/typedefstruct{ elemtypevec[MAXSIZE];intlen; /* 顺序表的长度*/}sequenlist;将此结构定义放在一个头文件sqlist.h里,可避免在后面的参考程序中代码重复书写,另外在该头文件里给出顺序表的建立及常量的定义。
2. 注意如何取到第i个元素,在插入过程中注意溢出情况以及数组的下标与位序(顺序表中元素的次序)的区别。
3.单链表的结点结构除数据域外,还含有一个指针域。
用C语言描述结点结构如下:typedefintelemtype;typedefstruct node{ elemtype data; //数据域struct node *next; //指针域}linklist;注意结点的建立方法及构造新结点时指针的变化。
《数据结构》实验1实验报告
南京工程学院实验报告<班级>_<学号>_<实验X>.RAR文件形式交付指导老师。
一、实验目的1.熟悉上机环境,进一步掌握语言的结构特点。
2.掌握线性表的顺序存储结构的定义及实现。
3.掌握线性表的链式存储结构——单链表的定义及实现。
4.掌握线性表在顺序存储结构即顺序表中的各种基本操作。
5.掌握线性表在链式存储结构——单链表中的各种基本操作。
二、实验内容1.顺序线性表的建立、插入及删除。
2.链式线性表的建立、插入及删除。
三、实验步骤1.建立含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度。
2.利用前面的实验先建立一个顺序表L={21,23,14,5,56,17,31},然后在第i个位置插入元素68。
3.建立一个带头结点的单链表,结点的值域为整型数据。
要求将用户输入的数据按尾插入法来建立相应单链表。
四、程序主要语句及作用程序1的主要代码(附简要注释)public struct sequenlist{public const int MAXSIZE=1024; /*最大值为1024*/public elemtype[] vec;public int len; /* 顺序表的长度 */public sequenlist( int n){vec=new elemtype[MAXSIZE ];len = n;}};class Program{static void Main(string[] args){sequenlist list1 = new sequenlist(5);for (int i = 0; i < 5; i++){list1.vec[i] = i;}for (int i = 0; i < 5; i++){Console.Write("{0}---", list1.vec[i]) ;}Console.WriteLine("\n");Console.WriteLine("表长:{0}\n",list1.len );Console.ReadKey();}}程序2的主要代码(附简要注释)public void insertlist(int i, int x){if (len >= MAXSIZE)throw new Exception("上溢"); /*长度大于最大值则抛出异常*/if (i < 1 || i > len + 1)throw new Exception("位置");/插入位置小于1或大于len+1则抛出插入位置错误的异常for (int j = len; j >= i; j--)vec[j] = vec[j - 1]; //注意第j个元素存在数组下标为j-1处vec[i - 1] = x;len++;}};class Program{static void Main(string[] args){sequenlist list2 = new sequenlist(7);list2.vec[0] = 21;list2.vec[1] = 23;list2.vec[2] = 14;list2.vec[3] = 5;list2.vec[4] = 56;list2.vec[5] = 17;list2.vec[6] = 31;Console.Write("请输入第i个位置插入元素:");int loc =Convert.ToInt32( Console.ReadLine());Console.Write("请输入第{0}个位置插入的元素:", loc);int ele = Convert.ToInt32(Console.ReadLine());Console.WriteLine("插入前的线性表:");for (int i = 0; i < list2.len ; i++){Console.Write("{0}---", list2.vec[i]);}Console.WriteLine("\n");list2.insertlist(loc, ele);Console.WriteLine("插入后的线性表:");for (int i = 0; i < list2.len ; i++){Console.Write("{0}---", list2.vec[i]);}Console.WriteLine("\n");Console.ReadKey();}}程序3的主要代码(附简要注释)class Node{private int num;public int Num{set { num = value; }/输入值get { return num; }/获得值}private Node next;public Node Next{set { next = value; }get { return next; }}}class Pp{static void Main(string[] args){Node head;Node tempNode, tempNode1;int i;head = new Node();Console.WriteLine("输入六项数据:\n");Console.Write("输入第1项数据:");head.Num = Convert.ToInt32(Console.ReadLine());head.Next = null;tempNode = head;for (i = 1; i < 6; i++){tempNode1 = new Node();Console.Write("输入第{0}项数据:",i+1);tempNode1.Num = Convert.ToInt32(Console.ReadLine());/插入项转换为整形数值 tempNode1.Next = null;tempNode.Next = tempNode1;tempNode = tempNode.Next;}Console.WriteLine("线性表:");tempNode = head;for (i = 0; i < 6; i++){Console.Write("{0}", tempNode.Num);if (i < 5){Console.Write("--");}tempNode = tempNode.Next;}Console.ReadKey();}}五、程序运行结果截图程序1程序2程序3六、收获,体会及问题(写得越详细、越个性化、越真实越好,否则我不知道你做这个实验的心路历程,也就无法充分地判断你是否是独立完成的这个实验、你是否在做这个实验时进行了认真仔细地思考、通过这个实验你是否在实践能力上得到了提高)这次试验刚开始做时完全不知道从哪下手,才刚上了几节课,对于线性表、链式表都不是理解的很透彻,不知道用哪个软件编写程序。
数据结构实验一-线性表
数据结构实验⼀-线性表实验⼀线性表⼀、实验⽬的1、深刻理解线性结构的特点,以及在计算机内的两种存储结构。
2、熟练掌握线性表的顺序存储结构和链式存储结构,及其它们的基本操作,重点掌握查找、插⼊和删除等操作。
⼆、实验要求1、认真阅读程序,将未完成的代码补全(红⾊部分)。
2、上机调试,并运⾏程序。
3、保存和截图程序的运⾏结果,并结合程序进⾏分析。
三、实验内容和基本原理1、实验1.1 顺序表的操作利⽤顺序表存储⽅式实现下列功能(见参考程序1):1)通过键盘输⼊数据建⽴⼀个线性表,并输出该线性表。
如,依次输⼊元素25,21,46,90,12,98。
2)根据屏幕菜单的选择,进⾏数据的插⼊、删除和查找,并在插⼊或删除数据后,再输出线性表。
如,在第2个位置上插⼊元素43,然后输出顺序表。
删除顺序表第4个元素,输出改变的顺序表。
3)在屏幕菜单中选择0,结束程序的运⾏。
基本原理:在顺序表的第i个位置上插⼊⼀个元素时,必须先将线性表的第i个元素之后的所有元素依次后移⼀个位置,以便腾空⼀个位置,在把新元素插⼊到该位置。
当要删除第i个元素时,只需将第i个元素之后的所有元素前移⼀个位置。
程序代码(蓝⾊为补充的语句)://* * * * * * * * * * * * * * * * * * * * * * * *//*PROGRAM :顺序结构的线性表 *//*CONTENT :建⽴,插⼊,删除,查找 *//*编程语⾔: Visual c++ 6.0 *//* * * * * * * * * * * * * * * * * * * * * *#include#include#define MAXSIZE 20typedef int ElemType; //数据元素的类型typedef struct{ElemType a[MAXSIZE];int length;}SqList; //顺序存储的结构体类型SqList a,b,c;//函数声明void creat_list(SqList *L);void out_list(SqList L);void insert_sq(SqList *L,int i,ElemType e); ElemType delete_sq(SqList *L,int i);int locat_sq(SqList L,ElemType e);//主函数void main(){int i,k,loc;ElemType e,x;char ch;do {printf("\n\n\n");printf("\n 吴肖遥20151681310131");printf("\n 1.建⽴线性表");printf("\n 2.插⼊元素");printf("\n 3.删除元素");printf("\n 4.查找元素");printf("\n 0.结束程序运⾏");printf("\n =====================");printf("\n 请输⼊要执⾏的操作: ");scanf("%d",&k);switch(k){case 1:{creat_list(&a);out_list(a);}break;case 2:{printf("\n请输⼊插⼊位置: ",a.length+1); scanf("%d",&i);printf("请输⼊要插⼊的元素值: ");scanf("%d",&e);insert_sq(&a,i,e);out_list(a);}break;case 3:{printf("\n请输⼊要删除元素的位置: ",a.length); scanf("%d",&i);x=delete_sq(&a,i);out_list(a);if(x!=-1)printf("\n删除的元素为:%d\n",x);else printf("要删除的元素不存在!");}break;case 4:{printf("\n请输⼊要查找的元素值:");scanf("%d",&e);loc=locat_sq(a,e);if(loc==-1)printf("\n未找到指定元素!");elseprintf("\n已找到,元素的位置是: %d ",loc);}break;}/*switch*/}while(k!=0);printf("\n 按回车键,返回...\n");ch=getchar();}/*main*///建⽴线性表void creat_list(SqList *L){int i;printf("请输⼊线性表的长度: ");scanf("%d",&L->length);for(i=0;ilength;i++){printf("数据 %d =",i);scanf("%d",&(L->a[i]));}}//输出线性表void out_list(SqList L){int i;for(i=0;i<=L.length-1;i++)printf("%10d",L.a[i]);}//在线性表的第i个位置插⼊元素evoid insert_sq(SqList *L,int i,ElemType e){int j;if(L->length==MAXSIZE)printf("线性表已满!\n");else {if(i<1||i>L->length+1)printf("输⼊位置错!\n");else {for(j=L->length-1;j>=i-1;j--)L->a[j+1]=L->a[j];L->a[j+1]=e;/*将未完成的代码补全,提⽰:此处添加⼀条语句,将被删除的元素值赋给e*/ L->length++;}}}//删除第i个元素,返回其值ElemType delete_sq(SqList *L,int i){ElemType x;int j;if(L->length==0)printf("空表!\n");else if(i<1||i>L->length){printf("输⼊位置错!\n");x=-1;}else{x=L->a[i-1];for(j=i;j<=L->length-1;j++)L->a[j-1]=L->a[j];/*将未完成的代码补全,提⽰:此处添加⼀条语句,将被删除元素之后的元素左移。
数据结构实验一:线性表的应用
数据结构实验报告实验一线性表的应用一、实验目的:1.掌握线性表的两种存储结构及实现方式;2.熟练掌握顺序表和链表的建立、插入和删除的算法。
二、实验要求:1.C完成算法设计和程序设计并上机调试通过。
2.撰写实验报告,提供实验结果和数据。
3.写出算法设计小结和心得。
三、实验内容:1.用顺序表表示集合,编写程序以实现集合的交、并、差运算。
2.设带头结点的单链表ha和hb中结点数据域值按从小到大顺序排列,且各自链表内无重复的结点,要求:(1)建立两个按升序排列的单链表ha和hb。
(2)将单链表ha合并到单链表hb中,且归并后的hb链表内无重复的结点,结点值仍保持从小到大顺序排列。
(3)输出合并后单链表hb中每个结点的数据域值。
四、程序源代码:1.#include<stdio.h>#include<stdlib.h>#define LIST_INIT_CAPACITY 100 typedef int ElementType;typedef struct List{ElementType elem[LIST_INIT_CAPACITY]; int nLength;}SqList;void init(struct List*L)//初始化顺序表{if(L)L->nLength=0;}int visit(SqList*L,ElementType e)//遍历顺序表{for(int i=0;i<L->nLength;i++){if(L->elem[i]==e){return 0;break;}elsecontinue;return 1;}}SqList*jiao(SqList*L1,SqList*L2,SqList*L3)//求两个集合的交集{int n=0;for(int i=0;i<L1->nLength;i++){for(int j=0;j<L2->nLength;i++){if(L1->elem[i]==L2->elem[j]){L3->elem[n]=L1->elem[i];n++;}elsecontinue;}}printf("集合的交集:\n");return L3;}SqList*bing(SqList*L1,SqList*L2,SqList*L3)//求两个集合的并集{int j=0;for (int i=0;i<L1->nLength;i++){if (visit(L2,L1->elem[i])){L3->elem[j]=L1->elem[i];L3->nLength++;j++;}elsecontinue;}printf("集合的并集:\n");return L3;}SqList*cha(SqList*L1,SqList*L2,SqList*L3)//求两个集合的差集{int j=0;for(int i=0;i<L1->nLength;i++){if(visit (L2,L1->elem[i])){L3->elem[j]=L1->elem[i];j++;L3->nLength++;}elsecontinue;}printf("集合的差集:\n");return L3;}void show(SqList *list)//显示线性表元素{for (int i=0;i<list->nLength;i++){printf(" %d",list->elem[i]);}printf("\n");}void main(){SqList*list1,*list2,*list3;list1=(SqList*)malloc(sizeof(SqList));list2=(SqList*)malloc(sizeof(SqList));list3=(SqList*)malloc(sizeof(SqList));init(list1);init(list2);init(list3);intstr1[6]={1,2,3,4,5,6},str2[7]={1,3,4,5,7,9,10};for(int i=0;i<6;i++){list1->elem[i]=str1[i];list1->nLength=i+1;}for(i=0;i<7;i++){list2->elem[i]=str2[i];list2->nLength++;}printf("初始集合:\n");show(list1);show(list2);list3=jiao(list1,list2,list3);show(list3);init(list3);list3=bing(list1,list2,list3);show(list3);init(list3);list3=cha(list1,list2,list3);show(list3);}2.#include <stdio.h>#include<stdlib.h>typedef int ElementType;typedef struct ListNode{ElementType data;struct ListNode *next;}sLinkList;sLinkList*create(ElementType i)//创建接点{sLinkList *p;p=(sLinkList*)malloc(sizeof(sLinkList));if(!p)exit(0);elsep->data=i;return p;}void anotherorder(sLinkList*head){sLinkList*P;P=head->next;if(head!=NULL)//头指针不为空{while (P->next!=NULL){sLinkList*q;//p的后继指针sLinkList*t;q=P->next;t=P->next->next;q->next=head->next;head->next=q;P->next=t;}}}void print(sLinkList*head)//输出链表{if(head==NULL){exit(0);}sLinkList*p=head->next;while(p!=NULL){printf("%4d",p->data);p=p->next;}printf("\n");}void hebing(sLinkList *p,sLinkList *q,sLinkList *l)//将两个链表合并{ sLinkList*z;q=q->next;l=l->next;while(q!=NULL&&l!=NULL){if(q->data>l->data){z=create(l->data);p->next=z;z->next=NULL;p=z;l=l->next;}elseif(q->data<l->data){z=create(q->data);p->next=z;z->next=NULL;p=z;q=q->next;}elseif(q->data==l->data){for(int i=0;i<2;i++){z=create(q->data);p->next=z;z->next=NULL;p=z;}q=q->next;l=l->next;}}if(q==NULL){while (l!=NULL){z=create(l->data);p->next=z;z->next=NULL;p=z;l=l->next;}}if(l==NULL){while (q!=NULL){z=create(q->data);p->next=z;z->next=NULL;p=z;q=q->next;}}printf("合并后:\n");}void deletelist(sLinkList*p)//删除多余元素节点{if(p!=NULL)p=p->next;sLinkList*q;//中间指针while (p!=NULL){int i=p->data;sLinkList*head=p;while (head->next!=NULL){if(i==head->next->data){q=head->next;head->next=q->next;free(q);}elsehead=head->next;}p=p->next;}printf("最终结果:\n");}void main(){sLinkList *ha; ha=(sLinkList*)malloc(sizeof(ListNode)); if(ha!=NULL)//判空{ha->next=NULL;ha->data=-1;}sLinkList *p;sLinkList *q=ha;int a[5]={2,4,6,8,10};for (int i=0;i<5;i++){p=create(a[i]);q->next=p;p->next=NULL;q=p;}printf("初始:\n");print(ha);sLinkList *hb;hb=(sLinkList*)malloc(sizeof(ListNode)); if(hb!=NULL)//判空{hb->next=NULL;hb->data=-1;}q=hb;int b[6]={1,4,5,8,9,10};for (i=0;i<6;i++){p=create(b[i]);q->next=p;p->next=NULL;q=p;}print(hb);//构建ha,hbsLinkList *hc;hc=(sLinkList*)malloc(sizeof(ListNode)); hebing(hc,ha,hb);print(hc);deletelist(hc);print(hc);}五、测试结果:1.2.六、小结(包括收获、心得体会、存在的问题及解决问题的方法、建议等)经过这次实验,我对线性表的两种形式顺序表和链表有了进一步的了解,对线性表之间的运算及线性表的简单应用有了更深的体会。
数据结构实验(1)线性表及其应用
计算机系数据结构实验报告(1)实验目的:帮助学生掌握线性表的基本操作在顺序和链表这两种存储结构上的实现,尤以链表的操作和应用作为重点。
问题描述:1、构造一个空的线性表L。
2、在线性表L的第i个元素之前插入新的元素e;3、在线性表L中删除第i个元素,并用e返回其值。
实验要求:1、分别利用顺序和链表存储结构实现线性表的存储,并设计出在不同的存储结构中线性表的基本操作算法。
2、在实验过程中,对相同的操作在不同的存储结构下的时间复杂度和空间复杂度进行分析。
算法分析:由于两种存储结构都用来创建线性结构的数据表,可采用相同的输出模式和整体结构类似的算法,如下:v1.0 可编辑可修改实验内容和过程:顺序存储结构线性表程序清单://顺序存储结构线性表的插入删除#include <iostream>#include <>using namespace std;# define LISTSIZE 100# define CREMENTSIZE 10typedef char ElemType; //定义数据元素类型为字符型typedef struct {ElemType *elem; //数据元素首地址int len; //当前元素个数int listsize; //当前存储最大容量}SqList;//构造一个空的线性表Lint InitList(SqList &L){=(ElemType *)malloc(LISTSIZE*sizeof(ElemType));if (! exit(-2); //分配空间失败=0;=LISTSIZE;}//在顺序线性表L中第i个位置之前插入新的元素eint ListInsert(SqList &L,int i,ElemType e){if (i<1||i>+1) return -1; //i值不合法if >={ElemType *newelem=(ElemType *)realloc,+CREMENTSIZE)*sizeof(ElemType));//存储空间已满,增加分配if(!newelem) exit (-2); //分配失败=newelem;+=CREMENTSIZE;}ElemType *q=&[i-1]) ;for (ElemType *p=&[]);p>=q;--p) *(p+1)=*p; //插入位置及其后的元素后移 *q=e; ++;return 1;}//在顺序线性表L中删除第i个元素,并用e返回其值int ListDelete(SqList &L,int i,ElemType&e){if (i<1||i> return -1; //i值不合法ElemType *p=&[i-1]);e=*p; ElemType*q=+;for (++p;p<=q+1;++p) *(p-1)=*p; //被删除元素之后的元素前移;return 1;}int main (){SqList L; char e,ch;int i,j,state;InitList(L); //构造线性表printf("请输入原始数据(字符串个数0~99):L="); //数据初始化gets;for ( j=1;[j-1]!='\0';j++) =j; //获取表长[j]='\0';printf("操作:插入(I)还是删除(D)\n"); //判断进行插入还是删除操作AGAIN:cin>>ch;if(ch=='I'){cout<<"插在第几个元素之前:"; //插入操作cin>>i; cout<<"输入要插入的新元素:";cin>>e;cout<<endl;printf("输入数据:L=(%s) ListInsert(L,%d,%c)",,i,e);state=ListInsert (L,i,e);}else if (ch=='D'){cout<<"删除第几个元素:"; //删除操作cin>>i;cout<<endl;printf("输入数据:L=(%s) DeleteList(L,%d,e)",,i);state=ListDelete(L,i,e);}else goto AGAIN; //操作指示符输入错误处理cout<<endl<<"正确结果:";if(state==-1) cout<<"ERROR,";printf("L=(%s) ",; //输出结果if(ch=='D'&&state!=-1) cout<<",e="<<e;}链式存储结构线性表程序清单:// - - - - -单链存储结构线性表的插入删除 - - - - -#include <iostream>#include <>using namespace std;#define null 0typedef char ElemType; //定义数据元素类型为字符型typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkList;int GetElem(LinkList L,int i,ElemType &e) //获取第i个元素的值 {LinkList p;int j;p=L->next; j=1;while(p&&j<i){p=p->next; ++j; //寻找第i个元素}if(!p||j>i) return -1; //寻找失败e=p->data;return 1;}int ListInsert(LinkList &L,int i,ElemType e){//在带头结点的单链线性表L中第i个元素之前插入元素eLinkList p,s; int j;p=L;j=0;while(p&&j<i-1) {p=p->next;++j;}if(!p||j>i-1) return -1;s=(LinkList) malloc( sizeof(LNode));s->data=e;s->next=p->next;p->next=s;return 1;}int ListDelete(LinkList&L,int i,ElemType&e){//在带头结点的单链线性表L中,删除第i个元素,并由e返回其值LinkList p,q; int j;p=L;j=0;while(p->next&&j<i-1){p=p->next;++j;}if(!(p->next)||j>i-1) return -1;q=p->next;p->next=q->next;e=q->data;free(q);return 1;}int newdata(LinkList&L,char *ch){int k;printf("请输入原始数据(字符串个数0~99):L="); //数据初始化gets(ch);for (k=0;ch[k]!='\0';k++) ListInsert(L,k+1, ch[k]); //将初始化数据插入链表L中cout<<"OK"<<endl;return k; //返回链表中的元素个数}int main (){char *ch;ch=(char *)malloc(100*sizeof(char)); //定义数组用来辅助数据初始化LinkList L; //头指针LNode head; //头结点L=&head; =null;int i,k,state; char e,CH,f;k=newdata(L,ch); //调用函数使链表数据初始化=k; //将元素个数存入头结点的数据域printf("操作:插入(I)还是删除(D)\n"); //判断进行插入还是删除操作AGAIN:cin>>CH;if(CH=='I'){cout<<"插在第几个元素之前:"; //插入操作cin>>i; cout<<"输入要插入的新元素:";cin>>e;cout<<endl;printf("输入数据:L=(%s) ListInsert(L,%d,%c)",ch,i,e);state=ListInsert(L,i,e);++;}else if (CH=='D'){cout<<"删除第几个元素:"; //删除操作cin>>i;cout<<endl;printf("输入数据:L=(%s) DeleteList(L,%d,e)",ch,i);state=ListDelete(L,i,e);--;}else goto AGAIN; //操作指示符输入错误处理cout<<endl<<"正确结果:";if(state==-1) cout<<"ERROR,"; //输出结果cout<<"L=(";for(int m=1;>=m;m++) //一一输出数据{GetElem(L,m,f);cout<<f;}cout<<")";if(CH=='D'&&state!=-1) cout<<",e="<<e; //删除操作反馈e }实验结果:由于两个程序的输出模式相同,在此只列一组测试数据:L = () ListInsert (L, 1, 'k')L = (EHIKMOP) ListInsert (L, 9, 't')L = (ABCEHKNPQTU) ListInsert(L, 4, 'u') L = () ListDelete (L, 1, e)L = (DEFILMNORU) ListDelete_Sq(L, 5, e) L = (CD) ListDelete_Sq(L, 1, e)测试过程中所注意到的问题主要还是输出与输入界面的问题,通过灵活使用cout和cin函数来不断改进。
数据结构--实验报告 线性表的基本操作
一、实验目的二、实验内容和要求三、源代码1)顺序表的代码2)单链表的代码四、测试结果1)顺序表的测试结果2)单链表的测试结果五、心得体会实验一线性表的基本操作及其应用一、实验目的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++)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<<"请选择所要取出元素的位置:";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<<"请选择所要取出元素的位置:";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);default : cout<<"输入有误,请重新输入"<<endl;break;}}}四、测试结果1)顺序表的测试结果2)单链表的测试结果五、心得体会当听到老师说写数据结构实验报告时,我有点惊讶,才学了不到一个月,就要写实验报告。
数据结构实验报告(一)线性表的应用
数据结构实验报告(⼀)线性表的应⽤实验说明数据结构实验⼀ 线性表的实验——线性表的应⽤⼀、实验⽬的通过本实验使学⽣了解线性表的⼀种简单应⽤,熟悉线性表顺序存储与链式存储的特性,特别训练学⽣编程灵活控制链表的能⼒,为今后编程控制更为复杂的数据结构奠定基础。
⼆、实验内容1.⽤顺序表和链表分别分别编程实现教材中例⼦2-1与2-2。
要求:(1)只能⽤C语⾔编程实现;(2)完全保持书中算法2.1与算法2.2形式,不允许有任何变化,除⾮语法上不允许;所调⽤各函数参照书中19页的功能描述,其中函数名、参数个数及性质、函数功能必须与书中完全⼀致,不能有变化。
2.利⽤线性表表⽰⼀元多项式完成多项式的加、减、乘、求导、求值运算。
要求:(1)输⼊的⼀元多项式可以采⽤只输⼊各项的系数与指数这种简化的⽅式。
如对于多项式2x2+6x5,输⼊可为: 2,2 6,5 这样的简单形式。
(2)遇到有消项时应当处理,如2x2+6x5与3x2-6x5进⾏相加时,结果为5*x^2。
(3)当给定x的值时,能计算表达式相加或相减的结果。
(4)操作的结果放⼊⼀个新线性表中,原来的两个表达式存储表⽰不变,也可以不是产⽣新的线性表,⽽是将两上线性表合并为⼀个。
(5)要求程序功能模块划分合理(每个函数功能单⼀、可重⽤性好),使⽤空间尽可能少,算法尽可能⾼效。
实验报告1.实现功能描述使⽤线性表表⽰⼀元多项式完成多项式的加、减,乘,求导、求值运算。
2.⽅案⽐较与选择(1)因为使⽤的是线性表,所以主要⽅案有数组法和链表法。
(2)从时间复杂度来说,使⽤数组法更优;从空间复杂度来说,链表法更优。
因为数组法是指定好空间的,若式⼦⼤⼩超出设置⼤⼩,那程序必然出错;若式⼦⼤⼩⼩于设置⼤⼩,那就意味着有多余的空间被浪费了。
综合来讲,若计算式⼦较为庞⼤,使⽤链表法更佳;相反,若计算式⼦较⼩,数组法更佳。
3.设计算法描述(1)单个项式的数据存储使⽤了结构体,数组法是在⼀个结构体中定义两个⼀维数组;链表法是通过⼀个结构体作为⼀个节点,通过next指针连接起来。
线性表及其应用实验报告
数据结构实验报告实验名称:线性表及其应用班级:12级电气本2学号:2012081227姓名:赵雪磊指导教师:梁海丽日期:2013年9月9日数学与信息技术学院一、实验目的1、掌握线性表的概念,理解线性表的顺序、链式存储。
2、掌握线性表的基本操作,插入、删除、查找,以及线性表合并等运算在顺序存储结构和链接存储结构上的运算。
二、实验要求1、建立顺序存储的线性表,并对之进行插入、删除操作。
2、建立链式存储的线性表,并对之进行插入、删除操作。
;三、算法描述#include <cstdlib>#include <iostream>#include "myList.h"using namespace std;template <class T> class Link {public:T data; // 用于保存结点元素的内容Link * next; // 指向后继结点的指针Link(const T info, Link* nextValue = NULL) { // 具有两个参数的Link构造函数data = info;next = nextValue;}Link(Link* nextValue = NULL) { // 具有一个参数的Link构造函数next = nextValue;}}// 【代码2.7】单链表的类型定义template <class T>class lnkList : public List<T> {protected:Link<T>* head, tail; // 单链表的头、尾指针public:lnkList(); // 构造函数~lnkList(); // 析构函数bool isEmpty(); // 判断链表是否为空void clear(); // 将链表存储的内容清除,成为空表int length(); // 返回此顺序表的当前实际长度bool append(T value); // 在表尾添加一个元素value,表的长度增1 bool insert(int p, T value); // 在位置p上插入一个元素value,表的长度增1 bool delete(int p); // 删除位置p上的元素,表的长度减 1int getPos(const T value); // 查找值为value的元素,并返回第1次出现的位置Link<T> setPos(int p); // 返回线性表指向第p个元素的指针值}template <class T>class lnkList:: lnkList() {head = tail = new Link<T>;}template <class T>class lnkList:: ~lnkList() {Link tmp;while (head != NULL) {tmp = head;head = head->next;delete tmp;}}template <class T> // 假定线性表的元素类型为TLink lnkList :: setPos(int i) {int count = 0;Link *p;if (i == -1) // i为-1则定位到"虚"头结点return head;p = head->next; // 若i为0则定位到第一个结点while (p != NULL && count < i) {p = p-> next;count++;};return p; // 指向第 i 结点,i=0,1,…,当链表中结点数小于i时返回NULL }template <class T> // 假定线性表的元素类型为Tbool lnkList :: insert (int i, T value) {Link *p, *q;q = new Link<T>;p = setPos(i-1); // p是第i个结点的前驱if (p == NULL ) {cout << " the inserted point is illegal"<<endl;return false;}q->next = p->next;q->data = value;p->next = q;if (q->next == NULL ) // 插入点在链尾,插入结点成为新的链尾tail = q;return true;}// delete a node from singly linked listtemplate <class T> // 假定线性表的元素类型为Tbool lnkList :: delete(int i) {Link *p, *q;p = setPos(i-1); // p是第i个结点的前驱if (p == NULL ) {cout << " the deletion point is illegal"<<endl;return false;}q = p->next; // q是真正待删结点if (q == tail) // 待删结点为尾结点,则修改尾指针tail = p;if (q != NULL) { // 删除结点q 并修改链指针p->next = q->next;delete q;}return true;}template <class T> // 假定顺序表的元素类型为Tvoid lnkList<T> :: print() {while (head != NULL) {cout << head->data;cout << endl; // 从位置p开始每个元素左移直到curLen, tmp = head;head = head->next;}}四、程序清单#include <iostream.h>#define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #defineOVERFLOW -2typedef int Status;typedef int ElemType;#define LIST_INIT_SIZE 10 #define LISTINCREMENT 2typedef struct shunxubiao{ ElemType *list;int size;int Maxsize; }SqList;int InitList_Sq(SqList &L) {// 构造一个空的线性表L。
数据结构实验一 线性表的应用(班级通讯录代码及测试界面)
printf("\t**********************欢迎使用班级通讯录**********************\n\n"); printf("\t\t\t╔━━━━━═操作目录═━━━━━╗\n"); printf("\t\t\t┃ ┃\n"); printf("\t\t\t┃ ◇1.显示通讯录记录 ┃\n"); printf("\t\t\t┃ ┃\n"); printf("\t\t\t┃ ◇2.添加通讯录成员 ┃\n"); printf("\t\t\t┃ ┃\n"); printf("\t\t\t┃ ◇3.删除通讯录成员 ┃\n"); printf("\t\t\t┃ ┃\n"); printf("\t\t\t┃ ◇4.查找通讯录成员 ┃\n"); printf("\t\t\t┃ ┃\n"); printf("\t\t\t┃ ◇5.插入通讯录记录 ┃\n"); printf("\t\t\t┃ ┃\n"); printf("\t\t\t┃ ◇6.退出班级通讯录 ┃\n"); printf("\t\t\t┃ ┃\n"); printf("\t\t\t╚━━━━━━━━━━━━━━━━╝\n"); printf("\n\t**************************************************************\n"); printf("\n\n\t\t\t 请选择操作:"); scanf("%d",&set); printf("\n"); return set; } void key () { //任意键函数 printf("\n\t\t\t\t[按任意键返回主界面]\n\n"); getchar(); getchar(); }
数据结构线性表的实现与应用完整版
实验报告课程名称数据结构__________实验项目线性表的实现及应用实验仪器PC机一台_________学院 ____________________________ 专业 ____________________________ 班级/学号__________________________ 姓名 ______________________________ 实验日期____________________________ 成绩 ____________________________指导教师___________________________北京信息科技大学信息管理学院(数据结构课程上机)实验报告1. 实验目的:(1)理解用顺序表实现线性表的特点;熟练掌握顺序表的基本操作;学会利用顺序表解决实际应用问题 (2)熟练掌握单链表的使用;理解用链表实现线性表的特点;了解链表的多种形式;学会利用单链表解决实际应用问题。
2. 实验要求:(1) 学时为8学时;(2) 能在机器上正确、调试运行程序; (3) 本实验需提交实验报告;(4)实验报告文件命名方法:数据结构实验 —信管16xx_学号J 生名.doc 。
3. 实验内容和步骤:第一部分顺序表的实现与应用(1)基于顺序表实现线性表的以下基本操作:T 表示数据元素的数据类型〃判断线性表是否空 //返回线性表长度//返回第i (i > 0)个元素 〃设置第i 个元素值为x〃插入x 作为第i 个元素//在线性表最后插入x 元素 〃删除第i 个元素并返回被删除对象 int search(T key); 〃查找,返回首次出现的关键字为 key 的元素的位序 void removeAII(); 〃删除线性表所有元素public String toString();//返回顺序表所有元素的描述字符串,形式为 }要求:实现后应编写代码段对每个基本操作做测试。
数据结构线性表实验报告五篇
数据结构线性表实验报告五篇第一篇:数据结构线性表实验报告实验报告课程名:数据结构实验名:线性表及其操作姓名:班级:学号:撰写时间: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 线性表应用
void Init_SeqList(SeqList &L);//创建空顺序表算法 void Show_SeqList(SeqList L);//顺序表输出算法 void Create_SeqList(SeqList &L);//顺序表的创建算法 int Insert_SeqList(SeqList &L,DataType x,int i);//顺序表的插入算法 int Delete_SeqList(SeqList &L,int i);//顺序表的删除算法 void Sort_SeqList(SeqList &L);//顺序表的排序算法 int Insert_SeqList_sort(SeqList &L,DataType x);//有序表的插入算法 void menu(); //菜单算法
cin>>i; cout<<endl<<"请输入插入元素值:"; cin>>x;
cout<<endl; m=Insert_SeqList(L,x,i); if (m==1)
{ cout<<"插入操作后:"<<endl;
Show_SeqList(L); } else if (m==0) cout<<"插入位置不合法!"<<endl; else cout<<"发生溢出!"<<endl; break; }
int main() { menu(); }
void menu()
{
SeqList L;
Init_SeqList(L);
int m;
(完整版)数据结构线性表的应用实验报告
实验报告课程名称____数据结构上机实验__________ 实验项目______线性表的应用 ____________实验仪器________PC机___________________系别_____电子信息与通信学院___专业________ ___班级/学号______ __学生姓名______ ___________实验日期_______________________成绩_______________________指导教师_______________________实验一.线性表的应用1.实验目的:掌握线性链表的存储、运算及应用。
利用链表实现一元多项式计算。
2.实验内容:1)编写函数,实现用链表结构建立多项式;2)编写函数,实现多项式的加法运算;3)编写函数,实现多项式的显示;4)测试:编写主函数,它定义并建立两个多项式,显示两个多项式,然后将它们相加并显示结果。
变换测试用的多项式,检查程序的执行结果。
选做内容:修改程序,选择实现以下功能:5)多项式求值:编写一个函数,根据给定的x值计算并返回多项式f(x)的值。
测试该函数(从终端输入一个x的值,调用该函数并显示返回结果)。
6)多项式相减:编写一个函数,求两个多项式相减的多项式。
7)多项式相乘:编写一个函数,求两个多项式的乘积多项式。
3.算法说明:1)多项式的建立、显示和相加算法见讲义。
可修改显示函数,使输出的多项式更符合表达规范。
2)多项式减法:同次项的系数相减(缺项的系数是0)。
例如a(x)=-5x2+2x+3,b(x)= -4x3+3x,则a(x)-b(x)=4x3-5x2-x+3。
提示:a(x)-b(x) = a(x)+(-b(x))。
3)多项式乘法:两个多项式的相乘是“系数相乘,指数相加”。
算法思想是用一个多项式中的各项分别与另一个多项式相乘,形成多个多项式,再将它们累加在一起。
例如,a(x)=-5x2+2x+3,b(x)=-4x3+3x,则a(x)*b(x) = (-4x3)*(-5x2+2x+3)+(3x)*(-5x2+2x+3)= (20x5-8x4-12x3) + (-15x3+6x2+9x) =20x5-8x4-27x3+6x2+9x。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验一线性表及其应用一、实验目的1.熟悉C语言的上机环境,进一步掌握C语言的结构特点。
2.掌握线性表的顺序存储结构的定义及C语言实现。
3.掌握线性表的链式存储结构——单链表的定义及C语言实现。
4.掌握线性表在顺序存储结构即顺序表中的各种基本操作。
5.掌握线性表在链式存储结构——单链表中的各种基本操作。
二、实验内容1.顺序线性表的建立、插入及删除。
2.链式线性表的建立、插入及删除。
三、实验步骤1.建立含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度。
2.利用前面的实验先建立一个顺序表L={21,23,14,5,56,17,31},然后在第i个位置插入元素68。
3.建立一个带头结点的单链表,结点的值域为整型数据。
要求将用户输入的数据按尾插入法来建立相应单链表。
四、实现提示1.由于C语言的数组类型也有随机存取的特点,一维数组的机内表示就是顺序结构。
因此,可用C语言的一维数组实现线性表的顺序存储。
在此,我们利用C语言的结构体类型定义顺序表:#define MAXSIZE 1024typedef int elemtype; /* 线性表中存放整型元素*/typedef struct{ elemtype vec[MAXSIZE];int len; /* 顺序表的长度*/}sequenlist;将此结构定义放在一个头文件sqlist.h里,可避免在后面的参考程序中代码重复书写,另外在该头文件里给出顺序表的建立及常量的定义。
2. 注意如何取到第i个元素,在插入过程中注意溢出情况以及数组的下标与位序(顺序表中元素的次序)的区别。
3.单链表的结点结构除数据域外,还含有一个指针域。
用C语言描述结点结构如下:typedef int elemtype;typedef struct node{ elemtype data; //数据域struct node *next; //指针域}linklist;注意结点的建立方法及构造新结点时指针的变化。
构造一个结点需用到C语言的标准函数malloc(),如给指针变量p分配一个结点的地址:p=(linklist *)malloc(sizeof(linklist));该语句的功能是申请分配一个类型为linklist的结点的地址空间,并将首地址存入指针变量p 中。
当结点不需要时可以用标准函数free(p)释放结点存储空间,这时p为空值(NULL)。
五、思考与提高1. 如果按由表尾至表头的次序输入数据元素,应如何建立顺序表。
2. 在main函数里如果去掉L=&a语句,会出现什么结果?六、完整参考程序1.顺序线性表的建立、插入及删除。
#include <stdio.h>#include <conio.h>#define MAX 30 //定义线性表的最大长度enum BOOL{False,True}; //定义BOOL型typedef struct{char elem[MAX]; //线性表int last; //last指示当前线性表的长度}sqlist;void initial(sqlist &); //初始化线性表BOOL insert(sqlist &,int,char); //在线性表中插入元素BOOL del(sqlist&,int,char &); //在线性表中删除元素int locate(sqlist,char); //在线性表中定位元素void print(sqlist); //显示线性表中所有元素void main(){sqlist S; //S为一线性表int loc,flag=1;char j,ch;BOOL temp;printf("本程序用来实现顺序结构的线性表。
\n");printf("可以实现查找、插入、删除等操作。
\n");initial(S); //初始化线性表while(flag){ printf("请选择:\n");printf("1.显示所有元素\n");printf("2.插入一个元素\n");printf("3.删除一个元素\n");printf("4.查找一个元素\n");printf("5.退出程序\n");scanf(" %c",&j);switch(j){case '1':print(S); break; //显示所有元素case '2':{printf("请输入要插入的元素(一个字符)和插入位置:\n");printf("格式:字符,位置;例如:a,2\n");scanf(" %c,%d",&ch,&loc); //输入要插入的元素和插入的位置temp=insert(S,loc,ch); //插入if(temp==False) printf("插入失败!\n"); //插入失败else {printf("插入成功!\n"); print(S);} //插入成功break;}case '3':{printf("请输入要删除元素的位置:");scanf("%d",&loc); //输入要删除的元素的位置temp=del(S,loc,ch); //删除if(temp==True) printf("删除了一个元素:%c\n",ch); //删除成功else printf("该元素不存在!\n"); //删除失败print(S);break;}case '4':{printf("请输入要查找的元素:");scanf(" %c",&ch); //输入要查找的元素loc=locate(S,ch); //定位if(loc!=-1) printf("该元素所在位置:%d\n",loc+1); //显示该元素位置else printf("%c 不存在!\n",ch);//当前元素不存在break;}default:flag=0;printf("程序结束,按任意键退出!\n");}getch();}void initial(sqlist &v){//初始化线性表int i;printf("请输入初始线性表长度:n="); //输入线性表初始化时的长度scanf("%d",&st);printf("请输入从1到%d的各元素(字符),例如:abcdefg\n",st); getchar();for(i=0;i<st;i++) scanf("%c",&v.elem[i]); //输入线性表的各元素}BOOL insert(sqlist &v,int loc,char ch){//插入一个元素,成功返回True,失败返回Falseint i;if((loc<1)||(loc>st+1)){printf("插入位置不合理!\n"); //位置不合理return False;}else if(st>=MAX) //线性表已满{printf("线性表已满!\n");return False;}else {for(i=st-1;i>=loc-1;i--) v.elem[i+1]=v.elem[i];//其后元素依次后移v.elem[loc-1]=ch; //插入元素st++; //线性表长度加一return True;}}BOOL del(sqlist &v,int loc,char &ch){//删除一个元素,成功返回True,并用ch返回该元素值,失败返回Falseif(loc<1||loc>st) //删除位置不合理return False;else {ch=v.elem[loc-1]; //ch取得该元素值for(j=loc-1;j<st-1;j++) v.elem[j]=v.elem[j+1]; //其后元素依次前移st--; //线性表长度减一return True;}}int locate(sqlist v,char ch){//在线性表中查找ch的位置,成功返回其位置,失败返回-1int i=0;while(i<st&&v.elem[i]!=ch) i++; //当前位置后移,直到找到为止if(v.elem[i]==ch) //找到当前元素return i;else return(-1);}void print(sqlist v) //显示当前线性表所有元素{int i;for(i=0;i<st;i++) printf("%c ",v.elem[i]);printf("\n");}2.链式线性表的建立、插入及删除。
#include <conio.h>#include <stdio.h>#include <stdlib.h>#define LEN sizeof(LNode) //定义LEN为一个节点的长度enum BOOL{False,True}; //定义BOOL型typedef struct node{char data; //数据域struct node *next;//指向下一个节点的指针}LNode,*LinkList;void CreatList(LinkList &,int); //生成一个单链表BOOL ListInsert(LinkList &,int,char); //在单链表中插入一个元素BOOL ListDelete(LinkList &,int,char &); //在单链表中删除一个元素BOOL ListFind_keyword(LinkList,char,int &); //按关键字查找一个元素BOOL ListFind_order(LinkList,char &,int); //按序号查找一个元素void ListPrint(LinkList); //显示单链表所有元素void main(){LinkList L;BOOL temp;int num,loc,flag=1;char j,ch;printf("本程序实现链式结构的线性表的操作。