实验一-线性表及其应用(I)
实验1线性表及其应用实验报告
实验1线性表及其应⽤实验报告暨南⼤学本科实验报告专⽤纸课程名称数据结构成绩评定实验项⽬名称线性表及其应⽤指导教师王晓明实验项⽬编号实验⼀实验项⽬类型综合性实验地点南海楼601 学⽣姓名朱芷漫学号2010051875学院信息科学技术学院系计算机专业计算机科学与技术实验时间2011年9⽉7⽇18:30午~9⽉7⽇20:30午温度℃湿度⼀、实验⽬的和要求实验⽬的:熟练掌握线性表基本操作的实现及应⽤实验要求:在上机前写出全部源程序完毕并调试完毕。
⼆、实验原理和主要内容1.建⽴4个元素的顺序表SqList={2,3,4,5},实现顺序表的基本操作;在SqList={2,3,4,5}的元素4与5之间插⼊⼀个元素9,实现顺序表插⼊的基本操作;在SqList={2,3,4,9,5}中删除指定位置(i=3)上的元素,实现顺序表删除的操作。
2.利⽤顺序表完成⼀个班级的⼀个学期的课程的管理:能够增加、删除、修改学⽣的成绩记录。
三、主要仪器设备PC机,Windows XP操作平台,Visual C++四、调试分析学⽣课程管理系统的调试过程中发现⼀些错误,主要是参数设置的问题,经过修改,错误得到排除。
五、测试结果1.顺序表2.学⽣课程管理系统附录(源程序)1.顺序表的操作#include#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef int ElemType;#define LIST_INIT_SIZE 10 #define LISTINCREMENT 2 typedef struct shunxubiao{ElemType *list;int size;int Maxsize;}SqList;int InitList_Sq(SqList &L) {// 构造⼀个空的线性表L。
实验一 线性表及其应用(I)
姓名学号ElemType data; //待插入元素SqList L; //定义SqList类型变量InitList_Sq(L); //初始化顺序表printf("※1. 请输入所需建立的线性表的长度:");scanf_s("%d", &LIST_MAX);printf("※2. 请录入数据:");for (i = 0; i<LIST_MAX; i++){scanf_s("%d", &(L.elem[i])); //向顺序表中输入数据++L.length; //表长自增1}printf("※3. 请选择数据的排序方式(0:递减,1:递增):");scanf_s("%d", &DIR);if (DIR){BubbleSortList_Sq(L, INCREASE); //将顺序表递增排序printf("※4. 数据递增排列:");}else{BubbleSortList_Sq(L, DECREASE); //将顺序表递减排序printf("※4. 数据递减排列:");}PrintfList_Sq(L); //打印输出printf("\n※5. 请输入待插入的元素:");scanf_s("%d", &data);InsertSequentList_Sq(L, data); //将数据元素插入到顺序表L中printf("※6. 插入元素后的顺序表:");PrintfList_Sq(L); //打印输出InverseList_Sq(L); //将顺序表就地逆置printf("\n※7. 就地逆置后的顺序表:");PrintfList_Sq(L); //打印输出printf("\n\n");return 0;}2.头文件”ADT.h”的部分程序如下:#ifndef ADT_H_#define ADT_H_/************************************************************* 常量和数据类型预定义************************************************************//* ------函数结果状态代码------ */#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2/* ------排序方式状态------ */#define INCREASE 1 //递增#define DECREASE 0 //递减/* ------数据类型预定义------ */typedef int Status; //函数结果状态类型typedef int_bool; //bool状态类型/************************************************************* 数据结构类型定义************************************************************//************************线性表*************************//* ------顺序表数据类型定义------ */typedef int ElemType; //顺序表中元素的数据类型/* ------线性表的动态存储分配初始常量预定义------ */#define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量#define LISTINCREMENT 10 //线性表存储空间的分配增量/* ------顺序存储结构类型定义------ */typedef struct{ElemType * elem; //存储空间基址int length; //当前长度int listsize; //当前分配的存储容量}SqList; //顺序表类型3.头文件”DataStructure_LinearList.h”中部分函数定义如下:#include<stdio.h>#include<malloc.h>#include"ADT.h"/** 函数原型:Status InverseList_Sq(SqList &L)* 函数功能:将线性表L就地逆置* 入口参数:结构体类型SqList的引用* 出口参数:返回函数结果状态*/Status InverseList_Sq(SqList &L){int i; //循环变量ElemType temp; //临时变量for (i = 0; i <= (L.length + 1) / 2; i++) //根据对称中心进行数据交换{temp = L.elem[i]; //缓存需要交换的数据L.elem[i] = L.elem[L.length - 1 - i]; //对称位置数据交换L.elem[L.length - 1 - i] = temp;}return OK;} //InverseList_Sq/** 函数原型:Status InsertSequentList_Sq(SqList &L, ElemType e);* 函数功能:向已经过排序的线性表L中插入元素,插入位置由数据在线性表的大小关系确定* 入口参数:结构体类型SqList的引用,待插入的数据* 出口参数:返回函数结果状态*/Status InsertSequentList_Sq(SqList &L, ElemType e){int i,j; //位序变量ElemType *p, *q; //插入位置指针ElemType *newbase; //动态存储分配新基址指针if (L.length >= L.listsize) //当存储空间已满,增加分配{newbase = (ElemType *)realloc(L.elem, (L.listsize +LISTINCREMENT)*sizeof(ElemType)); //存储再分配if (!newbase) //分配失败,返回错误return OVERFLOW;L.elem = newbase; //将新的地址指针赋值,注:另定义一个指针变量newbase,而不用L.elem,是因为防止存储分配失败,使原基址被覆盖L.listsize += LISTINCREMENT; //增加存储容量}if (L.elem[0] <= L.elem[1]) //判断此顺序表是否为递增{for (i = 0; i < L.length; i++) //顺序查找{if (e >= L.elem[i]) //判断待插入元素是否大于当前位置元素j = i; //保存当前元素位序}p = &(L.elem[j+1]); //指向满足上条件元素的后一个位置for (q = &(L.elem[L.length - 1]); q >= p; --q) //将待插入元素位*(q + 1) = *q;*p = e; //插入元素++L.length; //表长自增}else{for (i = 0; i < L.length; i++) //顺序查找{if (e <= L.elem[i]) //判断待插入元素是否小于当前位置元素j = i; //保存当前元素位序}p = &(L.elem[j + 1]); //指向满足上条件元素的后一个位置for (q = &(L.elem[L.length - 1]); q >= p; --q) //将待插入元素位置后的元素依次后移一个位置*(q + 1) = *q;*p = e; //插入元素++L.length; //表长自增}return OK;} //InsertSequentList_Sq/** 函数原型:Status BubbleSortList_Sq(SqList &L,Status direction)* 函数功能:将已有数据的线性表L进行排序,排序方式由参数direction确定* 入口参数:已建立顺序表的引用&L,排序方式direction,当direction = INC = 1时,为递增,反之则为递减* 出口参数:返回函数结果状态*/Status BubbleSortList_Sq(SqList &L,Status direction){int i,j; //循环控制变量ElemType temp; //临时缓存变量if (L.length == 0){printf("错误,当前线性表为空,请录入数据:\n");return ERROR; //线性表错误}if (L.length == 1)return OK;if (L.length >= 2) //表中元素至少多于2个{for (i = L.length; i > 0; --i) //起泡法排序{for (j = 0; j < i - 1; j++){if (L.elem[j]>L.elem[j + 1]) //前一个元素大于后一个元素{temp = L.elem[j]; //保持较大的元素if (direction) //排序方式为递增{L.elem[j] = L.elem[j + 1]; //交换L.elem[j + 1] = temp;}}else{temp = L.elem[j]; //保持较小的元素if (!direction) //排序方式为递减{L.elem[j] = L.elem[j + 1]; //交换L.elem[j + 1] = temp;}}}}}return OK;} //BubbleSortList_Sq运行结果实验结果分析:从以上实验运行结果来说,程序可以实现实验要求的基本内容,至于数据输入等操作步骤从上图可以简单、明了的看出。
实验一 线性表的应用
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个数,元素间的顺序没有意义。
实验1线性表及其应用
实验1 线性表及其应用实验性质:验证性实验学时:2学时一、实验目的1.掌握线性表的顺序存储结构在计算机的表示方法及其基本操作的实现;2.掌握线性表的链式存储结构在计算机的表示方法及其基本操作的实现;3.能够利用线性表结构对实际问题进行分析建模,利用计算机求解。
二、实验预备知识1.复习C/C++语言相关知识(如:结构体的定义、typedef的使用、函数的定义、调用及参数传递方式);2.阅读并掌握顺序表与链表的类型定义及其查找、插入、删除等基本操作。
三、实验内容1.理解并分别用顺序表、链表的操作运行下列程序:#include <iostream>using namespace std;#include "Status.h"typedef int ElemType;#include "SqList.h" //用#include "LinkList.h"替换void main(){SqList L; //用LinkList L;替换,与#include "LinkList.h"配合int n,i;ElemType e;InitList(L);cout<<"\nL=";ListTraverse(L);cout<<"\n请设置将向线性表L中输入的元素个数:";cin>>n;CreateList(L,n);cout<<"\nL=";ListTraverse(L);cout<<"\nL的表长为:"<<ListLength(L)<<endl;cout<<"\n请输入想要获取的元素位序:";cin>>i;if(GetElem(L,i,e)) cout<<"\n第"<<i<<"个元素为:"<<e<<endl;else cout<<"\n第"<<i<<"个元素不存在!"<<endl;cout<<"\n请输入要查找的元素:";cin>>e;if(i=LocateElem(L,e)) cout<<"\n元素"<<e<<"的位置为:"<<i<<endl;else cout<<"\n元素"<<e<<"不存在!"<<endl;cout<<"\n请输入插入位置和所插入元素:";cin>>i>>e;if(ListInsert(L,i,e)){cout<<"\nL=";ListTraverse(L);}else cout<<"\n插入操作失败!"<<endl;cout<<"\n请输入被删元素的位置:";cin>>i;if(ListDelete(L,i,e)) cout<<"\n被删元素为:"<<e<<endl;else cout<<"\n删除操作失败!"<<endl;cout<<"\nL=";ListTraverse(L);}本题目说明:(1)头文件Status.h的内容如下:#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;(2)头文件SqList.h(内容包括顺序表的结构定义及基本操作实现)。
“线性表及其应用”实验报告
序号73 学号2013112000 姓名张三实验 2 实验名称线性表及其应用难度等级B+一、需求分析1、问题描述设计一个一元稀疏多项式简单计算器.2、基本要求一元稀疏多项式基本功能包括:1)输入并建立多项式⏹一元n次多项式:P(x)=c m+c m-1+…+c1,其中n=e m>e m-1>…>e1≥0,c i≠0(i=1,2,m)n⏹输入(c m,e m)(c m-1,e m-1)…(c1,e1)构建一元n次m项多项式2)输出多项式:c m x^e m+c m-1x^e m-1+…+c1x^e13)多项式a和b相加,建立a+b4)多项式a和b相减,建立a-b3、测试数据1)(-3.1x11+5x8+2x)+(11x9-5x8+7)=(-3.1x11+11x8+2x+7)2)(-1.2x9+6x-3+4.4x2-x)-(7.8x15+4.4x2-6x-3)=(-7.8x15-1.2x9+12x-3-x)3)(x5+x4+x3+x2+x+1)-(-x4-x3)=(x5+x2+x+1)4)(x3+x)-(-x3-x)=05)(x100+x)+(x200+x100)=(x200+2x100+x)6)(x3+x2+x)+0=x3+x2+x7)互换上述测试数据中的前后多项式.二、概要设计ADT Polynomial{数据对象: D={a i|a i∈TermSet, i=1,2,…,m,m≥0,TermSet中的每个元素包含一个表示系数的实数和表示指数的整数}数据对象: R1={<a i,a i-1>|a i,a i-1∈D,且a i-1中的指数值小于ai中的指数,i=2,…,m}基本操作:createPoly(&p,m,(*input)())Result: 指数由大到小输入m项的系数和指数,建立一元多项式pdestroyPoly(&p)Condition: 一元多项式p已存在Result: 销毁一元多项式ptraversePoly(p)Result: 输出一元多项式addPoly(&pa,&pb);Condition: 一元多项式pa,pb已存在Result: 完成多项式相加运算,即pa=pa+pb,并销毁一元多项式pb.subtractPoly(&pa,&pb)Condition: 一元多项式pa,pb已存在Result: 完成多项式相减运算,即pa=pa-pb,并销毁一元多项式pb.}ADT Polynomial三、详细设计1、 数据类型定义typedef struct{float coef; int expn;}ElemType;//定义存放多项式中项的系数和指数 typedef struct LNode{ElemType data;struct LNode *next; }LNode, *LNodePtr; typedef struct{LNodePtr hp; int length;}LinkList;//定义链表typedef LinkList Poly;//将链表定义为多项式类型 2、 函数原型定义Status createPoly(Poly &p, int m, Status (*input)(int, float *, int *)); Status traversePoly(Poly p, Status (*visit)(int, int, float, int)); Status destroyPoly(Poly &p);Status addPoly(Poly &pa, Poly &pb);//下面的函数可以根据需要由用户在main()函数中定义 Status input(int, float *, int *); Status visit(int, int, float, int);3、 核心算法描述⏹ createPoly()Status createPoly(Poly &p, int m, Status (*input)(int, float *, int *)){ int i,expn; float coef; LNodePtr s,hp;p.hp =(LNodePtr)malloc(sizeof(LNode)); if(!p.hp) exit(OVERFLOW); p.hp->next=NULL; p.length=0; hp=p.hp;for(i=1;i<=m;i++){(*input)(i,&coef,&expn);s=(LNodePtr)malloc(sizeof(LNode)); if(!s) exit(OVERFLOW); s->data.coef=coef; s->data.expn=expn; s->next=NULL; hp->next=s; hp=s; }p.length=m; return OK; }⏹ traversePoly()Status traversePoly(Poly p, Status (*visit)(int,int, float, int)){ int m;LNodePtr q;构建链表头结点,完成链表初始化 根据用户输入多项式的项信息构建多项式,hp 指向当前创建结点q=p.hp->next;for(m=1;m<=p.length;m++){(*visit)(p.length,m,q->data.coef,q->data.expn);q=q->next;}return OK;}⏹destroyPoly()Status destroyPoly(Poly &p){LNodePtr q;while(p.hp){q=p.hp;p.hp=q->next;free(q);}p.length=0;return OK;}⏹addPoly()Status addPoly(Poly &pa, Poly &pb){LNodePtr q,ap,bh,bp,s;float tcoef;int result;q=pa.hp; ap=q->next; bh=pb.hp; bp=bh->next;while(ap&&bp){result=ap->data.expn-bp->data.expn;if(result<0){s=bp; bp=bp->next; bh->next=bp;q->next=s; s->next=ap; q=s;pa.length++; pb.length--;}else if(result>0){q=ap; ap=ap->next;}else{tcoef=ap->data.coef+bp->data.coef;if(!tcoef){q->next=ap->next; free(ap);ap=q->next;pa.length--;}else{ap->data.coef=tcoef; q=ap;ap=ap->next;}bh->next=bp->next; free(bp);bp=bh->next; pb.length--;}//result=0}//while 根据用户定义的输出函数遍历多项式的每一项并将项和系数输出if(bp) {q->next=bp; pa.length += pb.length; bh->next=NULL; pb.length=0;}free(pb.hp);return OK;}4、函数调用关系main()首先调用createPoly(),traversePoly(),addPoly(),而createPoly()调用用户自定义input()输入多项式信息,traverPoly()调用用户自定义visit()输出多项式信息.四、运行记录测试数据预期结果实际结果分析(-3.1,11) (5,8) (2,1) -3.1x^11+5x^8+2^x -3.1x^11-3.1x^11-3.1x^11 scanf(“(%f,%d)”)(-3.1,11)(5,8)(2,1) -3.1x^11+5x^8+2^x -3.1x^11+5.0x^8+2.0x^1 剔除输入数据项括号之间的空格测试addPoly()pa:(-3.1,11)(5,8)(2,1) pb:(11,9)(-5,8)(7,0) -3.1x^11+11x^9+2x^1+7 -3.1x^11+11x^9+2x^1原因算法中忽略了对pa和pb长度的处理,另外,在将剩余元素加到pa上,忘记对pb头结点的处理即pb.hp->next=NULL五、总结这次实验的难度和复杂度高于第一次实验,第一次实验是熟悉C语言环境,本次实验要求对结构体、链表和多项式项的特点要熟练掌握。
数据结构实验一线性表及其应用
实验一线性表及其应用一、实验目的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;注意结点的建立方法及构造新结点时指针的变化。
数据结构实验一:线性表的应用
数据结构实验报告实验一线性表的应用一、实验目的: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 线性表的应用
实验1 线性表应用一.实验目的1、掌握顺序表数组表示,插入、删除运算及应用;2、掌握单链式的存储结构,链表的建立,插入、删除及应用;二.实验内容与要求1 .顺序表操作( l)定义一个长度为10 的数组A ,即顺序表的形式,并初始化数据,下标为零的元素存放存放线性表的长度;( 2 )建立一个数组元素的插入和浏览函数,能够按照数据从小到大的次序自动找到插入位置完成插入元素的操作,调用此函数插入数据,浏览功能要输出数组元素的存储单元地址和相应的数值;( 3 )建立一个数组元素的删除函数,能够按照数据自动删除指定元素的操作,调用此函数删除与输入数据相等的数组元素。
2、单链表操作建立第二个C 语言程序,完成下列要求:(l)定义一个单链表LLIST;( 2 )建立一个插入函数,将数据作为结点插入到链表的指定位置,完成插入结点的操作,形成新的链表LLIST;( 3 )建立一个删除函数,将链表中的指定位置结点删除。
3、界面要求(1)程序启动后,显示下列选项信息:1—信息浏览 2—插入信息 3—删除信息 0—退出程序(2)输入数字“1”显示输出存储单元地址和相应的数值;(3)输入数字“2”进入插入信息功能模块。
程序提示用户输入要插入的数据,最终实现在线性表头部插入一个数据。
(4)输入数字“3”进入删除信息功能模块。
程序提示并由用户输入要删除的数值信息。
(5)通过输入数字“0”使得程序结束。
(6)当用户执行浏览、插入、删除功能后,程序应继续提示用户通过数字键选择相应功能,直到用户输入数字“0”程序才结束。
3.实验环境的选择本实验通过C语言实现,实验环境可以选择以下两种之一。
(1)微软公司开发的基于Windows系统的集成开发环境,包括Visual C++ 6.0、Visual C++.Net。
其中后者包含于Visual 系统中。
本章的例子和实验都不需要使用可视化编程,因此只需要利用上面的开发工具建立基于控制台的Win32程序即可,程序最终将在一个模拟的Dos环境中执行。
实验 线性表的应用
实验报告实验项目:线性表的运用实验器材: Vc++6.0编程工具系别: 电子信息工程系学号: 0632323姓名: 赵烨昕实验日期: 2008.10.17指导老师:______________________张玲_________________________________ 实验成绩:____________________________________________________________实验一线性表的应用一.实验目的:掌握线性链表的存储、运算及应用。
利用链表实现一元多项式计算。
二.实验步骤:(1)编写函数,实现用链表结构建立多项式;(2)编写函数,实现多项式的加法运算;(3)编写函数,实现多项式的显示;(4)测试:编写主函数,它定义并建立两个多项式,显示两个多项式,然后将它们相加并显示结果。
变换测试用的多项式,检查程序的执行结果。
三.程序清单:#include <stdio.h>#include <malloc.h>typedef struct node{ float coef; /*序数*/int expn; /*指数*/struct node *next; /*指向下一个结点的指针*/} PolyNode;void InitList(PolyNode *&L) /*初始化多项式单链表*/{L=(PolyNode *)malloc(sizeof(PolyNode)); /*建立头结点*/L->next=NULL;}int GetLength(PolyNode *L) /*求多项式单链表的长度*/{int i=0;PolyNode *p=L->next;while (p!=NULL) /*扫描单链表L,用i累计结点个数*/{i++;p=p->next;}return i;}PolyNode *GetElem(PolyNode *L,int i) /*返回多项式单链表中第i个结点的指针*/{int j=1;PolyNode *p=L->next;if (i<1 || i>GetLength(L))return NULL;while (j<i) /*沿next域找第i个结点*/{p=p->next;j++;}return p;}PolyNode *Locate(PolyNode *L,float c,int e) /*在多项式单链表中按值查找*/ {PolyNode *p=L->next;while (p!=NULL && (p->coef!=c ||p->expn!=e))p=p->next;return p;}int InsElem(PolyNode *&L,float c,int e,int i) /*在多项式单链表中插入一个结点*/ {int j=1;PolyNode *p=L,*s;s=(PolyNode *)malloc(sizeof(PolyNode));s->coef=c;s->expn=e;s->next=NULL;if (i<1 || i>GetLength(L)+1)return 0;while (j<i) /*查找第i-1个结点*p*/{p=p->next;j++;}s->next=p->next;p->next=s;return 1;}int DelElem(PolyNode *L,int i) /*在多项式单链表中删除一个结点*/{int j=1;PolyNode *p=L,*q;if (i<1 || i>GetLength(L))return 0;while (j<i) /*在单链表中查找第i-1个结点,由p指向它*/{p=p->next;j++;}q=p->next; /*q指向被删结点*/p->next=q->next; /*删除*q结点*/free(q);return 1;}void DispList(PolyNode *L) /*输出多项式单链表的元素值*/{PolyNode *p=L->next;while (p!=NULL){printf("(%g,%d) ",p->coef,p->expn);p=p->next;}printf("\n");}void CreaPolyList(PolyNode *&L,float C[],int E[],int n){int i;InitList(L);for (i=0;i<n;i++)InsElem(L,C[i],E[i],i+1);}void SortPloy(PolyNode *&L) /*对L的多项式单链表按expn域递增排序*/ {PolyNode *p=L->next,*q,*pre;L->next=NULL;while (p!=NULL){if (L->next==NULL) /*处理第1个结点*/{L->next=p;p=p->next;L->next->next=NULL;}else /*处理其余结点*/{pre=L;q=pre->next;while (q!=NULL && p->expn>q->expn) /*找q->expn刚大于或等于p->expn的结点*q的前驱结点*pre*/{pre=q;q=q->next;}q=p->next; /*在*pre结点之后插入*p*/p->next=pre->next;pre->next=p;p=q;}}}PolyNode *AddPoly(PolyNode *pa,PolyNode *pb){PolyNode *pc,*p1=pa->next,*p2=pb->next,*p,*tc,*s;pc=(PolyNode *)malloc(sizeof(PolyNode)); /*新建头结点*pc*/ pc->next=NULL; /*pc为新建单链表的头结点*/tc=pc; /*tc始终指向新建单链表的最后结点*/while (p1!=NULL && p2!=NULL){if (p1->expn<p2->expn) /*将*p1结点复制到*s并链到pc尾*/{s=(PolyNode *)malloc(sizeof(PolyNode));s->coef=p1->coef;s->expn=p1->expn;s->next=NULL;tc->next=s;tc=s;p1=p1->next;}else if (p1->expn>p2->expn) /*将*p2结点复制到*s并链到pc尾*/{s=(PolyNode *)malloc(sizeof(PolyNode));s->coef=p2->coef;s->expn=p2->expn;s->next=NULL;tc->next=s;tc=s;p2=p2->next;}else /*p1->expn=p2->expn的情况*/{if (p1->coef+p2->coef!=0) /*序数相加不为0时新建结点*s并链到pc尾*/{s=(PolyNode *)malloc(sizeof(PolyNode));s->coef=p1->coef+p2->coef;s->expn=p1->expn;s->next=NULL;tc->next=s;tc=s;}p1=p1->next;p2=p2->next;}}if (p1!=NULL) p=p1; /*将尚未扫描完的余下结点复制并链接到pc单链表之后*/else p=p2;while (p!=NULL){s=(PolyNode *)malloc(sizeof(PolyNode));s->coef=p->coef;s->expn=p->expn;s->next=NULL;tc->next=s;tc=s;p=p->next;}tc->next=NULL; /*新建单链表最后结点的next域置空*/return pc;}void main(){PolyNode *L1,*L2,*L3;float C1[]={3,6,5,7},C2[]={-9,8,11};int E1[]={2,0,15,4},E2[]={9,1,6};InitList(L1);InitList(L2);InitList(L3);CreaPolyList(L1,C1,E1,4);CreaPolyList(L2,C2,E2,3);printf("两多项式相加运算\n");printf(" 原多项式A:");DispList(L1);printf(" 原多项式B:");DispList(L2);SortPloy(L1);SortPloy(L2);printf("排序后的多项式A:");DispList(L1);printf("排序后的多项式B:");DispList(L2);L3=AddPoly(L1,L2);printf("多项式相加结果:");DispList(L3);}实验结果如下:选作题:从终端输入多项式实现多项式相加。
线性表及其应用实验报告
数据结构实验报告实验名称:线性表及其应用班级: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。
实验一 线性表的建立与应用
实验一线性表的建立与应用一实验目的:通过实验,了解并掌握线性表逻辑特性和物理特性,了解并掌握队列和栈的运算方法,培养结合理论知识进行实际应用的实践能力。
二实验内容:队列示意图队列也是一种运算受限制的线性表,它的运算包括:初始化队、入队、退队、读取队首和队尾的数据。
当队列为空时不允许退队,当队列未满的时候不允许入队。
在实际应用中,通常使用循环队列循环队列示意图初始化循环队列四、实验步骤1 进入Turbo C 2.0,新建一个文件。
2 输入程序,程序要求使用子函数进行组织。
3 将源程序保存到指定文件夹“D:\学生姓名”。
4 按F9调试,纠正语法错误。
5按Ctrl+F9运行,调试逻辑错误。
6 按Alt+F5查看结果。
五、实验中应注意的问题与思考题:五、实验中应注意的问题与思考题:1 在对栈和队列的运算过程中保证数据结构的逻辑完整性。
2 栈和循环队列元素的打印。
在打印过程中应该正确分析循环队列的具体情况,做到正确打印。
3 栈与队列均不允许在中间插入数据,保证运算的正确性;线性队列不能重复使用,不符合流程化要求,应采取循环队列。
4 当栈满,而此时要进行退队入栈运算时应进行怎样的处理才能避免数据的丢失?退队入栈时,判断栈是否为满:若为满,则把数据存到其他地方。
5 当队列满,而此时要进行退栈入队运算时应进行怎样的处理才能避免数据的丢失?退栈入队时,判断队列是否为满:若为满,则把数据存到其他地方。
6 应用程序要求循环执行,每次运算结束后要求打印栈和队列中的元素,以查看结果。
7 对各个功能模块采用独立编制子函数,增强程序的可执行性、可移植性和可读性。
增加情报信息量,对实际应用中可能发生的情况考虑周全,对非法情形要提出适当的处理方案。
六、源程序#include "stdlib.h"#include "stdio.h"void push(s,m,top,x) /*******入栈************/int s[],x; int m,*top;{if(*top==m) {printf("栈上溢\n");return;}*top=*top+1;s[*top-1]=x;return;}void pop(s,m,top,y) /************退栈************/int s[],*y; int m,*top;{if(*top==0) {printf("栈下溢\n");return;}*y=s[*top-1];*top=*top-1;return;}out_s(s,m,top) /************输出栈内元素******************/int s[],m,*top;{int *q;q=s+*top-1;printf("输出栈内元素: ");if(q>=s)while(q>=s){ printf("%d ",*(q--)); }else printf("没有元素!!!");printf("\n"\n ");return;}void addcq(q,m,rear,front,s,x) /**************入队******************/int q[],x; int m,*rear,*front,*s;{if((*s==1)&&(*rear==*front)){printf("队列上溢\n");return;}*rear=*rear+1;if(*rear==m+1) *rear=1;q[*rear-1]=x;*s=1;return;}void delcq(q,m,rear,front,s,y) /**************退队*****************/int q[],*y; int m,*rear,*front,*s;{if(*s==0) {printf("队列下溢\n");return;}*front=*front+1;if(*front==m+1) *front=1;*y=q[*front-1];if(*front==*rear) *s=0;return;}out_q(q,m,front,rear,s) /******************输出队内元素******/ int q[],m,*front,*rear,*s;{int k;k=(*front)%m;*front=(*front)%m;*rear=(*rear)%m;printf("输出队列内元素: ");if(*s==1){if(*front<*rear)while(k<*rear){ printf("%d ",q[k]);k++;}else{while(k<=m-1){ printf("%d ",q[k]);k++;}k=0;while(k<*rear){ printf("%d ",q[k]);k++;}}}else { printf("没有元素!!!"); }printf("\n\n ");}main(){int x,y,z,m,n,*s,*q,top,rear,front,l,i,k,j;l=0;m=5;n=5;s=malloc(m*sizeof(int));q=malloc(n*sizeof(int));top=0;rear=n;front=n;printf("输入0, 退出\n");printf("输入1, 压栈\n");printf("输入2, 入队\n");printf("输入3, 弹栈\n");printf("输入4, 退队\n");printf("输入5, 弹栈入队\n");printf("输入6, 退队压栈\n");printf("输入0-6:");scanf("%d",&y);for(;y!=0;){switch(y){case 1:{printf("输入压栈元素\n");scanf("%d",&x);push(s,m,&top,x);out_s(s,m,&top);out_q(q,n,&front,&rear,&l);break;}case 2: {printf("输入入队元素");scanf("%d",&y);addcq(q,n,&rear,&front,&l,y);out_s(s,m,&top);out_q(q,n,&front,&rear,&l);break;}case 3:{pop(s,m,&top,&i);out_s(s,m,&top) ;out_q(q,n,&front,&rear,&l);break;}case 4: {delcq(q,n,&rear,&front,&l,&k);out_s(s,m,&top);out_q(q,n,&front,&rear,&l);break;}case 5:{if(top==0){ pop(s,m,&top,&i);out_s(s,m,&top);out_q(q,n,&front,&rear,&l);break;}pop(s,m,&top,&i);addcq(q,n,&rear,&front,&l,i);out_s(s,m,&top);out_q(q,n,&front,&rear,&l);break;}case 6:{if(l==0){ delcq(q,n,&rear,&front,&l,&k);out_s(s,m,&top);out_q(q,n,&front,&rear,&l);break;}delcq(q,n,&rear,&front,&l,&k);push(s,m,&top,k);out_s(s,m,&top);out_q(q,n,&front,&rear,&l);break;}default:break;}printf("输入0, 退出\n");printf("输入1, 压栈\n");printf("输入2, 入队\n");printf("输入3, 弹栈\n");printf("输入4, 退队\n");printf("输入5, 弹栈入队\n");printf("输入6, 退队压栈\n");printf("输入0-6:");scanf("%d",&y);}free(q);free(s);}七、实验总结通过实验,了解并掌握了线性表逻辑特性和物理特性,了解并掌握了队列和栈的运算方法,培养了结合理论知识进行实际应用的实践能力,受益匪浅。
实验一 线性表及其应用
华北水利水电大学数据结构实验报告2014~2015学年第一学期2012级计算机科学与技术专业实验一线性表及其应用一、实验目的:1.掌握用C语言调试程序的基本方法。
2.掌握线性表的基本运算,如插入、删除等。
二、实验内容:1.编写程序,实现顺序表的各种基本运算(假设顺序表的元素类型为char),并在此基础上完成如下功能:(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。
2.设带头结点的单链表ha和hb中结点数据域值按从小到大顺序排列,且各自链表内无重复的结点,要求:(1)建立两个单链表ha和hb,要求ha和hb都是递增有序的。
(2)将单链表ha合并到单链表hb中,且归并后的hb链表内无重复的结点,结点值仍保持从小到大顺序排列。
(3)输出合并后单链表hb中每个结点的数据域值。
三、程序设计过程及源代码:1. #include <stdio.h>#include <stdlib.h>#define Maxsize 100typedef struct{char data[Maxsize];int Length;}SqList;void InitList(SqList * &L){ //建表并初始化L=(SqList *)malloc(sizeof(SqList));L->Length=0;}void ListInsert1(SqList * &L,char a[],char n) {//顺序表赋值int i;L=(SqList *)malloc(sizeof(SqList));for(i=0;i<n;i++)L->data[i]=a[i];L->Length=n;}bool ListInsert2(SqList * &L,int i,char e) {//在第i的位置上插入元素eint j;if(i<1||i>L->Length+1)return false;i--;for(j=L->Length;j>i;j--)L->data[j]=L->data[j-1];L->data[i]=e;L->Length++;return true;}void Display(SqList *L){ //输出顺序表int i;for(i=0;i<L->Length;i++)printf("%c",L->data[i]);printf("\n");}void ListLength(SqList *L){//输出顺序表长度printf("%d",L->Length);printf("\n");}bool ListEmpty(SqList *L){//判断表L是否为空return(L->Length==0);}void Show(SqList *L,int i){//显示出第i个元素printf("%c",L->data[i-1]);printf("\n");}int Location(SqList *L,char e){//查找并输元素e出位置int i=0;while(i<L->Length && L->data[i]!=e)i++;if(i>L->Length)return 0;elseprintf("%d",i+1);printf("\n");return i+1;}bool Delete(SqList * &L,int i,char e){//删除第i个元素(字符)eint j;if(i<1 || i>L->Length)return false;i--;e=L->data[i];for(j=i;j<L->Length-1;j++)L->data[j]=L->data[j+1];L->Length--;return true;}void Free(SqList * &L){//释放顺序表free(L);}void main(){SqList *L;char s[]={'a','b','c','d','e'};printf("初始化顺序表\n");InitList(L);ListInsert1(L,s,5);printf("赋值后的顺序表为:\n");Display(L);printf("顺序表长度为:");ListLength(L);if(ListEmpty(L))printf("顺序表为空\n");else printf("顺序表不为空\n");printf("顺序表第三个元素为:");Show(L,3);printf("顺序表中a的位置为:");Location(L,'a');printf("在的4个元素的位置上插入新元素f之后顺序表为:\n"); ListInsert2(L,4,'f');Display(L);printf("删除第3个元素后顺序表为:\n"); Delete(L,3,'c');Display(L);Free(L);printf("顺序表已释放\n");}运行结果:2、#include <stdio.h>#include <malloc.h>typedef struct LNode{int data;struct LNode * next;}LinkList;void CreateList(LinkList *&L,int a[],int n) {//尾插法LinkList *s,*r;L=(LinkList *)malloc(sizeof(LinkList)); r=L;for(int i=0;i<n;i++){s=(LinkList *)malloc(sizeof(LinkList));s->data=a[i];r->next=s;r=s;}r->next=NULL;}void Sort(LinkList * &L ){//使插入的数据有序化(从小到大)LinkList *p,*pre,*q;p=L->next->next;L->next->next=NULL;while(p!=NULL){q=p->next;pre=L;while(pre->next!=NULL&& pre->next->data < p->data)pre=pre->next;p->next=pre->next;pre->next=p;p=q;}}void UnionList(LinkList * &L1,LinkList * &L2){//合并两个单链表LinkList * pa=L1->next, *pb=L2->next,*r,*s;L2->next=NULL;r=L2;while(pa!=NULL&&pb!=NULL){if(pa->data ==pb->data )pa=pa->next ;else if(pa->data<pb->data){s=(LinkList *)malloc(sizeof(LinkList));s->data=pa->data;r->next=s;r=s;pa=pa->next;}else{s=(LinkList *)malloc(sizeof(LinkList));s->data=pb->data;r->next=s;r=s;pb=pb->next;}}while(pa!=NULL){s=(LinkList *)malloc(sizeof(LinkList));s->data=pa->data;r->next=s;r=s;pa=pa->next;}while(pb!=NULL){s=(LinkList *)malloc(sizeof(LinkList));s->data=pb->data;r->next=s;r=s;pb=pb->next;}r->next=NULL;}void Display(LinkList *L){LinkList *p=L->next;while(p!=NULL){printf("%d ",p->data);p=p->next;}printf("\n");}void main(){LinkList *ha,*hb;int a[]={4,6,5,8,7,1,9,0,20},b[]={1,6,15,14,18,17,10,3,4};CreateList(ha,a,9);Sort( ha );printf("单链表ha赋值并排序后为:\n");Display(ha);CreateList(hb,b,9);Sort( hb );printf("单链表hb赋值并排序后为:\n");Display(hb);UnionList(ha,hb);printf("将单链表ha,hb合并后为:\n");Display(hb);}运行结果:四、小结经过这次实验,我对顺序表以及链表的相关操作的编译代码的应用有了更进一步的熟悉与应用,这次的实验让我意识到了,再编程这一方面:不管你多么清楚原理,那终究是纸上谈兵,没有经过实际的操作,你永远也不知道编程里需要注意的事项,尤其是一些细节问题。
线性表及其应用实验报告
{
sq->elem=(int *)malloc(LIST_INIT_SIZE*sizeof(int));
sq->length=0;
sq->listsize=LIST_INIT_SIZE;
printf("---申请空间成功---!\n");
实验报告册
课 程:《数据结构》
***********
学 号:*********
专 业:网络工程
班 级:10级网络工程
*******************
2011至2012学年第一学期
洛阳师范学院
信 息 技 术 学 院
实验时间:9月30日3、4节 星期五
实验地点:一号教学楼微机室
实验名称:线性表及其应用
}
刚开始设计时,没有加入这段程序,结果导致整个程序不够健壮。在设计后期,发现了这个问题,就尝试着进行编译,经过不断的编译调试,最后程序可以运行了,尽管依然不够完美。
经过这次实验,能够全面考虑问题了,意识到了程序的健壮性,不只是以程序能否运行为目标环境:微机室、 DEV-C++
实验步骤:1、确定基本思路和设计思想
2、确定程序主题
3、进行编程设计
4、调试程序
5、分析程序错误,编译调试
6、总结经验
实验体会:对程序设计一直讳莫如深,刚接触数据结构,觉得好难,接触一段时间之后,觉得果然如此。编程一直是我的弱项,调试这个程序却是费了不少心力。如:
实验一:线性表应用
实验报告学院(系)名称:计算机与通信工程学院 姓名**学号 ********专业计算机科学与技术班级 2015级*班 实验项目实验一:线性表应用课程名称 数据结构与算法 课程代码 0661013 实验时间2017年3月9日第一节实验地点 7-219 考核标准 实验过程 25分程序运行 20分回答问题15分 实验报告30分 特色 功能5分考勤违纪情况 5分 成绩成绩栏其它批改意见: 教师签字:考核内容 评价在实验课堂中的表现,包括实验态度、编写程序过程等内容等。
□功能完善,□功能不全□有小错□无法运行○正确 ○基本正确○有提示○无法回答○完整 ○较完整○一般 ○内容极少 ○无报告○有 ○无 ○有 ○无一、实验目的? (1)将多项式各项的系数和指数分别存在A、B两个链表的中。
? (2)用指针Pa、Pb分别指向连个链表的首元素。
? (3)遍历两个链表,比较各元素的指数,若相同则相加减,将结果插入新表中,若不相等则将指数较小的插入新表中,继续向后遍历,直到其中一个链表到达表尾。
? (4)将另一表中的剩余元素按指数大小顺序全部插入到新表中。
? (5)新表中的元素按规定格式输出既为相加或相减后的多项式。
? 3、?? (1)通过构造函数创建单链表? (2)通过循环变量temp找到第一个链表的尾部设为p。
? (3)使p的next指向第二个链表的第一个元素? (4)将连接后的两链表输出? 4、? (1)用两个变量minZ,maxZ分别存储输入的最小值和最大值? (2)遍历整个单链表,将小于minZ和大于maxZ的节点删除? (3)输出操作后的单链表? 算法的实现和测试结果:包括算法运行时的输入、输出,实验中出现的问题及解决办法等? 出现问题? 无法返回操作后的单链表? 解决办法? 经老师直到后,在相关函数前面加*成功返回操作后的单链表? 1、3、4、? 算法时间复杂度分析? 1、O(1表长度+2表长度)---------------可视为O(n)? 3、O(1表长度+2表长度)---------------可视为O(n)? 4、O(n)?四、收获与体会线性表分为顺序表和链表,其中顺序表已相当熟悉,主要练了新接触的链表,感觉现在才真正体会到指针的魅力之处。
数据结构 实验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;
实验一__线性表及其应用[1]pp
集美大学数据结构课程实验报告课程名称:数据结构班级:实验成绩:指导教师:吴晓晖姓名:实验项目名称:实验1--线性表及其应用学号:上机实践日期:一、目的理解线性表数据结构及其应用;二、实验内容1.线性表的抽象数据类型的定义2.线性表存储映像---顺序表类定义(包括方法实现)及测试(要求:main中要测试每个方法)测试如下:定义一个顺序表,最大50,存储以下数据元素(1,-9,6,10,400,30,60),输出之。
查找的测试如下:元素30存在否,测试元素67存在否。
插入测试如下:在表的第5个位置插入元素值为12,在第10个元素后插入元素值为18。
删除测试:……。
.3.线性表存储映像—链表的类定义(包括方法实现)及测试(要求:main中要测试每个方法)4.使用顺序表实现有序集合的合并,并分析其时间与空间复杂度。
测试LA('a,e,g,h,x,y )与LB(c,d,e,r)的合并并输出。
5.使用链表实现一元多项式运算,并测试以下两个一元多项的加法,输出实现加法后的结果表示。
并分析其时间与空间复杂度pa=1+10x3-2x100+1000x1300,pb=-1+13x15+2x100-10x10106.设计一个循环链表类,完成约瑟夫问题的解决。
测试共10个人围成一圈,每个人都有一个表示其身份的号牌,从第1个人开始报数,报到3的人出列,求出列的号牌顺序。
可简化用1….10分别表示第1个人至第10个人的号牌。
三、实验使用环境VC++ 6.0控制台程序附:文件—新建---项目(选项卡)--选择console application,给项目名四、实验关键代码与结果展示(部分截图)查找测试:五、附录(代码)。
实验1 线性表及其应用 实验报告
实验1 线性表及其应用一、实验目的和要求:1.加深对线性表的结构特性的理解,熟练掌握单链表类的描述方法及其C++实现;2.掌握线性表的链式存储结构的应用;3.加强对算法的设计能力和程序调试能力的培养。
二、实验时间:2010-3-26三、实验内容:约瑟夫(Joseph)环问题1.问题描述:编号为1,2,…,n的n个人按顺时针方向围坐一圈,从1起报到k则出圈,下一个人再从1报起,如此下去直到圈中只有一人为止。
求最后剩下的人的编号。
2.数据结构设计:(包括类型设计和类的设计)编号为1,2,…,n的n个人可用线性表结构表示,因是围坐一圈,故可采用循环链表(不带表头结点)结构存储。
(1)结点结构定义template<class T>struct Node //定义链表结点结构{T data;Node<T>*link;Node(T e=-1,Node<T>*next=NULL):data(e),link(next){ }};(2)单循环链类设计template<class T>class LinkList //不带表头结点的单循环链类{ private:Node<T> *current,*front; //链表指针,front指向current的前驱结点public:LinkList(int mSize); //构造函数~LinkList(); //析构函数int RemoveCurrent(); //删除current所指结点void movenext(int n); //current后移n次T CurrentData(){return current->data;}bool toLocatioin(T &t); //将current指向元素为t的结点 void Output() const ; //输出链表}; // Class LinkList(3)Joseph类定义template<class T>class Joseph{ private:int numOfBoy;int startPosition;int Interval;public:Joseph(int boys=10,int start=1,int m=3): numOfBoy(boys), startPosition(start), Interval(m){ }int GetWinner();};// Joseph类3.算法设计:(主要包括算法原理、算法流程图、实现等)(1)单循环链类的算法(2)约瑟夫报数出圈算法:设计一个循环链表和一个报数器k,从current所指结点开始报数。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
姓名学号scanf_s("%d", &LIST_MAX);printf("※2. 请录入数据:");for (i = 0; i<LIST_MAX; i++){scanf_s("%d", &(L.elem[i])); //向顺序表中输入数据++L.length; //表长自增1}printf("※3. 请选择数据的排序方式(0:递减,1:递增):");scanf_s("%d", &DIR);if (DIR){BubbleSortList_Sq(L, INCREASE); //将顺序表递增排序printf("※4. 数据递增排列:");}else{BubbleSortList_Sq(L, DECREASE); //将顺序表递减排序printf("※4. 数据递减排列:");}PrintfList_Sq(L); //打印输出printf("\n※5. 请输入待插入的元素:");scanf_s("%d", &data);InsertSequentList_Sq(L, data); //将数据元素插入到顺序表L中printf("※6. 插入元素后的顺序表:");PrintfList_Sq(L); //打印输出InverseList_Sq(L); //将顺序表就地逆置printf("\n※7. 就地逆置后的顺序表:");PrintfList_Sq(L); //打印输出printf("\n\n");return 0;}2.头文件”ADT.h”的部分程序如下:#ifndef ADT_H_#define ADT_H_/************************************************************* 常量和数据类型预定义************************************************************//* ------函数结果状态代码------ */#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2/* ------排序方式状态------ */#define INCREASE 1 //递增#define DECREASE 0 //递减/* ------数据类型预定义------ */typedef int Status; //函数结果状态类型typedef int_bool; //bool状态类型/************************************************************* 数据结构类型定义************************************************************//************************线性表*************************//* ------顺序表数据类型定义------ */typedef int ElemType; //顺序表中元素的数据类型/* ------线性表的动态存储分配初始常量预定义------ */#define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量#define LISTINCREMENT 10 //线性表存储空间的分配增量/* ------顺序存储结构类型定义------ */typedef struct{ElemType * elem; //存储空间基址int length; //当前长度int listsize; //当前分配的存储容量}SqList; //顺序表类型3.头文件”DataStructure_LinearList.h”中部分函数定义如下:#include<stdio.h>#include<malloc.h>#include"ADT.h"/** 函数原型:Status InverseList_Sq(SqList &L)* 函数功能:将线性表L就地逆置* 入口参数:结构体类型SqList的引用* 出口参数:返回函数结果状态*/Status InverseList_Sq(SqList &L){int i; //循环变量ElemType temp; //临时变量for (i = 0; i <= (L.length + 1) / 2; i++) //根据对称中心进行数据交换{temp = L.elem[i]; //缓存需要交换的数据L.elem[i] = L.elem[L.length - 1 - i]; //对称位置数据交换L.elem[L.length - 1 - i] = temp;}return OK;} //InverseList_Sq/** 函数原型:Status InsertSequentList_Sq(SqList &L, ElemType e);* 函数功能:向已经过排序的线性表L中插入元素,插入位置由数据在线性表的大小关系确定* 入口参数:结构体类型SqList的引用,待插入的数据* 出口参数:返回函数结果状态*/Status InsertSequentList_Sq(SqList &L, ElemType e){int i,j; //位序变量ElemType *p, *q; //插入位置指针ElemType *newbase; //动态存储分配新基址指针if (L.length >= L.listsize) //当存储空间已满,增加分配{newbase = (ElemType *)realloc(L.elem, (L.listsize + LISTINCREMENT)*sizeof(ElemType)); //存储再分配if (!newbase) //分配失败,返回错误return OVERFLOW;L.elem = newbase; //将新的地址指针赋值,注:另定义一个指针变量newbase,而不用L.elem,是因为防止存储分配失败,使原基址被覆盖L.listsize += LISTINCREMENT; //增加存储容量}if (L.elem[0] <= L.elem[1]) //判断此顺序表是否为递增{for (i = 0; i < L.length; i++) //顺序查找{if (e >= L.elem[i]) //判断待插入元素是否大于当前位置元素j = i; //保存当前元素位序}p = &(L.elem[j+1]); //指向满足上条件元素的后一个位置for (q = &(L.elem[L.length - 1]); q >= p; --q) //将待插入元素位*(q + 1) = *q;*p = e; //插入元素++L.length; //表长自增}else{for (i = 0; i < L.length; i++) //顺序查找{if (e <= L.elem[i]) //判断待插入元素是否小于当前位置元素j = i; //保存当前元素位序}p = &(L.elem[j + 1]); //指向满足上条件元素的后一个位置for (q = &(L.elem[L.length - 1]); q >= p; --q) //将待插入元素位置后的元素依次后移一个位置*(q + 1) = *q;*p = e; //插入元素++L.length; //表长自增}return OK;} //InsertSequentList_Sq/** 函数原型:Status BubbleSortList_Sq(SqList &L,Status direction)* 函数功能:将已有数据的线性表L进行排序,排序方式由参数direction确定* 入口参数:已建立顺序表的引用&L,排序方式direction,当direction = INC = 1时,为递增,反之则为递减* 出口参数:返回函数结果状态*/Status BubbleSortList_Sq(SqList &L,Status direction){int i,j; //循环控制变量ElemType temp; //临时缓存变量if (L.length == 0){printf("错误,当前线性表为空,请录入数据:\n");return ERROR; //线性表错误}if (L.length == 1)return OK;if (L.length >= 2) //表中元素至少多于2个{for (i = L.length; i > 0; --i) //起泡法排序{for (j = 0; j < i - 1; j++){if (L.elem[j]>L.elem[j + 1]) //前一个元素大于后一个元素{temp = L.elem[j]; //保持较大的元素if (direction) //排序方式为递增{L.elem[j] = L.elem[j + 1]; //交换L.elem[j + 1] = temp;}}else{temp = L.elem[j]; //保持较小的元素if (!direction) //排序方式为递减。