线性表的链式存储实验
实验二 链式存储线性表
实验二 链式存储线性表的基本操作一、 实验目的1. 掌握用Turbo C2.0上机调试线性表的基本方法。
2. 掌握线性表的基本操作,插入、删除、查找,以及线性表合并等运算在链接存储结构上的运算。
二、 实验内容1.typedef int ElemType;typedef struct LNode { //创建结构体数据类型LNodeElemType data; //存放数值的数据域struct LNode *next; //存放后继结点地址的指针域}LNode;2. 链表的创建:创建n 个结点,利用scanf( )函数为每个结点的数据域赋值,一次将每个结点插入链表,形成一个包含n 个元素的链表。
#define NULL 0#define OVERFLOW 0#define OK 1#define ERROR -1typedef int ElemType;typedef struct LNode { //创建LNode 数据类型ElemType data;struct LNode *next;}LNode;typedef LNode *LinkList; //定义LinkList 指针型数据类型int CreateList_L(LinkList L, int n) { //创建拥有n 个元素的线性链表//int i;struct LNode *p;L->next = NULL; //线性链表初始化,见右图for (i = n; i > 0; --i) { //循环n 次在头结点和第一个结点间插入新结点,形成长度为n 的线性链表p =(LNode*)malloc(sizeof(LNode));scanf("%d",&p->data);p->next = L ->next;L->next =p;}return 1;}data next data nextl1)2)3)int VistList_L(LinkList L) { //遍历链表L中每个结点的函数struct LNode *p;p = L->next;while (p) {printf("%d ",p->data); //访问输出p结点的数据域p = p->next; } //p指针前进一位,指向后继结点printf("\n");return OK;}}lmain(){int m;LNode l;ElemType e;printf("please input the length of the linklist that you want to build");scanf("%d",&m);printf("please give the number that you want to insert");CreateList_L(&l,m); //调用创建链表函数VistList_L(&l); //调用遍历链表结点函数}3. 链表的插入算法:向链表中某个位置上插入一个结点#define NULL 0#define OVERFLOW 0#define OK 1#define ERROR -1typedef int ElemType;typedef struct LNode { //创建LNode 数据类型ElemType data;struct LNode *next;}LNode;typedef LNode *LinkList;int CreateList_L(LinkList L, int n) { //创建包含n 个元素的链表int i;struct LNode *p;L->next = NULL;for (i = n; i > 0; --i) {p =(LNode*)malloc(sizeof(LNode));scanf("%d",&p->data);p->next = L ->next;L->next =p;}return 1;}int ListInsert_L(LinkList L, int i, ElemType e) { //向链表中第i位插入数据e struct LNode *s,*p;int j;p = ; j = 0; //p指针指向线性链表的头结点while (p && j < ) //循环查找第i-1位作为数据e的插入位置{ p = ; ++j; } //p指针向前移动if (!p || j > i-1)return ERROR;s =(LNode*)malloc(sizeof(LNode)); //见下图1)if ( s == NULL) return ERROR;s-> = e; //将插入数据e的值赋值给s结点的数据域1)s->next = ; p->next = ; //旧链断开,新链产生2)3)return OK;}1)2)3)int VistList_L(LinkList L) { //遍历链表所有结点的函数struct LNode *p;p = L->next;while (p) {printf("%d",p->data);p = p->next; }return OK;}main(){int m;LNode l;ElemType e;int i;printf("please input the length of the linklist that you want to build");scanf("%d",&m);printf("please give the number that the initial list have");CreateList_L(&l,m);VistList_L(&l);printf("please input the positon and data of the insert number i&e");scanf("%d,%d",&i,&e);ListInsert_L(&l,i,e);VistList_L(&l);}附:一元多项式的相加#include<stdio.h>#include<stdlib.h>#define LEN sizeof(node)typedef struct polynode /*用单链表存储多项式的结点结构*/{int coef; /*多项式的系数*/int exp; /*指数*/struct polynode *next; /*next是struct polynode类型中的一个成员,它又指向struct polynode类型的数据,以此建立链表*/}node;/*若定为"node,*list;",意即node*与list同为结构指针类型*/node * create(void) /*指针函数,返回指针类型;用尾插法建立一元多项式的链表的函数*/ {node *h,*r,*s;int c,e;h=(node *)malloc(LEN); /*建立多项式的头结点,为头结点分配存储空间*/r=h; /*r指针始终动态指向链表的当前表尾,以便于做尾插入,其初值指向头结点*/ printf("coef:");scanf("%d",&c); /*输入系数*/printf("exp: ");scanf("%d",&e); /*输入指针*/while(c!=0) /*输入系数为0时,表示多项式的输入结束*/{s=(node *)malloc(LEN); /*申请新结点*/s->coef=c; /*申请新结点后赋值*/s->exp=e; /*申请新结点后赋值*/r->next=s; /*做尾插,插入新结点*/r=s; /*r始终指向单链表的表尾*/printf("coef:");scanf("%d",&c);printf("exp: ");scanf("%d",&e);}r->next=NULL; /*将表的最后一个结点的next置NULL,以示表结束*/return(h);}void polyadd(node *polya, node *polyb)/*一元多项式相加函数,用于将两个多项式相加,然后将和多项式存放在多项式polya中,并将多项式ployb删除*/{node *p,*q,*pre,*temp;int sum;p=polya->next;/*令p和q分别指向polya和polyb多项式链表中的第一个结点*/q=polyb->next;pre=polya; /*位置指针,指向和多项式polya*/while(p!=NULL&&q!=NULL) /*当两个多项式均未扫描结束时,执行以下操作*/{if(p->exp<q->exp) /*若p指向的多项式指数小于q指的指数*/{pre->next=p; /*将p结点加入到和多项式中*/pre=pre->next;p=p->next;}else if(p->exp==q->exp) /*若指数相等,则相应的系数相加*/{sum=p->coef+q->coef;if(sum!=0){p->coef=sum;pre->next=p;pre=pre->next;p=p->next;temp=q;q=q->next;free(temp);}else /*如果系数和为零,则删除结点p与q,并将指针指向下一个结点*/{temp=p->next;free(p);p=temp;temp=q->next;free(q);q=temp;}}else /*若p指数大于q指数*/{pre->next=q; /*p结点不动,将q结点加入到和多项式中*/pre=pre->next;q=q->next;}}if(p!=NULL) /*多项式A中还有剩余,则将剩余的结点加入到和多项式中*/ pre->next=p;else /*否则将B的结点加入到和多项式中*/pre->next=q;}void print(node * p) /*输出函数,打印出一元多项式*/{while(p->next!=NULL){p=p->next;printf(" %d*x^%d",p->coef,p->exp);}}main() /*主函数*/{node * polya,* polyb;printf("Welcome to use!\n");printf("\nPlease input the ploya include coef && exp:\n");polya=create(); /*调用建立链表函数,创建多项式A*/print(polya);printf("\nPlease input the ployb include coef && exp:\n");polyb=create(); /*同理,创建B*/print(polyb);printf("\nSum of the poly is:\n");polyadd(polya,polyb); /*调用一元多项式相加函数*/print(polya); /*调用输出函数,打印结果*/printf("\n");}。
线性表的链式存储结构实验报告
实验报告课程名称:数据结构与算法分析实验名称:链表的实现与应用实验日期:班级:数媒1401 姓名:范业嘉学号一、实验目的掌握线性表的链式存储结构设计与基本操作的实现。
二、实验内容与要求⑴定义线性表的链式存储表示;⑵基于所设计的存储结构实现线性表的基本操作;⑶编写一个主程序对所实现的线性表进行测试;⑷线性表的应用:①设线性表L1和L2分别代表集合A和B,试设计算法求A和B的并集C,并用线性表L3代表集合C;②(选做)设线性表L1和L2中的数据元素为整数,且均已按值非递减有序排列,试设计算法对L1和L2进行合并,用线性表L3保存合并结果,要求L3中的数据元素也按值非递减有序排列。
⑸设计一个一元多项式计算器,要求能够:①输入并建立多项式;②输出多项式;③执行两个多项式相加;④执行两个多项式相减;⑤(选做)执行两个多项式相乘。
三、数据结构设计1.按所用指针的类型、个数、方法等的不同,又可分为:线性链表(单链表)静态链表循环链表双向链表双向循环链表2.用一组任意的存储单元存储线性表中数据元素,用指针来表示数据元素间的逻辑关系。
四、算法设计1.定义一个链表void creatlist(Linklist &L,int n){int i;Linklist p,s;L=(Linklist)malloc(sizeof(Lnode));p=L;L->next=NULL;for(i=0;i<n;i++){s=(Linklist)malloc(sizeof(Lnode));scanf("%d",&s->data);s->next=NULL;p->next=s; p=s;}}2.(1)两个链表的合并void Mergelist(Linklist &La,Linklist &Lb,Linklist &Lc) {Linklist pa,pb,pc;pa=La->next;pb=Lb->next;Lc=pc=La;while(pa&&pb){if(pa->data<=pb->data){pc->next=pa;pc=pa;pa=pa->next;}else {pc->next=pb;pc=pb;pb=pb->next;} }pc->next=pa?pa:pb;free(Lb);}(2)两个链表的并集Linklist unionlist(Linklist &La,Linklist &Lb){Linklist p1,p2,head,q,s;int flag;head=q=(Linklist)malloc(sizeof(Lnode));p1=La->next;while(p1){flag=0;p2=Lb->next;while(p2){if(p1->data==p2->data){flag=1;break;}p2=p2->next;}if(flag==0){s=(Linklist)malloc(sizeof(Lnode));s->data=p1->data;q->next=s;q=s;}p1=p1->next;}q->next=Lb->next;return head;}3.(1)一元多项式的加法List addpoly(List pa,List pb) //一元多项式的加法{int n;List pc,s,p;pa=pa->next;pb=pb->next;pc=(List)malloc(sizeof(struct Linklist));pc->next=NULL;p=pc;while(pa!=NULL&&pb!=NULL){if(pa->expn>pb->expn){s=(List)malloc(sizeof(struct Linklist));s->expn=pa->expn;s->coef=pa->coef;s->next=NULL;p->next=s;p=s;pa=pa->next;}else if(pa->expn<pb->expn){s=(List)malloc(sizeof(struct Linklist));s->expn=pb->expn;s->coef=pb->coef;s->next=NULL;p->next=s;p=s;pb=pb->next;}else{n=pa->coef+pb->coef;if(n!=0){s=(List)malloc(sizeof(struct Linklist));s->expn=pa->expn;s->coef=n;s->next=NULL;p->next=s;p=s;}pb=pb->next;pa=pa->next;}}while(pa!=NULL){s=(List)malloc(sizeof(struct Linklist));s->expn=pa->expn;s->coef=pa->coef;s->next=NULL;p->next=s;p=s;pa=pa->next;}while(pb!=NULL){s=(List)malloc(sizeof(struct Linklist));s->expn=pb->expn;s->coef=pb->coef;s->next=NULL;p->next=s;p=s;pb=pb->next;}return pc;}(2)一元多项式的减法List subpoly(List pa,List pb) //一元多项式的减法{int n;List pc,s,p;pa=pa->next;pb=pb->next;pc=(List)malloc(sizeof(struct Linklist));pc->next=NULL;p=pc;while(pa!=NULL&&pb!=NULL){if(pa->expn>pb->expn){s=(List)malloc(sizeof(struct Linklist));s->expn=pa->expn;s->coef=pa->coef;s->next=NULL;p->next=s;p=s;pa=pa->next;}else if(pa->expn<pb->expn){s=(List)malloc(sizeof(struct Linklist));s->expn=pb->expn;s->coef=-pb->coef;s->next=NULL;p->next=s;p=s;pb=pb->next;}else{n=pa->coef-pb->coef;if(n!=0){s=(List)malloc(sizeof(struct Linklist));s->expn=pa->expn;s->coef=n;s->next=NULL;p->next=s;p=s;}pb=pb->next;pa=pa->next;}}while(pa!=NULL){s=(List)malloc(sizeof(struct Linklist));s->expn=pa->expn;s->coef=pa->coef;s->next=NULL;p->next=s;p=s;pa=pa->next;}while(pb!=NULL){s=(List)malloc(sizeof(struct Linklist));s->expn=pb->expn;s->coef=-pb->coef;s->next=NULL;p->next=s;p=s;pb=pb->next;}return pc;}(3)一元多项式的乘法void mulpolyn(polynomail pa,polynomail pb,polynomail &pc) {LNode *p,*q,*s,*hc;p=pa->next;q=pb->next;hc=pc;while(p!=NULL){while(q!=NULL){s=(polynomail)malloc(sizeof(LNode));hc->next=s;hc=hc->next;hc->coef=q->coef*p->coef;hc->expn=q->expn+p->expn;q=q->next;}p=p->next;q=pb->next;}hc->next=NULL;}五、测试结果2.3.六、心得体会(包括对于本次实验的小结,实验过程中碰到的问题等)1.首先书上给的链表输入是倒序的,写的时候想都没想就抄上去了,结果运行时发现问题,可是上网百度依然没有把问题解决,导致最后输出链表倒序的,并且链表的合并并集依旧是倒序的。
数据结构实验二 线性表的链式存储及其操作 - 副本
实验二线性表的链式存储及其操作实验项目:线性表的链表实现:遍历、插入、删除、翻转实验类型: 基础性一【指导思想】用链表存储线性表,实现线性表的基本操作。
二【实验目的及要求】1、复习C语言的指针的定义、链表的使用;2、理解线性表的属性;3、实践线性表的链式实现方法以及相关的操作。
4、要求:提交实验报告,附源程序中填空的内容(10处)、打印运行结果涉及的知识点:线性表的逻辑属性、运算带表头的单链表的操作:定义、输入、输出、链表内容的翻转元素/链表的操作:元素的插入、删除三【实验内容】实现链表的输入、输出、插入、删除、翻转等功能,教师提供主要源代码,其中有10处标出需要学生填空,使得整个程序能正确运行。
问题描述:用带表头的链表存放输入的数据,每读入一个数,按升序顺序插入到链表中,链表中允许两个结点有相同值。
链表的头结点存放链表后面的结点个数,初始化时就生成头结点(初值为0)。
链表翻转是把数据逆序(变成降序),注意,头结点不动。
翻转后要再翻转一次,恢复升序后才能插入新元素,否则会出错。
实验步骤:读懂后面附带的源代码,在标注“填空”的位置填写适当的表达式或语句,使得程序完成指定功能。
测试要求:1、连续插入5个实数;要求:插入的元素要分别位于表头、表中、表尾,以确保该插入函数适合于各种情况;2、翻转链表,确认成功后再翻转一次,恢复元素的升序序列;3、删除3个数组元素,删除的元素要分别要位于表头、表中、表尾,以确保该删除函数适合于各种情况;4、删除一个不存在的元素,确认链表的内容没被改变。
//***************************************//////#include <stdio.h>#include "malloc.h"#define null 0struct node{float data;struct node *next;};void insert(float aa,struct node *vq){struct node *newnode,*p;newnode=(struct node *)malloc(sizeof(struct node));newnode->data=aa;p=vq;while ((p->next!=null)&&(p->next->data<aa))/* 填空1 */newnode->data=aa;newnode->next=p->next;/* 填空2 */p->next=newnode;vq->data=vq->data+1;}void dele(float aa,struct node *vq){struct node *p,*q;p=vq;while ((p->next!=null)&&(p->next->data<aa))/* 填空3 */p++;p=p->next;if ((p->next==null)||(p->next->data!=aa))printf("\n%5.1f is not in the link !",aa);else if (p->next->data==aa){q=p->next;p->next=q->next;/* 填空4 */free(q);/* 填空5 */vq->data=vq->data-1;}}void print(struct node *vq){struct node *p;printf("\nthe length of link is %4.0f",vq->data);p=vq->next;printf("\nthe link is:");while (p!=NULL) /* 填空6 */{printf("%5.1f",p->data);/* 填空7 */p=p->next;}}void reverse(struct node *vq){struct node *q,*p;p=vq->next;vq->next=p->next;/* 填空8 */while (p!=null){q=p;p=p->next;/* 填空9 */q->next=p->next /* 填空10 */;vq->next=q;}}main(){int mark=1,op;float aa;struct node *vq;vq=(struct node *)malloc(sizeof(struct node));vq->data=0;vq->next=null;while (mark==1){printf("\nWhich kind of operation will you select ? ");printf("\ninsert---1, delete---2, print---3, reverse---4, exit---0 : ");scanf("%d",&op);switch (op){case 0: mark=0;break;case 1: printf("\nPlease input the new element:");scanf("%f",&aa);insert(aa,vq);print(vq);break;case 2: if (vq->data==0)printf("\n the link is null !",aa);else{printf("\nPlease input the deleted element:");scanf("%f",&aa);dele(aa,vq);print(vq);}break;case 3: print(vq);break;case 4: reverse(vq);print(vq);break;default:printf(" input error!\n");}}}////////***************************************以下是待填空的源代码,请同学们粘贴到系统中填空、运行、测试:/* 链表操作:插入、删除、输出、翻转用带表头的链表存放输入的数据,每读入一个数,按升序顺序插入到链表中,链表中允许两个结点有相同值。
实验五__线性表的链式表示和实现
浙江大学城市学院实验报告课程名称数据结构基础实验项目名称实验五线性表的链式表示和实现学生姓名专业班级学号实验成绩指导老师(签名)日期一.实验目的和要求1、了解线性表的链式存储结构,学会定义线性表的链式存储结构。
2、掌握单链表、循环单链表的一些基本操作实现函数。
二.实验内容1、设线性表采用带表头附加结点的单链表存储结构,请编写线性表抽象数据类型各基本操作的实现函数,并存放在头文件LinkList.h中(注:教材上为不带表头附加结点)。
同时建立一个验证操作实现的主函数文件test5.cpp,编译并调试程序,直到正确运行。
提示:⑴单向链表的存储结构可定义如下:struct LNode { // 定义单链表节点类型ElemType data; // 存放结点中的数据信息LNode *next; // 指示下一个结点地址的指针}⑵线性表基本操作可包括如下一些:①void InitList (LNode *&H) //初始化单链表②void ClearList(LNode *&H) //清除单链表③int LengthList (LNode *H) //求单链表长度④bool EmptyList (LNode *H) //判断单链表是否为空表⑤ElemType GetList (LNode *H, int pos)//取单链表第pos 位置上的元素⑥void TraverseList(LNode *H) //遍历单链表⑦bool InsertList ( LNode *&H, ElemType item, int pos)//向单链表插入一个元素⑧bool DeleteList ( LNode *&H, ElemType &item, int pos)//从单链表中删除一个元素⑶带表头附加结点的单链表初始化操作的实现可参考如下:void InitList(LNode *&H){ //构造一个空的线性链表H,即为链表设置一个头结点,//头结点的data数据域不赋任何值,头结点的指针域next则为空H=(LNode *)malloc(sizeof(LNode)); // 产生头结点Hif (!H) exit(0); // 存储分配失败,退出系统H->next=NULL; // 指针域为空}2、选做部分:编写一个函数void MergeList(LNode *&La, LNode *&Lb, LNode *&Lc),实现将两个有序单链表La和Lb合并成一个新的有序单链表Lc,同时销毁原有单链表La和Lb。
实验一 线性表的链式存储
实验一线性表的链式存储【实验时间】【实验地点】【实验目的和要求】1.掌握线性表的结构特点和表示方法;2.掌握线性表链式存储结构特性和基本操作算法;3.掌握用指针实现单链表的建立、输出、插入和删除的算法。
【实验类型】验证性【实验时数】2学时【实验设备】计算机【参考资料】1.数据结构题解2.C程序设计【实验内容】熟练掌握线性表的链式表示和实现方法,利用其定义具体的链表结点;利用链表的结构特点,建立单链表;利用链表结点间的指针关系,实现链表的插入和删除。
[具体要求](1) 建立单链表时,要首先输入链表长度,根据输入值来确定所建链表的结点个数;(2) 在单链表中插入新结点时,要给出结点的插入位置和数据域的值;(3) 在单链表中删除某个结点时,要给出要删结点的位置;(4) 要编写单链表的输出函数,以便能验证程序的执行结果。
【实验分析】1、实验的第一步应该建立单链表结点类型和程序所需的宏或数据类型,例如:#define NULL 0 //宏定义NULL的值为0#define LEN sizeof(struct node) //宏定义LEN,为申请结点空间时做准备typedef struct{ int a;float b;} elemtype; //定义elemtype类型,这里同学们可以根据自己的情况来自行定义。
typedef struct node{elemtype data; //data域为elemtype类型的,它应该包含两个子域:a和bstruct node *next;}NODE , *NODEPTR; //定义了单链表结点类型和单链表结点指针类型2、对单链表的四种操作进行实现。
(1) NODEPTR creatlink() 建立单链表的函数很明显这个函数的返回值时结点指针类型的,所以这个函数应该返回的时建立的单链表的头指针。
同学们可以根据自己的构思,从前往后或从后往前建立单链表。
此外,提醒同学们最好建立带有附加头结点的单链表。
实验二 线性表的链
成 绩评 阅 人评阅日期计算机科学与技术系实 验 报 告课程名称:_________________________实验名称:_________________________班 级:_________________________学 号:_________________________姓 名:_________________________201年月日实验二 线性表的链数据结构 计算机实验二线性表的链式存储一、实验目的1、掌握线性表的链接存储结构;2、验证单链表及其基本操作的实现;3、进一步掌握数据结构及算法的程序实现的基本方法。
二、实验内容1、用头插法或尾插法建立带头结点的单链表;2、对已建立的单链表实现插入、删除、查询等基本操作。
三、实现提示1、将单链表中结点定义为如下结构类型:template <class T>struct Node{T data;Node<T> *next;};2、定义单链表的数据类型,单链表类LinkList,包括题目要求的插入、删除、查找等基本操作,为便于查看操作结果,设计一个输出函数依次输出单链表的元素。
template <class T>class LinkList{public:LinkList( ); //建立只有头结点的空链表LinkList(T a[ ], int n); //建立有n个元素的单链表~LinkList(); //析构函数int Length(); //求单链表的长度T Get(int i); //取单链表中第i个结点的元素值int Locate(T x); //求单链表中值为x的元素序号void Insert(int i, T x); //在单链表中第i个位置插入元素值为x的结点T Delete(int i); //在单链表中删除第i个结点void PrintList( ); //遍历单链表,按序号依次输出各元素private:Node<T> *first; //单链表的头指针};四、算法描述template <class T>struct Node{T data;Node<T> *next;}单链表类的声明:template <class T>class LinkList{public:LinkList( ){first=new Node<T>; first->next=NULL;}LinkList(T a[ ], int n);~LinkList( );int Length( );T Get(int i);int Locate(T x);void Insert(int i, T x);T Delete(int i);void PrintList( );private:Node<T> *first;};单链表查找算法Get:1、工作指针p初始化;累加器j初始化;2、执行下列操作,直到p为空或p执行第i个结点2.1 工作指针p后移;2.2 累加器j加1;3、若p为空,则第i个元素不存在,抛出查找位置异常;否则查找成功,返回结点p的数据元素;单链表插入算法Insert:1、工作指针p初始化;累加器j清零2、查找第i-1个结点并使工作指针p指向该节点;3、若查找不成功,说明插入位置不合理,抛出插入位置异常;否则,3.1生成一个元素值为x新结点s;3.2将新结点s插入到结点p之后;单链表删除算法Delete:1、工作指针p初始化;累加器j清零;2、查找第i-1个结点并使工作指针p指向该结点;3、若p不存在或p的后继结点不存在,抛出位置异常;否则,3.1 暂存被删除结点和被删除元素值;3.2 摘链,将结点p的后继结点从链表上摘下;3.3 释放被删结点;3.4 返回被删元素值;五、程序清单主函数#include <iostream.h>#include "2-1source.cpp"void main( ){LinkList<int>a; //创建一个空的顺序表cout<<"执行插入操作:"<<endl;try{a.Insert(1,1);a.Insert(2,3);a.Insert(3,4);}catch(char* wrong){cout << wrong; //如失败提示失败信息}cout<<"已经插入“1,3,4”"<<endl;cout<<endl;cout<<"顺序表a的长度为:";cout<<a.Length()<<endl; //返回单链表长度cout<<endl;cout<<"按位查询第二个元素:"<<endl;cout<<"第二个元素为:";cout <<a.Get(2)<<endl; //查找顺序表中第二个元素cout<<endl;cout<<"按值查询3:"<<endl;cout<<"值为3的元素位置为:";cout<<a.Locate(3)<<endl; //查找元素3,并返回在单链表中位置cout<<endl;try{if(a.Length()){cout<<"执行删除第一个元素操作:"<<endl;cout<<endl;a.Delete(1); //删除元素1cout<<"已删除成功,顺序表a的长度为:";cout<<a.Length()<<endl;}else{cout<<"顺序表a长度为0"<<endl;}}catch(char* wrong){cout << wrong; //如失败提示失败信息}cout<<endl;cout<<"顺序表a中的元素有:"<<endl;a.PrintList(); //输出所有元素int r[]={1,2,3,4,5};LinkList <int> b(r,5); //根据数组创建顺序表cout<<"执行插入操作前顺序表b为:"<<endl;b.PrintList(); //输出顺序表所有元素cout<<"插入前顺序表b的长度为:";cout<<b.Length()<<endl;try{b.Insert(3,8);}catch(char* wrong){cout << wrong; //如失败提示失败信息}cout<<"执行插入操作后顺序表b为:"<<endl;b.PrintList(); //输出顺序表b所有元素cout<<"插入后顺序表b的长度为:";cout<<b.Length()<<endl;cout<<endl;try{if(a.Length()){cout<<"执行删除第一个元素操作:"<<endl;cout<<endl;b.Delete(1); //删除b中第一个元素 cout<<"已删除成功,顺序表b的长度为:";cout<<b.Length()<<endl;}else{cout<<"顺序表b长度为0"<<endl;}}catch(char* wrong){cout << wrong; //如失败提示失败信息}cout<<"执行插入操作后顺序表b为:"<<endl;b.PrintList(); //输出顺序表所有元素}#include "2-1-header.h"template <class T>struct Node{T data;Node<T> *next;};template <class T>LinkList<T>:: LinkList( ){length=0;}template <class T>LinkList<T>:: LinkList(T a[], int n){if (n>MaxSize) throw "参数非法";for (int i=0; i<n; i++)data[i]=a[i];length=n;}template <class T>LinkList<T>:: ~LinkList( ){}template <class T>void LinkList<T>::Insert(int i, T x){int j;if (length>=MaxSize) throw "上溢";if (i<1 || i>length+1) throw "位置";for (j=length; j>=i; j--)data[j]=data[j-1]; //注意第j个元素存在数组下标为j-1处 data[i-1]=x;length++;}template <class T>T LinkList<T>::Delete(int i){int x,j;if (length==0) throw "下溢";if (i<1 || i>length) throw "位置";x=data[i-1];for (j=i; j<length; j++)data[j-1]=data[j]; //注意此处j已经是元素所在的数组下标 length--;return x;}template <class T>int LinkList<T>::Length(){return length;}template <class T>T LinkList<T>::Get(int i){if (i<1 && i>length) throw "查找位置非法";else return data[i-1];}template <class T>int LinkList<T>::Locate(T x){for (int i=0; i<length; i++)if (data[i]==x)return i+1 ; //下标为i的元素等于x,返回其序号i+1 return 0; //退出循环,说明查找失败}template <class T>void LinkList<T>::PrintList(){for(int i=0;i<length;i++)cout<<data[i]<<endl;}头文件#ifndef LinkList_H#define LinkList_Hconst int MaxSize=100; //100只是示例性的数据,可以根据实际问题具体定义template <class T> //定义模板类SeqListclass LinkList{public:LinkList( ); //无参构造函数LinkList(T a[], int n); //有参构造函数~LinkList(); //析构函数为空int Length(); //求线性表的长度T Get(int i); //按位查找,取线性表的第i个元素int Locate(T x); //按值查找,求线性表中值为x的元素序号void Insert(int i, T x); //在线性表中第i个位置插入值为x的元素 T Delete(int i); //删除线性表的第i个元素void PrintList(); //遍历线性表,按序号依次输出各元素private:T data[MaxSize]; //存放数据元素的数组int length; //线性表的长度};#endif六、思考题:为单链表的结点设计一个结点类,重新实现单链表基本操作的验证。
链式存储实验报告
线性表的链式存储
一、目的:
1.顺序表链式存储结构的运算;
2.顺序表空间分配好后的各个运算的执行;
3.顺序表中的打印、输入、置空表、长度、插入、删除的运算等
二、功能层次图:
三、运行结果:
主菜单:
建立链表:
打印 线性表的链式存储
输入 置空表 长度 插入 删除
打印链表:
链表查询:
四、小结:
1.线性表的线性存储是将线性表中的结点采用连接的方式存储;
2.链式存储是用任意的存储单元来存储数据的,这个单元可以使连续的也可以是不连续的,所以链表的结点的逻辑次序和物理次序不一定相同;
3.链表中每个结点的的存储地址是放在前一个前驱的next,而第一个结点无前驱则头指针是head;
4.链表在查找运算中耗时较多,在查找是链表必须从头指针开始扫描才能获得;
5.链表在进行插入和输出运算,都只用修改指针的存放地址的单元。
实验二 线性表链式存储运算的算法实现(昆工版)
昆明理工大学信息工程与自动化学院学生实验报告( 2013 — 2014 学年第三学期 )课程名称:数据结构 开课实验室:信自楼444 2013年11月12日注:报告内容按实验须知中七点要求进行。
一、实验目的和要求1.掌握线性表链式存储结构的C 语言描述及运算算法的实现;2.分析算法的空间复杂度和插入和删除的时间复杂度;3.总结比较线性表顺序存储存储与链式存储的各自特点。
程序功能: 1.(菜单)主程序; 2.链表的建立; 3.链表的数据插入;4.链表的数据删除;5.链表的数据输出;二、实验原理及基本技术路线图(方框原理图) 三、所用仪器、材料(设备名称、型号、规格等) 联想计算机一台Microsoft Visual c++ 6.0四、程序源代码#include<stdio.h>#include<conio.h>#include<malloc.h>#include<stdlib.h>typedef int dataType;typedef struct node{dataType data;struct node *next;}linkList;linkList *createList(){int num;linkList *head,*s,*r;head=NULL;r=NULL;printf("Enter the number(0 to stop):");scanf("%d",&num);while(num!=00){s=(linkList*)malloc(sizeof(linkList));s->data=num;if(head==NULL) head=s;else r->next=s;r=s;printf("Enter the number(0 to stop):");if(r!=NULL) r->next=NULL;return head;}linkList *get(linkList *head,int i){int j;linkList *p;p=head;j=0;while((p->next!=NULL)&&(j<i)){p=p->next;j++;}if(i==j) return p;else return NULL;}linkList *locate(linkList *head,dataType key) {linkList *p;p=head->next;while(p!=NULL){if(p->data!=key)p=p->next;else break;}return p;}s=(linkList*)malloc(sizeof(linkList));s->data=x;s->next=p->next;p->next=s;}void insertBefore(linkList *p,dataType x){linkList *s;s=(linkList*)malloc(sizeof(linkList));s->data=p->data;s->next=p->next;p->next=s;p->data=x;}void insert(linkList *L,dataType x,int i){linkList *p;int j;j=i-1;p=get(L,j);if(p==NULL){printf("erro\n");getch();}else {insertAfter(p,x);printf("\nInsert Succeed");getch();} }r=p->next;p->next=r->next;free(r);}void Delete(linkList *L,int i){int j;linkList *p;j=i-1;p=get(L,j);if(p!=NULL&&p->next!=NULL){deleteAfter(p);printf("\nDelete Succeed");getch();} else{printf("error\n");getch();}}void display(linkList *head){int i=1;if(head==NULL){printf("Empty List\n");}while(head!=NULL){head=head->next;i++;}}char caiDan(){char ch;do{printf("1:Create New List\n");printf("2:Insert\n");printf("3:Delete\n");printf("4:Display\n");printf("5:Exit\n");printf("Please Choose:");}while(ch=getch(),ch!='1'&&ch!='2'&&ch!='3'&&ch!='4'&&ch!='5'); return ch;}void main(){linkList *head=NULL;char ch;int i,key;do{system("cls");ch=caiDan();printf("%c",ch);getch();switch(ch){case '1': head=createList();printf("List was created successfully");getch();break;case '2': display(head);if(head==NULL) { getch(); break; }else {printf("\nInput Key:");scanf("%d",&key);printf("Input Index u want to insert after:");scanf("%d",&i);insert(head,key,i);break; }case '3': display(head);if(head==NULL) { getch(); break; }else {printf("\nInput index you want to delete:");scanf("%d",&i);Delete(head,i-1);break; }case '4': display(head);getch();break;case '5': exit(0);}}while(ch!='5');}五、运行结果(1)创建单链表(2)插入单链表(4)删除单链表(6)插入错误(7)删除错误六、实验总结在做这个程序的时候,虽然遇到一些问题,但最后都被我解决,自信心上得到比较大的提升,这也是这次实践最大的收获。
实验报告
2.将实验材料(附件)中的c1.h和linklist.cpp文件复制到同一个文件夹中。
其中,c1.h中包含程序中常用的头文件及宏定义,以后每次都要记得将该文件包括到你的源程序中。
linklist.cpp中包含线性表顺序存储结构的定义和部分基本操作的实现。
实验报告
课程名称
数据结构
实验名称
线性表的链式存储结构
实验间
11月4日星期二下午
实验地点
数学院楼504
班级
信息1班
学号
姓名
一、实验目的与要求
实验目的:了解和掌握线性表的逻辑结构和链式存储结构,掌握单链表的基本算法。
实验要求:1,根据实验内容编程,上机调试,得出正确的运行程序。
2,编译运行程序,观察运行情况和输出结果。
3,写出实验报告。
二、实验内容与步骤
一.实验内容
1.利用基本操作实现两个有序表合并(教材算法2.2)
2.补充未完成的基本操作:InitList,DestroyList,ListLength,ListTraverse,GetElem,ListInsert
3.记录实验过程并总结实验经验,完成实验报告。
二.实验步骤
{
pc->next=pb;
pc=pb;
pb=pb->next;
}
}
pc->next=pa?pa:pb;
free(Lb);
}
2,调用基本操作的好处:调用基本操作的过程中没有破坏链表的原始结构。更容易理解程序每一步操作的含义,结构条理清楚,增加程序的可读性。
指导老师
评分情况
void MergeList(LinkList La,LinkList Lb,LinkList &Lc) //算法2.2
线性表的链式存储结构和实现
经济学院实验报告学院: ______专业:计算机班级: ________________学号: ____________姓名:_________________信息工程学院计算机实验中心制实验题目:线性表的链式存储结构和实现实验室:机房4 设备编号: 09 完成日期:2012. ()4. ()9一、实验容1.会定义线性表的链式存储结构。
2.熟悉对单链表的一些基本操作(建表、插入、删除等)和具体的函数定义。
二、实验目的学握链式存储结构的特点,掌握并实现单链表的常用的基本算法。
三、实验的容及完成情况1.需求分析(1)线性表的抽象数据类型ADT的描述及实现。
本实验实现使用Visual c卄6.0实现线性表链式存储结构的表示及操作。
具体实现要求:(2)完成对线性表链式存储结构的表示和实现。
(3)实现对单链表的创建。
(4)实现对单链表的插入和删除操作。
2.概要设计抽象数据类型线性表的定义:ADT LIST{抽象对象:D= {ai | ai<-Elemset, i = l,2, •••,n,n>=0}数据关系:Rl= {<ai-l,ai<-DJ=2.-,n}基本操作:InitList(&L)操作结果:构造一个空的线性表L。
DestoryList(&L)初始条件:线性表L已存在。
操作结果:销毁线性表LCLearList(&L)初始条件:线性表L已存在。
操作结果:将L重置为空表。
ListEmpty(L)初始条件:线性表L已存在。
操作结果:若L为空表,则返回TRUE,否则返回FALSE。
ListLength(L)初始条件:线性表L已存在。
操作结果:返回L中数据元素个数。
GetElem(L,I,&e)初始条件:线性表L已存在,l<=i<=ListLength(L)o操作结果:用e返回L中第i个数据元素的值。
LocateElem(L,e,compare())初始条件:线性表L已存在,compare()是数据元素判定的函数。
线性表的链式存储结构实验报告
贵州大学实验报告学院:计算机科学与信息学院专业:信息安全班级:chaintable *Buildtable(int x[],int y) {chaintable *p,*head;p=new chaintable;head=p;p->data=x[0];for(int i=1;i<y;i++){p->next=new chaintable;p=p->next;p->data=x[i];}p->next=NULL;return head;}bool Deltable(chaintable *&head,int x) {if(x<1)return false;chaintable *relief,*p=head;for(int i=0;i<x-2;i++){if(p->next==NULL)return false;p=p->next;}if(x==1){relief=head;head=head->next;delete relief;if(head!=NULL)return true;elsereturn false;}else{if(p->next!= NULL){relief=p->next;p->next=p->next->next;delete relief;return true;}elsereturn false;}}bool Inserttable(chaintable *&head,int x,int y) {if(y<0)return false;chaintable *p=head,*t=new chaintable;t->data=x;t->next=NULL;if(y==0){t->next=head;head=t;return true;}else{for(int i=0;i<y-1;i++){if(p->next==NULL)return false;p=p->next;}t->next=p->next;p->next=t;return true;}}void Disptable(chaintable *p){while(p!=NULL){cout<<p->data<<' ';p=p->next;}cout<<endl;}bool Searchtable(chaintable *p,int &y,int x) {if(x>=1){for(int i=0;i<x-1;i++){if(p->next==NULL)return false;p=p->next;}y=p->data;return true;}elsereturn false;}int Location(chaintable *p,int x){int i=1;while(p!=NULL){if(p->data==x)return i;i++;p=p->next;}return 0;}void main(){int x,*temp,result;chaintable *head;cin>>x;temp=new int[x];for(int i=0;i<x;i++)cin>>temp[i];head=Buildtable(temp,x);if(Deltable(head,2)){cout<<"删除操作结果:";Disptable(head);}elsecout<<"操作失败!"<<endl;if(Inserttable(head,23,5)){cout<<"将23插入到第五个数字后面的操作结果:";Disptable(head);}elsecout<<"操作失败!"<<endl;if(Searchtable(head,result,4)){cout<<"链表的第四个数是:";cout<<"Search result:"<<result<<endl;}elsecout<<"操作失败!"<<endl;cout<<"Please input your integer:";cin>>x;cout<<"Location:"<<Location(head,x)<<endl;}实验结果:实验总结结果说明:1、第一行的8表示链表初始有8个数2、第二行的8个数是链表初始化的8个数3、第三行的结果是从链表删除了第二个数后的结果4、第五行的结果是搜索链表第四个数5、第六行是输入一个数要搜索的数(图中为25),第七行得出了搜索的结果。
线性表的链式存储结构实验报告
线性表的链式存储结构实验报告实验一:线性表的链式存储结构【问题描述】某项比赛中,评委们给某参赛者的评分信息存储在一个带头结点的单向链表中,编写程序:(1)显示在评分中给出最高分和最低分的评委的有关信息(姓名、年龄、所给分数等)。
(2)在链表中删除一个最高分和一个最低分的结点。
(3)计算该参赛者去掉一个最高分和一个最低分后的平均成绩。
【基本要求】(1)建立一个评委打分的单向链表;(2)显示删除相关结点后的链表信息。
(3)显示要求的结果。
【实验步骤;】(1)运行PC中的Microsoft Visual C++ 6.0程序,(2)点击“文件”→“新建”→对话窗口中“文件”→“c++ Source File”→在“文件名”中输入“X1.cpp”→在“位置”中选择储存路径为“桌面”→“确定”,(3)输入程序代码,程序代码如下:head=create(PWRS);printf("所有评委打分信息如下:\n");print(head);//显示当前评委打分calc(head);//计算成绩printf("该选手去掉 1 最高分和 1 最低分后的有效评委成绩:\n");print(head);//显示去掉极限分后的评委打分}void input(NODE *s) #include#include#include#include#include#define NULL 0#define PWRS 5 //定义评委人数struct pw //定义评委信息{ char name[6];float score;int age;};typedef struct pw PW;struct node //定义链表结点{struct pw data;struct node * next;};typedef struct node NODE;//自定义函数的声明NODE *create(int m); //创建单链表int calc(NODE *h); //计算、数据处理void print(NODE *h); //输出所有评委打分数据void input(NODE *s);//输入评委打分数据void output(NODE *s);//输出评委打分数据void main(){NODE *head;float ave=0;float sum=0;{printf("请输入评委的姓名: ");scanf("%S",&s->/doc/433085523.html,); printf("年龄: ");scanf("%d",&s->data.age);printf("打分: ");scanf("%f",&s->data.score);printf("\n");}void output(NODE *s){printf("评委姓名: %8s ,年龄: %d,打分: %2.2f\n",s->/doc/433085523.html,,s->data. age,s->data.score);}NODE *create(int m){NODE *head,*p,*q;int i;p=(NODE*)malloc(sizeof(NODE));head=p;q=p;p->next=NULL;for(i=1;i<=m;i++){p=(NODE*)malloc(sizeof(NODE));input(p);p->next=NULL;q->next=p;q=p;}return (head);}void print(NODE *h){ for(int i=1;((i<=PWRS)&&(h->next!=NULL));i++){h=h->next;output(h); }printf("\n");}int calc(NODE *h){NODE *q,*p,*pmin,*pmax;float sum=0;float ave=0;p=h->next; //指向首元结点pmin=pmax=p; //设置初始值sum+=p->data.score;p=p->next;for(;p!=NULL;p=p->next){if(p->data.score>pmax->data.score) pmax=p;if(p->data.scoredata.score) pmin=p;sum+=p->data.score;}cout<<"给出最高分的评委姓名:"</doc/433085523.html,<<"年龄:"<data.age<<"分值:"<data.score<<endl;< bdsfid="172" p=""></endl;<>cout<<"给出最低分的评委姓名:"</doc/433085523.html,<<"年龄:"<data.age<<"分值:"<data.score<<endl;< bdsfid="177" p=""></endl;<>printf("\n");sum-=pmin->data.score;sum-=pmax->data.score;for (q=h,p=h->next;p!=NULL;q=p,p=p->next){if(p==pmin){q->next=p->next; p=q;}//删除最低分结点if(p==pmax) {q->next=p->next; p=q;}//删除最高分结点}ave=sum/(PWRS-2);cout<<"该选手的最后得分是:"<<ave<<endl;< bdsfid="188" p=""></ave<<endl;<>return 1;}实验结束。
线性表的链式存储结构实验报告
线性表的链式存储结构实验报告文件编码(008-TTIG-UTITD-GKBTT-PUUTI-WYTUI-8256)实验报告课程名称:数据结构与算法分析实验名称:链表的实现与应用实验日期:班级:数媒1401 姓名:范业嘉学号 08一、实验目的掌握线性表的链式存储结构设计与基本操作的实现。
二、实验内容与要求⑴定义线性表的链式存储表示;⑵基于所设计的存储结构实现线性表的基本操作;⑶编写一个主程序对所实现的线性表进行测试;⑷线性表的应用:①设线性表L1和L2分别代表集合A和B,试设计算法求A和B的并集C,并用线性表L3代表集合C;②(选做)设线性表L1和L2中的数据元素为整数,且均已按值非递减有序排列,试设计算法对L1和L2进行合并,用线性表L3保存合并结果,要求L3中的数据元素也按值非递减有序排列。
⑸设计一个一元多项式计算器,要求能够:①输入并建立多项式;②输出多项式;③执行两个多项式相加;④执行两个多项式相减;⑤(选做)执行两个多项式相乘。
三、数据结构设计1.按所用指针的类型、个数、方法等的不同,又可分为:线性链表(单链表)静态链表循环链表双向链表双向循环链表2.用一组任意的存储单元存储线性表中数据元素,用指针来表示数据元素间的逻辑关系。
四、算法设计1.定义一个链表void creatlist(Linklist &L,int n){int i;Linklist p,s;L=(Linklist)malloc(sizeof(Lnode));p=L;L->next=NULL;for(i=0;i<n;i++){s=(Linklist)malloc(sizeof(Lnode));scanf("%d",&s->data);s->next=NULL;p->next=s; p=s;}}2.(1)两个链表的合并void Mergelist(Linklist &La,Linklist &Lb,Linklist &Lc) {Linklist pa,pb,pc;pa=La->next;pb=Lb->next;Lc=pc=La;while(pa&&pb){if(pa->data<=pb->data){pc->next=pa;pc=pa;pa=pa->next;}else {pc->next=pb;pc=pb;pb=pb->next;} }pc->next=papa:pb;free(Lb);}(2)两个链表的并集Linklist unionlist(Linklist &La,Linklist &Lb){Linklist p1,p2,head,q,s;int flag;head=q=(Linklist)malloc(sizeof(Lnode));p1=La->next;while(p1){flag=0;p2=Lb->next;while(p2){if(p1->data==p2->data){flag=1;break;}p2=p2->next;}if(flag==0){s=(Linklist)malloc(sizeof(Lnode));s->data=p1->data;q->next=s;q=s;}p1=p1->next;}q->next=Lb->next;return head;}3.(1)一元多项式的加法List addpoly(List pa,List pb)3.六、心得体会(包括对于本次实验的小结,实验过程中碰到的问题等)1.首先书上给的链表输入是倒序的,写的时候想都没想就抄上去了,结果运行时发现问题,可是上网百度依然没有把问题解决,导致最后输出链表倒序的,并且链表的合并并集依旧是倒序的。
实验四 线性表的链式存储实验
实验四线性表的链式存储实验【实验目的】⑴掌握链表的概念,学会对单向链表的插入,删除等操作.⑵加深对链式存储结构的理解,逐步培养解决实际问题的编程能力.⑶学会菜单程序的编写。
【实验类型】验证型+设计型实验。
【实验时间及地点】2011,10,12。
同析楼3幢109室。
【实验说明】阅读下列实验说明,它能帮助你顺利完成实验。
把其中的中文说明注释掉,就是一完整的C程序。
//1.存储结构定义及库文件如下:#include <stdlib.h>#include <stdio.h>#define OK 1#define ERROR 0typedef int ElemType;typedef struct Node{ElemType data;struct Node *next;}Node,*LinkList;//2.以下是菜单选择函数int menu_select(){int sn;printf("\n");printf(" 主菜单\n");printf("*********************\n");printf(" 1.单链表的建立\n");printf(" 2.单链表的结点的删除\n");printf(" 3.单链表的输出\n");printf(" 0.退出\n");printf("*********************\n");printf(" 请选择0---3: ");for(;;){scanf("%d",&sn);if(sn<0||sn>3)printf("\n\t输入错误,重选¡0---3: ");elsebreak;}return sn;void InitList(LinkList *L){*L=(LinkList)malloc(sizeof(Node));(*L)->next=NULL;}/*voi d InitList(LinkList L){L=(LinkList)malloc(sizeof(Node));L->next=NULL;}*///3.通过键盘输入链表中元素值,利用头插法建单链表L。
链式存储的实验报告
实验名称:线性表的链式存储结构实验日期:2022年X月X日班级:XX班姓名:XXX学号:XXXXXXX指导教师:XXX一、实验目的1. 理解线性表的链式存储结构及其特点。
2. 掌握链表的基本操作,如创建、插入、删除、查找和遍历等。
3. 通过实际编程实现链表,加深对链式存储结构概念的理解。
二、实验内容与要求1. 定义线性表的链式存储表示,包括节点结构和链表结构。
2. 实现链表的基本操作,如创建链表、插入节点、删除节点、查找节点和遍历链表等。
3. 编写测试代码,验证链表操作的正确性。
三、实验步骤1. 定义链表节点结构体,包含数据和指向下一个节点的指针。
2. 创建链表结构体,包含指向头节点的指针和节点数量。
3. 实现链表创建操作,初始化链表。
4. 实现链表插入操作,包括在链表头部、尾部和指定位置插入节点。
5. 实现链表删除操作,包括删除链表头部、尾部和指定位置的节点。
6. 实现链表查找操作,根据节点数据查找节点在链表中的位置。
7. 实现链表遍历操作,打印链表中的所有节点数据。
8. 编写测试代码,验证链表操作的正确性。
四、实验代码```c#include <stdio.h>#include <stdlib.h>// 定义链表节点结构体typedef struct Node {int data;struct Node next;} Node;// 创建链表Node createList() {Node head = (Node)malloc(sizeof(Node));if (head == NULL) {printf("Memory allocation failed!\n"); return NULL;}head->next = NULL;return head;}// 在链表头部插入节点void insertAtHead(Node head, int data) {Node newNode = (Node)malloc(sizeof(Node)); if (newNode == NULL) {printf("Memory allocation failed!\n"); return;}newNode->data = data;newNode->next = head->next;head->next = newNode;}// 在链表尾部插入节点void insertAtTail(Node head, int data) {Node newNode = (Node)malloc(sizeof(Node)); if (newNode == NULL) {printf("Memory allocation failed!\n"); return;}newNode->data = data;newNode->next = NULL;Node current = head;while (current->next != NULL) {current = current->next;}current->next = newNode;}// 删除链表头部节点void deleteAtHead(Node head) {if (head->next == NULL) {printf("List is empty!\n");return;}Node temp = head->next;head->next = temp->next;free(temp);}// 删除链表尾部节点void deleteAtTail(Node head) {if (head->next == NULL) {printf("List is empty!\n");return;}Node current = head;while (current->next->next != NULL) { current = current->next;}Node temp = current->next;current->next = NULL;free(temp);}// 删除指定位置的节点void deleteAtPosition(Node head, int position) {if (head->next == NULL || position < 0) {printf("Invalid position!\n");return;}Node current = head;int index = 0;while (current->next != NULL && index < position - 1) { current = current->next;index++;}if (current->next == NULL) {printf("Invalid position!\n");return;}Node temp = current->next;current->next = temp->next;free(temp);}// 查找节点Node findNode(Node head, int data) {Node current = head->next;while (current != NULL) {if (current->data == data) { return current;}current = current->next;}return NULL;}// 遍历链表void traverseList(Node head) {Node current = head->next;while (current != NULL) {printf("%d ", current->data); current = current->next;}printf("\n");}// 释放链表内存void freeList(Node head) {Node current = head;while (current != NULL) {Node temp = current;current = current->next;free(temp);}}int main() {Node head = createList();insertAtHead(head, 3);insertAtHead(head, 2);insertAtHead(head, 1);insertAtTail(head, 4);insertAtTail(head, 5);printf("Original list: ");traverseList(head);deleteAtHead(head);deleteAtTail(head);printf("List after deleting head and tail: ");traverseList(head);deleteAtPosition(head, 1);printf("List after deleting node at position 1: ");traverseList(head);Node node = findNode(head, 3);if (node != NULL) {printf("Node with data 3 found at position: %d\n", (head->next == node ? 1 : (head->next != NULL ? 2 : 3)));} else {printf("Node with data 3 not found.\n");}freeList(head);return 0;}```五、实验结果与分析1. 通过实验,成功实现了线性表的链式存储结构,包括创建、插入、删除、查找和遍历等基本操作。
数据结构实验报告2线性表的 链式存储结构
原
序。
理
方 2. 编译运行程序,观察运行情况和输出结果。
法 3. 写出实验报告(包括源程序和运行结果)。
和
手
段
#include <stdio.h> #include <iostream.h> #include <stdlib.h> typedef int ElemType; struct list {
5.编写一个主函数,调试上述算法。
实 验 数 据
此次试验不是成功的,问题有很多,由于对从C++编程和单 实 验 向链表的操作不是很熟练,导致实验有很多困难。希望以后能更 总 结 加熟练地进行实验,并从实验中收获更多的知识经验。
指 导 教 师 意
见
数据结构实验报告(2)
专业: 实验组
实验时 2011-11-11
间
指导教 师
成绩
实验项 目名称
线性表的链式存储结构
实
验
了解和掌握线性表的逻辑结构和链式存储结构,掌握单链表 的基本算法。
目
的
实 验
运行Visual c++的微机一台 条 件
实 1. 根据实验内容编程,上机调试、得出正确的运行程
{int i;
printf("删除操作\n");
if((pos<0)||(pos>l.size+1))
{ printf("位置无效");
return false;}
if(l.size ==0)
{ cout<<"线性表为空";
return false;} for(i=pos;i<l.size ;i++) l.elem [i-1]=l.elem [i]; l.size --; if(float(l.size )/l.maxsize <0.4&&l.maxsize >10){
数据结构实验报告三线性表的链式存储
实验报告三线性表的链式存储班级: 2010XXX 姓名: HoogLe 学号: 2010XXXX 专业: XXXX*****************(1)实验目的:(2)掌握单链表的基本操作的实现方法。
(3)掌握循环单链表的基本操作实现。
(4)掌握两有序链表的归并操作算法。
实验内容: (请采用模板类及模板函数实现)1.线性表链式存储结构及基本操作算法实现[实现提示] (同时可参见教材p64-p73页的ADT描述及算法实现及ppt)函数、类名称等可自定义, 部分变量请加上学号后3位。
也可自行对类中所定义的操作进行扩展。
所加载的库函数或常量定义:#include <iostream>using namespace std;(1)单链表存储结构类的定义:template<class T>class LinkList{public:LinkList(); //初始化带头结点空单链表构造函数实现LinkList(T a[],int n);//利用数组初始化带头结点的单链表构造函数实现~LinkList();int length(); //求单链表表长算法T get(int i); //获得单链表中第i个结点的值算法int locate(T temp);void insert(int i,T temp); //在带头结点单链表的第i个位置前插入元素e算法T Delete(int i); //在带头结点单链表中删除第i个元素算法void print(); //遍历单链表元素算法bool isEmpty(); //判单链表表空算法void deleleAll(); //删除链表中所有结点算法(这里不是析构函数, 但功能相同)private:Node<T> *head;};(2)初始化带头结点空单链表构造函数实现输入:无前置条件: 无动作: 初始化一个带头结点的空链表输出:无后置条件: 头指针指向头结点。
实验一线性表[链式存储结构]
实验一线性表一.目的与要求本次实习的主要目的是为了使学生熟练掌握线性表的基本操作在顺序存储结构和链式存储结构上的实现,提高分析和解决问题的能力。
要求仔细阅读并理解下列例题,上机通过,并观察其结果,然后独立完成后面的实习题。
二.例题[问题描述]用链表形式存储一个字符串,插入、删除某个字符,最后按正序、逆序两种方式输出字符串。
[输入]初始字符串,插入位置,插入字符,删除字符。
[输出]已建立链表(字符串),插入字符后链表,删除字符后链表,逆转后链表。
[存储结构]采用链式存储结构[算法的基本思想]建立链表:当读入字符不是结束符时,给结点分配存储空间,写数据域,将新结点插到表尾;插入字符:根据读入的字符在链表中找插入位置,将新结点插入到该位置之前;删除字符:根据读入的删除字符在链表中找到被删结点后,将其从链表中删除;链表逆转:从链表的第一个结点开始对所有结点处理,将每个结点的前驱变为它的后继;打印链表:从链表的第一个结点开始,依次打印各个结点的数据域。
[参考源程序]#define NULL 0typedef struct node{char a;struct node *link;}node,*nodelink;void readlink(nodelink head){nodelink p,q;char c;p=head;printf("Input a linktable(a string):");scanf("%c",&c);if (c=='\n') printf("This string is empty。
");while(c!='\n'){q=(nodelink)malloc(sizeof(node));q->a=c;p->link=q;p=q;scanf("%c",&c);}p->link=NULL;}void writelink(nodelink head){nodelink q;if (head->link==NULL) printf(" This link is empty。
数据结构实验线性表的链式存储结构
南昌航空大学实验报告课程名称:数据结构实验名称:实验一线性表的链式存储结构班级:080611 学生姓名:冯武明学号:16 指导教师评定:XXX 签名: XXX题目:设计并实现以下算法:给出用单链表存储多项式的结构,利用后接法生成多项式的单链表结构,实现两个多项式相加的运算,并就地逆置相加后的多项式链式。
一、需求分析⒈先构造两个多项式链表,实现两个多项式的和及删除和值为零元素的操作,不同用户输入的多项式不同。
⒉在演示过程序中,用户需敲击键盘输入多项式,即可观看结果。
⒊程序执行的命令包括:(1)构造多项式链表pa (2)构造多项式链表pb (3)求两张链表的和(4)删除和值为零元素,即不创建链表结点。
二、概要设计⒈为实现上述算法,需要线性表的抽象数据类型:ADT Stack {数据对象:D={a i:|a i∈ElemSet,i=1…n,n≥0}数据关系:R1={<a i-1,a i>|a i-1,a i∈D,i=2,…n≥0}基本操作:init(list *L)操作结果:构造一个空的线性表L。
ListLength(List *L)初始条件:线性表L已经存在操作结果:返回L中数据元素的个数。
GetElem(List L, int i, ElemType *e)初始条件:线性表L已经存在,1≤i≤ListLength(&L)操作结果:用e返回L中第i个数据元素的值。
EqualList(ElemType *e1,ElemType *e2)初始条件:数据元素e1,e2存在操作结果:以e1,e2中的姓名项作为判定e1,e2是否相等的依据。
Less_EquaList(ElemType *e1,ElemType *e2)初始条件:数据元素e1,e2存在操作结果:以e1,e2中的姓名项(为字符串)的≤来判定e1,e2是否有≤的关系。
LocateElem(List *La,ElemType e,int type)初始条件:线性表La已经存在操作结果:判断La中是否有与e相同的元素。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
{
p = p->next;
j++;
}
if(p==NULL)
{
printf("插入的位置超过合法范围\n");
exit(0);
}
else if(pe==1)
{
q = (Link *)malloc(sizeof(Link));
if(q==NULL)
{
printf("空间不足,节点申请失败!\n");
while(p!=NULL)
{
printf("%d ",p->data);
p = p->next;
}
printf("\n");
break;
case 2:
printf("1按序号查找\n2按值查找\n");
while(m=='y')
{
printf(#34;%d",&chioce);
}
q->data = e;
q->next = p;
head->next = q;
}
else
{
q = (Link *)malloc(sizeof(Link));
if(q==NULL)
{
printf("空间不足,节点申请失败!\n");
exit(0);
}
q->data = e;
q->next = p->next;
实验报告
学号:****************年**月**日
系别
***
专业
**
班级
1班
姓名
****
课程名称
数据结构
课程类型
专业必修
学时数
2
实验名称
线性表的链式存储实验
实验目的和要求:
(1)掌握用在VC环境下上机调试单链表的基本方法
(2)掌握单链表、循环链表的插入、删除、查找、求表长以及有序单链表的合并算法的实现
{
printf("次链表为空!请先创建链表\n");
exit(0);
}
while(p!=NULL && i<k)
{
p = p->next;
i++;
}
if(p==NULL)
{
printf("输入序号超过表长!\n");
exit(0);
}
else
printf("第%d个元素为%d\n",k,p->data);
scanf(" %c",&m);
}
break;
case 3:
printf("输入插入的数值:");
scanf("%d",&e);
printf("输入节点的位置:");
scanf("%d",&pe);
Insert_elem(head,pe,e);
break;
case 4:
printf("1按位置删除\n2按值删除\n3删除链表中所有的重复元素\n");
p->next = q;
}
printf("插入新节点后的链表为:\n");
p = head->next;
while(p!=NULL)
{
printf("%d ",p->data);
p = p->next;
}
}
//删除元素
void Delete(Link *head,int chioce)
{
int k,j=1;
while(1)
{
printf("请选择要执行的操作:");
scanf("%d",&chioce);
Delete(head,chioce);
printf("\n是否继续操作(y/n):");
scanf(" %c",&c);
if(c=='n')
break;
}
break;
case 5:
printf("\n创建第一个列表\n");
exit(0);
break;
}
}while(pick!=0);
}
运算结果:
二、循环链表的基本操作
源代码:
#include <stdio.h>
#include <stdlib.h>
typedef struct link
{
int data;
struct link *next;
}Link;
//创建链表并初始化
scanf(" %c",&c);//注意吸收回车符
getchar();
while(c=='y')
{
i++;
headLb = Create_link(headLb);
printf("是否要创建新的节点(y/n):");
scanf(" %c",&c);//吸收回车符可以在scanf后加入多个空格
}
p = headLb->next;
}
else
{
printf("%d在第%d个位置且地址为%d\n",key,i,p);
}
}
//将e插入链表的第pe个位置
void Insert_elem(Link *head,int pe,int e)
{
Link *q = NULL;//q用于申请新节点
Link *p = head->next;
int j=1;
p->next = NULL;
printf("请输入该结点的数据:");
scanf("%d",&(p->data));
}
return head;
}
//在链表中按序号查找
void Insert_link(Link *head,int k)
{
int i=1;
Link *p = head->next;
if(head==NULL)
printf("是否要创建新的节点(y/n):");
scanf(" %c",&c); //注意吸收在选择时的回车符
getchar();
while(c=='y')
{
i++;
headLa = Create_link(headLa);
printf("是否要创建新的节点(y/n):");
scanf(" %c",&c);
int chioce,pick;
int e,pe;
printf("1创建链表\n2链表的查找\n3链表的插入\n4链表的删除\n5两链表的合并\n6退出操作\n");
do{
printf("\n选择:");
scanf("%d",&pick);
switch(pick)
{
case 1:
printf("是否要创建新的节点(y/n):");
Link *ptr =NULL;
while(pa && pb)
{
if(pa->data < pb->data)
{
pc->next = pa;
pc = pa;
pa = pa->next;
}
else if(pa->data > pb->data)
{
pc->next = pb;
pc = pb;
pb = pb->next;
printf("共创建%d个节点\n链表为:\n",i);
while(p!=NULL)
{
printf("%d ",p->data);
p = p->next;
}
printf("\n");
printf("\n合并后的链表为\n");
Merge(headLa,headLb);
break;
case 0:
printf("退出操作!\n");
switch(chioce)
{
case 1:
printf("输入序号:");
scanf("%d",&k);
Insert_link(head,k,i);
break;
case 2:
printf("输入元素值:");
scanf("%d",&key);
Find_elem(head,key);
break;
}
printf("是否继续查找(输入y/n):");
if(p==NULL)
{
printf("没有足够的空间!\n");
exit(0);
}
if(head==NULL)
{
head = p;
p->next = NULL;