实验一线性表与应用(I)

合集下载

实验1线性表及其应用实验报告

实验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)

实验一 线性表及其应用(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运行结果实验结果分析:从以上实验运行结果来说,程序可以实现实验要求的基本内容,至于数据输入等操作步骤从上图可以简单、明了的看出。

实验一 线性表的应用

实验一 线性表的应用
voidInitializeVote(VoteTp *vote);
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个数,元素间的顺序没有意义。

实验一:线性表应用

实验一:线性表应用

实验报告学院(系)名称:计算机与通信工程学院 姓名**学号 ********专业计算机科学与技术班级 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-线性表及应用

贵州大学数据结构实验1-线性表及应用

实验一线性表及应用一、实验目的1.复习C语言的上机环境,掌握C语言的基本结构;2.会定义线性表的顺序存储结构和链表的存储结构;3.熟悉对顺序表的一些基本操作和具体的函数定义。

4.掌握顺序表和单链表的存储结构及相关运算5.掌握顺序表和单链表的基本应用二、实验硬软件环境硬件环境:赛扬433以上CPU,10GB以上硬盘,64MB以上内存软件环境:DOS+Turbo C 2.0 或Borland C++ 3.1以上Windowx 9X+VC++ 5.0以上三、实验要求1.认真阅读和掌握本实验内容所给的全部程序。

2.保存和打印出程序运行结果,并结合程序进行分析。

3.按照你对顺序表操作的需要,屏幕考贝运行结果到实验报告中。

4.撰写实验报告并准时上交四、注意事项在做第一次“数据结构”课程实验之前,要在硬盘上建立好自己的工作目录,专门用来存储你所做的实验程序及相关信息,以后每次做实验都采用这个目录。

本实验设计完全由老师设计,版权限本班同学使用,勿外传。

实验材料下载到本机后,请用winrar软件释放到你的电脑磁盘的“数据结构实验(张三)”文件夹中,形成如上图的文件夹结构。

上交实验报告时,请把“实验一”的所有内容(含实验报告)用winrar打包成.rar文件后一并交上来。

上传名字为“实验一(张三).rar”五、基本理论线性表:线性表(linear list)是这样的数据对象,其实例形式为: (e1 , e2 ,... en ),其中n 是有穷自然数。

e是表中的元素,n 是表的长度。

元素i可以被视为原子,因为它们本身的结构与线性表的结构无关。

当n = 0 时,表为空;当n > 0时,e1是第一个元素,e n是最后一个元素,可以认为e l优先于e2,e优先于e3,如此等等。

除了这种优先关系之外,在线性表中不再有其他的结构。

2基本操作:• 创建一个线性表。

• 确定线性表是否为空。

• 确定线性表的长度。

• 查找第k个元素。

实验一 线性表的操作及应用

实验一 线性表的操作及应用
while(p&&j<i)
{
p=p->next;
++j;
}
if ( !p||j>i )
{
printf("参数 i 错或单链表不存在");
return (NULL);
} /*第i个结点不存在*/
return (p);
}
int Insert_LinkList( LinkList H, int i, DataType x)
scanf("%d%d",&n,&m);
for(j=0;j<n;j++)
{
printf("请输入要插入的第%d个元素:",j+1);
scanf("%d",&x);
y=Insert_LinkList( L,m,x);
if(y==1)
{
y=0;
printf("成功插入第%d个元素。\n",j+1);
}
}
代码:
#include <stdio.h>
#include <malloc.h>
typedef int DataType;
typedef struct node{
DataType data; /*每个元素数据信息*/
struct node *next; /*存放后继元素的地址*/
} LNode, *LinkList;
y=0;
/*(将单链表逆置,并输出逆置后单链表中的元素)*/
InvertList(L);
y=Print_LinkList(L);

实验1线性表及其应用

实验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(内容包括顺序表的结构定义及基本操作实现)。

(完整版)数据结构线性表的应用实验报告

(完整版)数据结构线性表的应用实验报告

实验报告课程名称____数据结构上机实验__________ 实验项目______线性表的应用 ____________实验仪器________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。

“线性表及其应用”实验报告

“线性表及其应用”实验报告

序号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)线性表及其应用

