实验1线性表及其应用
实验1线性表及其应用实验报告
![实验1线性表及其应用实验报告](https://img.taocdn.com/s3/m/830102fcafaad1f34693daef5ef7ba0d4a736db5.png)
实验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。
实验一 线性表的基本操作实现及其应用
![实验一 线性表的基本操作实现及其应用](https://img.taocdn.com/s3/m/3a06c391bb4cf7ec4afed08e.png)
实验一线性表的基本操作实现及其应用一、实验目的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的人,就要在该数组的相应位置做一个删除标记,该单元以后就不再作为计数单元。
实验一 线性表及其应用(I)
![实验一 线性表及其应用(I)](https://img.taocdn.com/s3/m/5f613ff66137ee06eff9189b.png)
姓名学号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运行结果实验结果分析:从以上实验运行结果来说,程序可以实现实验要求的基本内容,至于数据输入等操作步骤从上图可以简单、明了的看出。
实验一 线性表的应用
![实验一 线性表的应用](https://img.taocdn.com/s3/m/4801e8e51ed9ad51f01df2be.png)
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个数,元素间的顺序没有意义。
实验一 线性表的操作及应用
![实验一 线性表的操作及应用](https://img.taocdn.com/s3/m/63cdf1727e21af45b307a8a0.png)
{
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);
《数据结构》实验一 线性表及其应用
![《数据结构》实验一 线性表及其应用](https://img.taocdn.com/s3/m/783a55122cc58bd63086bd2e.png)
实验一线性表及其应用一、实验目的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;注意结点的建立方法及构造新结点时指针的变化。
数据结构实验一:线性表的应用
![数据结构实验一:线性表的应用](https://img.taocdn.com/s3/m/7dcd8ddb50e2524de5187ed1.png)
数据结构实验报告实验一线性表的应用一、实验目的: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)线性表及其应用](https://img.taocdn.com/s3/m/e2588c63d5bbfd0a7856733b.png)
计算机系数据结构实验报告(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函数来不断改进。
实验一 线性表的建立与应用
![实验一 线性表的建立与应用](https://img.taocdn.com/s3/m/87a495d233d4b14e85246829.png)
实验一线性表的建立与应用一实验目的:通过实验,了解并掌握线性表逻辑特性和物理特性,了解并掌握队列和栈的运算方法,培养结合理论知识进行实际应用的实践能力。
二实验内容:队列示意图队列也是一种运算受限制的线性表,它的运算包括:初始化队、入队、退队、读取队首和队尾的数据。
当队列为空时不允许退队,当队列未满的时候不允许入队。
在实际应用中,通常使用循环队列循环队列示意图初始化循环队列四、实验步骤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);}七、实验总结通过实验,了解并掌握了线性表逻辑特性和物理特性,了解并掌握了队列和栈的运算方法,培养了结合理论知识进行实际应用的实践能力,受益匪浅。
数据结构实验一 线性表的应用(班级通讯录代码及测试界面)
![数据结构实验一 线性表的应用(班级通讯录代码及测试界面)](https://img.taocdn.com/s3/m/203e8f35bcd126fff7050bcd.png)
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(); }
实验一 线性表及其应用
![实验一 线性表及其应用](https://img.taocdn.com/s3/m/d8fd99de050876323112125e.png)
华北水利水电大学数据结构实验报告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);}运行结果:四、小结经过这次实验,我对顺序表以及链表的相关操作的编译代码的应用有了更进一步的熟悉与应用,这次的实验让我意识到了,再编程这一方面:不管你多么清楚原理,那终究是纸上谈兵,没有经过实际的操作,你永远也不知道编程里需要注意的事项,尤其是一些细节问题。
实验一线性表操作实验报告
![实验一线性表操作实验报告](https://img.taocdn.com/s3/m/2cf90cbc05a1b0717fd5360cba1aa81144318f09.png)
实验一_线性表操作_实验报告实验一:线性表操作一、实验目的1.理解线性表的基本概念和特点。
2.掌握线性表的基本操作,包括插入、删除、查找等。
3.通过实验,提高动手能力和解决问题的能力。
二、实验原理线性表是一种较为常见的数据结构,它包含零个或多个数据元素,相邻元素之间有前后关系。
线性表具有以下特点:1.元素之间一对一的顺序关系。
2.除第一个元素外,每个元素都有一个直接前驱。
3.除最后一个元素外,每个元素都有一个直接后继。
常见的线性表有数组、链表等。
本实验主要针对链表进行操作。
三、实验步骤1.创建链表:首先创建一个链表,并给链表添加若干个节点。
节点包括数据域和指针域,数据域存储数据,指针域指向下一个节点。
2.插入节点:在链表中插入一个新的节点,可以选择在链表的头部、尾部或中间插入。
3.删除节点:删除链表中的一个指定节点。
4.查找节点:在链表中查找一个指定数据的节点,并返回该节点的位置。
5.遍历链表:从头节点开始,依次访问每个节点的数据。
四、实验结果与分析1.创建链表结果:我们成功地创建了一个链表,每个节点都有数据域和指针域,数据域存储数据,指针域指向下一个节点。
2.插入节点结果:我们成功地在链表的头部、尾部和中间插入了新的节点。
插入操作的时间复杂度为O(1),因为我们只需要修改指针域即可。
3.删除节点结果:我们成功地删除了链表中的一个指定节点。
删除操作的时间复杂度为O(n),因为我们可能需要遍历整个链表才能找到要删除的节点。
4.查找节点结果:我们成功地在链表中查找了一个指定数据的节点,并返回了该节点的位置。
查找操作的时间复杂度为O(n),因为我们可能需要遍历整个链表才能找到要查找的节点。
5.遍历链表结果:我们成功地遍历了整个链表,并访问了每个节点的数据。
遍历操作的时间复杂度为O(n),因为我们可能需要遍历整个链表。
通过本次实验,我们更加深入地理解了线性表的基本概念和特点,掌握了线性表的基本操作,包括插入、删除、查找等。
实验一线性表地基本操作实现及其应用
![实验一线性表地基本操作实现及其应用](https://img.taocdn.com/s3/m/4da33b3516fc700abb68fcd4.png)
实验一线性表的基本操作实现及其应用一、实验目的1、熟练掌握线性表的基本操作在两种存储结构上的实现。
2、会用线性链表解决简单的实际问题。
二、实验内容题目一链表基本操作该程序的功能是实现单链表的定义和操作。
该程序包括单链表结构类型以及对单链表操作的具体的函数定义和主函数。
其中,程序中的单链表(带头结点)结点为结构类型,结点值为整型。
单链表操作的选择以菜单形式出现,如下所示:please input the operation:1.初始化2.清空3.求链表长度4.检查链表是否为空5.检查链表是否为满6.遍历链表(设为输出元素)7.从链表中查找元素8.从链表中查找与给定元素值相同的元素在表中的位置9.向链表中插入元素 10. 从链表中删除元素其他键退出。
实验一线性表的基本操作实现及其应用一、实验目的1、熟练掌握线性表的基本操作在两种存储结构上的实现。
2、会用线性链表解决简单的实际问题。
二、实验内容题目一链表基本操作该程序的功能是实现单链表的定义和操作。
该程序包括单链表结构类型以及对单链表操作的具体的函数定义和主函数。
其中,程序中的单链表(带头结点)结点为结构类型,结点值为整型。
单链表操作的选择以菜单形式出现,如下所示:please input the operation:1.初始化2.清空3.求链表长度4.检查链表是否为空5.检查链表是否为满6.遍历链表(设为输出元素)7.从链表中查找元素8.从链表中查找与给定元素值相同的元素在表中的位置9.向链表中插入元素 10. 从链表中删除元素其他键退出。
题目一链表基本操作一、数据结构与核心算法的设计描述1、单链表的最大长度#define MAXSIZE 1002、单链表的结点类型定义/* 定义elemtype为int类型 */typedef int elemtype;/* 单链表的结点类型 */typedef struct STD{elemtype elem;STD *next;}list, * linklist;3、初始化单链表/* 函数功能:对链表进行初始化参数:链表(linklist L)成功初始化返回1,否则返回0 */ int init(linklist &L){L=(linklist)malloc(sizeof(list));//头结点申请内存。
第一次实验 线性表的实现及其应用
![第一次实验 线性表的实现及其应用](https://img.taocdn.com/s3/m/c3a729c9ce2f0066f53322b3.png)
typedef Struct
{ DataType data[MAXNUM];
int
last; //存放线性表中最后一个元素在数组data[ ]中的下标 注意:顺序表的类型定义 可存储在seqlist.h中。
} SeqList;
二、关键技术分析
2.顺序表的空间申请
在教材第6页中的“臵空表”的程序有错, 缺少了申请存储空间的语句,故完整程 序应该为:
Void SeqLSetNull(SeqList *l) { l=(SeqList*) malloc(sizeof(SeqList)); l->last= -1; }
注意:教材第6页至第8页中的算法 ①~⑧给出了线性表在顺序表存储 结构下的所有基本操作的实现算法, 可存储在seqlist.cpp中。
数据结构实验(C语言版)
第一次实验 线性表的实现及其应用
一、实验内容
1.用C语言实现线性表的存储结构 (顺序表或链表,任选其中之一); 2.实现线性表所有基本操作的有关 算法; 3.利用线性表解决某一实际问题(实 现学生成绩管理系统;实现集合的 交运算和并运算)。
二、关键技术分析
1.顺序表的类型定义
二、关键技术分析
6.实现学生成绩管理系统
用一个带头结点的杂,导致对单链 表的输入、删除、插入等操作较为复杂,不能直接使 用教材2.1节中实现的单链表来表示线性表。必须重 新设计线性表的结点node(类型名为LinkList,教材第 19页),并针对该线性表设计所需的全部操作(如建 立、插入、删除、输出及主函数模块)的算法。
二、关键技术分析
6.实现学生成绩管理系统
数据结构 实验1 线性表应用
![数据结构 实验1 线性表应用](https://img.taocdn.com/s3/m/45b8a0c14b73f242326c5fab.png)
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](https://img.taocdn.com/s3/m/11f06f01eff9aef8941e06cb.png)
集美大学数据结构课程实验报告课程名称:数据结构班级:实验成绩:指导教师:吴晓晖姓名:实验项目名称:实验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,给项目名四、实验关键代码与结果展示(部分截图)查找测试:五、附录(代码)。
线性表及其应用实验
![线性表及其应用实验](https://img.taocdn.com/s3/m/2fe55be5d5bbfd0a7956734f.png)
数据结构实验
实验一线性表及其应用
一、实验目的
1、掌握用上机调试线性表的基本方法;
2、掌握线性表的基本操作,插入、删除、查找,以及线性表在顺序存储结构上的
应用。
3、按要求完成实验报告
二、实验环境
硬件:PC 微型计算机、256M以上内存,40G以上硬盘。
软件:Windows XP,VC或
三、实验内容
定义一个可以存放学生元素的有序顺序表。
学生元素中包含两个数据项:姓名,成绩。
注意顺序表以学生成绩有序存放。
要求完成一个程序,能添加、删除学生元素,并显示顺序表中所有元素。
四、实验步骤
1、编写程序,定义学生类Student,记录两个数据项:姓名,成绩。
并提供构造函数。
2、
在此基础上添加三个学生,一个分数为45,一个分数为88,一个分数为75。
检查学生添加后顺学表中的学生信息是否还以成绩为序非递减排列。
实验代码:
头文件函数:
c1.h
c2.h
功能函数:
Basic_Operation.cpp
主函数:
插入:
合并并按非递减排序:
删除:。
(完整版)数据结构线性表的应用实验报告
![(完整版)数据结构线性表的应用实验报告](https://img.taocdn.com/s3/m/6fbe509102020740bf1e9b29.png)
实验报告课程名称____数据结构上机实验__________ 实验项目______线性表的应用 ____________实验仪器________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。
数据结构实验一 线性表的操作与应用
![数据结构实验一 线性表的操作与应用](https://img.taocdn.com/s3/m/c7cc26ecaef8941ea76e05da.png)
长春大学计算机学院网络工程专业数据结构实验报告实验名称:实验一线性表的操作与应用班级:网络四班姓名:刘虹秀学号:041440406实验地点:教室日期:2015-3-27一、实验目的:1.掌握线性表的两类存储结构(顺序存储结构和链式存储结构)的描述方法。
2.掌握在顺序结构中实现查找、插入、删除操作的基本方法。
3.掌握在各种链表结构中实现查找、插入、删除操作的基本方法。
二、实验内容、要求和环境:注:将完成的实验报告重命名为:班级+学号+姓名+(实验一),(如:041340538张三(实验一)),发邮件到:ccujsjzl@。
提交时限:本次实验后24小时之内。
阅读程序,完成填空,并上机运行调试。
1、线性表的顺序存储结构的定义及其基本操作。
建立顺序表,完成顺序表的基本操作:初始化、插入、删除、输出、销毁, 置空表、求表长、查找元素、判线性表是否为空。
(1) 文件1:pubuse. h 是公共使用的常量定义和系统函数调用声明。
#include<string. h>#include<ctype. h>#include<malloc. h> /* malloc()等*/#include<limits. h> /* INT_MAX 等*/#include<stdio. h> /* EOF(=^Z 或F6),NULL */#include<stdlib. h> /* atoi() */#include<io. h> /* eof() */#include<math. h> /* floor(),ceil(),abs() */#include<process. h> /* exit() *//* 函数结果状态代码*/#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1typedef int Status; /* Status 是函数的类型,其值是函数结果状态代码,如OK 等*/typedef int Boolean; /* Boolean 是布尔类型,其值是TRUE 或FALSE */(2) 文件2:seqlistDef. h 进行线性表的动态分配顺序存储结构的表示#define LIST_INIT_SIZE 10 /* 线性表存储空间的初始分配量*/#define LISTINCREMENT 2 /* 线性表存储空间的分配增量*/typedef struct{Elem Type *elem; /* 存储空间基址*/int length; /* 当前长度*/int listsize; /* 当前分配的存储容量) */}SqList;(3)文件3:seqlistAlgo. h 进行线性表顺序存储结构的基本实验算法定义Status ListInit_Sq(SqList &L){ /* 操作结果:构造一个空的顺序线性表*/L. elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!L. elem)exit(OVERFLOW); /* 存储分配失败*/L. length=0; /* 空表长度为0 */L. listsize=LIST_INIT_SIZE; /* 初始存储容量*/return OK;}Status ListInsert_Sq(SqList &L,int i,ElemType e){ /* 初始条件:顺序线性表L 已存在,1≤i≤ListLength(L)+1 *//* 操作结果:在L 中第i 个位置之前插入新的数据元素e,L 的长度加1 */ ElemType *newbase,*q,*p;if(i<1||i>L. length+1) /* i 值不合法*/return ERROR;if(L. length>=L. listsize) /* 当前存储空间已满,增加分配*/{newbase=(ElemType *)realloc(L. elem,(L.istsize+LISTINCREMENT)*sizeof(ElemType));if(!newbase)exit(OVERFLOW); /* 存储分配失败*/L. elem=newbase; /* 新基址*/L. listsize+=LISTINCREMENT; /* 增加存储容量*/}q=L.elem+i-1; ; /* q 为插入位置*/for(p=L. elem+L. length-1;p>=q;--p) /* 插入位置及之后的元素右移*/*(p+1)=*p;*q=e; ; /* 插入e */++L.length ; /* 表长增1 */return OK;}Status ListDelete_Sq(SqList &L,int i,ElemType *e){ /* 初始条件:顺序线性表L 已存在,1≤i≤ListLength(L) *//* 操作结果:删除L 的第i 个数据元素,并用e 返回其值,L 的长度减1 */ElemType *p,*q;if(i<1||i>L. length) /* i 值不合法*/return ERROR;p=L.elem+i-1 ; /* p 为被删除元素的位置*/*e=*p; /* 被删除元素的值赋给e */q=L. elem+L. length-1; /* 表尾元素的位置*/for(++p;p<=q;++p) /* 被删除元素之后的元素左移*/*(p-1)=*p; ;L.length--; ; /* 表长减1 */return OK;}Status ListPrint_Sq(SqList L){ /* 初始条件:顺序线性表L 已存在*//* 操作结果:依次对L 的数据元素输出*/int i;printf("\n");for(i=0;i<L. length;i++)printf("%d ", L. elem[i]);return OK;}/* 还有一些算法,同学们自己补充完整*/(4)文件4:seqlistUse. cpp 进行线性表顺序存储结构的基本算法验证。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验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 -2
typedef int Status;
(2)头文件SqList.h(内容包括顺序表的结构定义及基本操作实现)。
(3)头文件LinkList.h(内容包括链表的结构定义及基本操作实现)。
(4)顺序表中基本操作的补充:
● CreateList(&L):向顺序表L中输入n个元素(0≤n≤MAXSIZE)。
Status CreateList(SqList &L,int n)
{
int i;
if(!L.elem||n<0||n>MAXSIZE) return ERROR;
cout<<"\n请输入"<<n<<"个元素:";
for(i=1;i<=n;i++)
cin>>L.elem[i-1]; //可以用随机函数rand()自动生成
L.length=n;
return OK;
}
● ListTraverse(L):以线性表的记录形式遍历输出顺序表L,例如:(a1,a2,…,
ai,…an)。
void ListTraverse(SqList L)
{
int i;
cout<<'(';
for(i=1;i<=L.length;i++)
cout<<L.elem[i-1]<<',';
if(L.length) cout<<"\b)"<<endl;
else cout<<')'<<endl;
}
2.设计实现一个算法,用以对两个非递减有序表A、B进行合并,其中A=(2,5,8,9) ,B=(3,4,8,10,12,20)。
3.(任选题)已知有两个多项式P(x)和Q(x),基于链表设计算法实现P(x)+Q(x)运算,而且不重新开辟存储空间。