数据结构实验(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.熟悉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 进入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);}七、实验总结通过实验,了解并掌握了线性表逻辑特性和物理特性,了解并掌握了队列和栈的运算方法,培养了结合理论知识进行实际应用的实践能力,受益匪浅。

实验一 线性表的基本操作实现及其应用

实验一 线性表的基本操作实现及其应用

实验一线性表的基本操作实现及其应用一、实验目的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 //结点结构{int number; /* 人的序号*/int cipher; /* 密码*/struct node *next; /* 指向下一个节点的指针*/};三、实验步骤(一)数据结构与核心算法的设计描述1、单链表的结点类型定义/* 预处理命令 */#define OK 1;#define ERROR 0;#define OVERFLOW -1;/* 定义DataType,status为int类型 */typedef int DataType;typedef int status;/* 单链表的结点类型 */typedef struct LNode{DataType data;struct LNode *next;}LNode,*LinkedList;2、初始化单链表LinkedList LinkedListInit(){ //定义并返回头结点L}3、清空单链表void LinkedListClear(LinkedList L){// L是带头结点的链表的头指针,释放除头结点外的所有内存空间}4.检查单链表是否为空int LinkedListEmpty(LinkedList L){//L是带头结点的链表的头指针,判断头结点的next是否为空,如果空//返回OK,否则返回ERROR}5、遍历单链表void LinkedListTraverse(LinkedList L){// L是带头结点的链表的头指针,遍历并输出L所有结点(不包括头//结点)的数据}6、求单链表的长度int LinkedListLength(LinkedList L){//L是带头结点的链表的头指针,通过遍历链表用i记录结点个数(不//包括头结点),并返回i}7、从单链表表中查找元素LinkedList LinkedListGet(LinkedList L,int i){//L是带头结点的链表的头指针,返回第 i 个元素}8、从单链表表中查找与给定元素值相同的元素在链表中的位置(位置)int LinkedListGet1(LinkedList L,DataType x){//L是带头结点的链表的头指针,返回值为x元素在链表中的位置的//位置9、从单链表表中查找与给定元素值相同的元素在链表中的位置(指针)LinkedList LinkedListLocate(LinkedList L, DataType x){//L是带头结点的链表的头指针,返回值为x元素的指针}10、向单链表中插入元素status LinkedListInsert(LinkedList L,int i,DataType x){}(二)函数调用及主函数设计图1.主函数流程图(三)程序调试及运行结果分析1.进入选择界面后,先选择7,进行插入:2.选择4,进行遍历,结果为:3.选择2,得出当前链表长度.4.选择3,得出当前链表为.5.选择分别选择5、6进行测试.6.选择8,分别按位置和元素值删除.7.选择9,或非1-8的字符,程序结束.(四)实验总结通过这次实验,我对线性链表有了更深的理解,深入明白了线性存储结构与链式存储结构在内存存储的不同特点,同时我还学会了用这些知识实际解决一些问题,能够更加熟练地将算法转化为实际程序。

数据结构实验一 线性表的应用(班级通讯录代码及测试界面)

数据结构实验一  线性表的应用(班级通讯录代码及测试界面)

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(); }

实验一 线性表及其应用

实验一   线性表及其应用

华北水利水电大学数据结构实验报告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);}运行结果:四、小结经过这次实验,我对顺序表以及链表的相关操作的编译代码的应用有了更进一步的熟悉与应用,这次的实验让我意识到了,再编程这一方面:不管你多么清楚原理,那终究是纸上谈兵,没有经过实际的操作,你永远也不知道编程里需要注意的事项,尤其是一些细节问题。

实验一线性表操作实验报告

实验一线性表操作实验报告

实验一_线性表操作_实验报告实验一:线性表操作一、实验目的1.理解线性表的基本概念和特点。

2.掌握线性表的基本操作,包括插入、删除、查找等。

3.通过实验,提高动手能力和解决问题的能力。

二、实验原理线性表是一种较为常见的数据结构,它包含零个或多个数据元素,相邻元素之间有前后关系。

线性表具有以下特点:1.元素之间一对一的顺序关系。

2.除第一个元素外,每个元素都有一个直接前驱。

3.除最后一个元素外,每个元素都有一个直接后继。

常见的线性表有数组、链表等。

本实验主要针对链表进行操作。

三、实验步骤1.创建链表:首先创建一个链表,并给链表添加若干个节点。

节点包括数据域和指针域,数据域存储数据,指针域指向下一个节点。

2.插入节点:在链表中插入一个新的节点,可以选择在链表的头部、尾部或中间插入。

3.删除节点:删除链表中的一个指定节点。

4.查找节点:在链表中查找一个指定数据的节点,并返回该节点的位置。

5.遍历链表:从头节点开始,依次访问每个节点的数据。

四、实验结果与分析1.创建链表结果:我们成功地创建了一个链表,每个节点都有数据域和指针域,数据域存储数据,指针域指向下一个节点。

2.插入节点结果:我们成功地在链表的头部、尾部和中间插入了新的节点。

插入操作的时间复杂度为O(1),因为我们只需要修改指针域即可。

3.删除节点结果:我们成功地删除了链表中的一个指定节点。

删除操作的时间复杂度为O(n),因为我们可能需要遍历整个链表才能找到要删除的节点。

4.查找节点结果:我们成功地在链表中查找了一个指定数据的节点,并返回了该节点的位置。

查找操作的时间复杂度为O(n),因为我们可能需要遍历整个链表才能找到要查找的节点。

5.遍历链表结果:我们成功地遍历了整个链表,并访问了每个节点的数据。

遍历操作的时间复杂度为O(n),因为我们可能需要遍历整个链表。

通过本次实验,我们更加深入地理解了线性表的基本概念和特点,掌握了线性表的基本操作,包括插入、删除、查找等。

一线性表实现与应用

一线性表实现与应用

实验一线性表实现与应用一、实验目的1.掌握线性表的顺序存储和链接存储结构。

2.了解线性表的应用。

3.分析顺序线性表与链接线性表的差异。

二、实验内容1.利用顺序线性表实现集合运算AUB。

2.利用向前链表实现集合运算(A-B)U(B-A)。

三、实验程序说明1.假设集合A和B的元素都是整数,并利用两个线性表la和lb分别存放集合A和B的成员。

现依次取出lb中的每个元素,按其值查找线性表la,若la中不存在该元素,则将它插入到la中去,最后线性表la就存放了集合AUB的元素。

2.(A-B)U(B-A)是由属于集合A或集合B,但又不同时属于A和B的全部元素组成。

我们可以先分别建立由集合A和集合B的元素构成的链表la和lb,然后对lb中每一个元素进行如下处理:在链表la中查找是否有相同元素,若有相同元素,则从la 中删除该元素;若没有相同元素,则将此元素插入la中。

最后,链表la就存放了(A-B)U(B-A)的全部元素。

四、参考程序1./* 求集合运算AUB */#define MAX 100typedef struct{char element[MAX];int num;} LIST;void create(LIST *list){int i,n;printf("Enter the number of list:");scanf("%d",&n);for(i=0;i<n;i++){printf("Enter element[%d]:",i+1);scanf("%d",&(list->element[i]));}list->num=n;}int insert(LIST *list, int m, int x){int i,n;n=list->num;if(n >= MAX){printf("The list is overflow! \n");return(-1);}else if(m < 1 || m > n+1){printf("Error! \n");return(-2);}else{for(i=n-1; i>=m-1; i--)list->element[i+1]=list->element[i];list->element[m-1]=x;list->num=n+1;return(0);}}int locate(LIST *list, int x){int i;for(i=0; i<=list->num-1; i++)if(list->element[i] == x)return(i+1);return(0);}void print_list(LIST *list){int i,n;n=list->num;if(n == 0)printf("The list is empty.\n");else{for(i=0; i<=n-1; i++)printf("%d\t",list->element[i]);printf("\n");}}main(){LIST *la,*lb;int i,x;create(la);printf("SET A:\n");print_list(la);create(lb);printf("SET B:\n");print_list(lb);for(i=0;i<lb->num;i++){x=lb->element[i];if(locate(la,x) == 0)insert(la,la->num+1,x);}printf("SET (AUB):\n");print_list(la);}2./* 集合运算(A-B)U(B-A)*/#include <stdio.h>typedef struct node{char info;struct node *link;} NODE;NODE *initial(),*process();main(){NODE *la,*lb,*ptr,*p1,*p2;printf("\nEnter the elements of Set A:");la=initial();printf("Set A:\n");travel(la);printf("\nEnter the elements of Set B:");lb=initial();printf("Set B:\n");travel(lb);la=process(la,lb);printf("\nSet (A-B)U(B-A):\n");travel(la);}NODE *initial(){NODE *head,*p1,*p2;char ch;head=(NODE *)malloc(sizeof(NODE));head->link=NULL;p1=head;while((ch=getchar()) != '\n'){p2=(NODE *)malloc(sizeof(NODE));p2->info=ch;p2->link=NULL;p1->link=p2;p1=p2;}return(head);}travel(NODE *ptr){ptr=ptr->link;while(ptr != NULL){printf("%c ",ptr->info);ptr=ptr->link;}printf("\n");}NODE *process(NODE *la,NODE *lb){NODE *ptr,*p1,*p2;int found=0;ptr=lb->link;while(ptr != NULL){p1=la->link;p2=la;while(p1 != NULL && ! found)if(p1->info == ptr->info)found=1;else{p2=p1;p1=p1->link;}if(found){p2->link=p1->link;free(p1);found=0;}else{p1=(NODE *)malloc(sizeof(NODE)); p1->info=ptr->info;p1->link=NULL;p2->link=p1;}ptr=ptr->link;}return(la);}/* 集合运算(A-B)U(B-A)*/#include <stdio.h>typedef struct node{char info;struct node *link;} NODE;NODE *initial(),*process();main(){NODE *la,*lb,*ptr,*p1,*p2;printf("\nEnter the elements of Set A:");la=initial();printf("Set A:\n");travel(la);printf("\nEnter the elements of Set B:");lb=initial();printf("Set B:\n");travel(lb);la=process(la,lb);printf("\nSet (A-B)U(B-A):\n");travel(la);}NODE *initial(){NODE *head,*p1,*p2;char ch;head=(NODE *)malloc(sizeof(NODE));head->link=NULL;p1=head;while((ch=getchar()) != '\n'){p2=(NODE *)malloc(sizeof(NODE));p2->info=ch;p2->link=NULL;p1->link=p2;p1=p2;}return(head);}travel(NODE *ptr){ptr=ptr->link;while(ptr != NULL){printf("%c ",ptr->info);ptr=ptr->link;}printf("\n");}NODE *process(NODE *la,NODE *lb){NODE *ptr,*p1,*p2;int found=0;ptr=lb->link;while(ptr != NULL){p1=la->link;p2=la;while(p1 != NULL && ! found)if(p1->info == ptr->info)found=1;else{p2=p1;p1=p1->link;}if(found){p2->link=p1->link;free(p1);found=0;}else{p1=(NODE *)malloc(sizeof(NODE));p1->info=ptr->info;p1->link=NULL;p2->link=p1;}ptr=ptr->link;}return(la);}五、实验步骤1.参考实验程序上机调试。

数据结构 实验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;

实验一__线性表及其应用[1]pp

实验一__线性表及其应用[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、掌握用上机调试线性表的基本方法;
2、掌握线性表的基本操作,插入、删除、查找,以及线性表在顺序存储结构上的
应用。

3、按要求完成实验报告
二、实验环境
硬件:PC 微型计算机、256M以上内存,40G以上硬盘。

软件:Windows XP,VC或
三、实验内容
定义一个可以存放学生元素的有序顺序表。

学生元素中包含两个数据项:姓名,成绩。

注意顺序表以学生成绩有序存放。

要求完成一个程序,能添加、删除学生元素,并显示顺序表中所有元素。

四、实验步骤
1、编写程序,定义学生类Student,记录两个数据项:姓名,成绩。

并提供构造函数。

2、
在此基础上添加三个学生,一个分数为45,一个分数为88,一个分数为75。

检查学生添加后顺学表中的学生信息是否还以成绩为序非递减排列。

实验代码:
头文件函数:
c1.h
c2.h
功能函数:
Basic_Operation.cpp
主函数:
插入:
合并并按非递减排序:
删除:。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

姓名学号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;。

相关文档
最新文档