实验二 线性表的应用
建立一个顺序表,表中元素为学生,每个学生信息包含姓名、学号和成绩三部分,对该表实现输出、插入、删除、
云南大学物理实验教学中心实验报告课程名称:计算机软件技术基础实验项目:实验二、线性表(顺序存储)及其应用学生姓名:学号:学院系级专业成绩指导教师:实验时间:年日时分至时分实验地点:实验类型:教学(演示□验证□综合█设计□)学生科研□课外开放□测试□其它□一、实验目的:掌握顺序表的建立及基本操作。
二、问题:建立一个顺序表,表中元素为学生,每个学生信息包含姓名、学号和成绩三部分,对该表实现:①输出、②插入、③删除、④查找功能,并计算出平均成绩和总成绩。
三、程序的编写与调试1、原程序:#include <iostream>using namespace std;typedef struct{ long double num; char name[10]; int score; } STUDENT; class sq_LList{ private:int mm;int nn;STUDENT *v;public:sq_LList(int);void prt_sq_LList();void ins_sq_LList(int, STUDENT);void del_sq_LList(int);void sea_num_sq_LList(int);voidvoid cal_sq_LList(int);};/*输出*/sq_LList ::sq_LList(int m){ mm=m;v=new STUDENT [mm];v[0].num=970156; strcpy(v[0].name,"张小明"); v[0].score=87; v[1].num=970157; strcpy(v[1].name,"李小青"); v[1].score=96;v[2].num=970158; strcpy(v[2].name,"刘华");v[2].score=85; v[3].num=970159; strcpy(v[3].name,"王伟");v[3].score=93; v[4].num=970160; strcpy(v[4].name,"李启明"); v[4].score=88;nn=5;}void sq_LList ::prt_sq_LList(){ int i;for(i=0; i<nn; i++){ cout<<"学号: "<<v[i].num<<" 姓名: "<<v[i].name<<" "<<"分数: "<<v[i].score<<endl;}}/*插入*/void sq_LList ::ins_sq_LList(int i, STUDENT b){ int k;if(nn==mm){cout<<"overflow"; return ;}if(i>nn) i=nn+1;if(i<1) i=1;for(k=nn; k>=i; k--)v[k]=v[k-1];v[i-1]=b; nn=nn+1;}/*删除*/void sq_LList ::del_sq_LList(int i){ int k;if(nn==0){cout<<"underflow"<<endl; return ;}if((i<1)||(i>nn)){cout<<"Not this element in the list!"<<endl; return ;}for(k=i; k<nn; k++)v[k-1]=v[k];nn=nn-1;}/*按学号查找*/void sq_LList ::sea_num_sq_LList(int i){ int k,t ;____t=0;for(i=0;i<nn;i++){ if(v[i].num==k){ t=t+1;cout<<"学号: "<<v[i].num<<" 姓名: "<<v[i].name<<" "<<"分数: "<<v[i].score<<endl;}}if(t==0)cout<<"No this student in the list!"<<endl;}/*按姓名查找*/void sq_LList ::sea_name_sq_LList(int i, char y[]){ int t;____t=0;for(i=0;i<nn;i++){ if(strcmp(y,v[i].name)=0){t=t+1cout<<"学号: "<<v[i].num<<" 姓名: "<<v[i].name<<" "<<"分数: "<<v[i].score<<endl;}}if(t==0) cout<<"No this student in the list!"<<endl }/*计算*/void sq_LList ::cal_sq_LList(int m){ int i;float sum,avr;{ sum=0;for(i=0;i<nn;i++){sum=sum+v[i].score;avr=sum/(i+1);}}cout<<"总分:"<<sum<<endl;cout<<"平均分:"<<avr<<endl;}int main(){ int mx; sq_LList s1(100);while (1){ cout<<"1.输出 2.插入 3.删除 4.查找 5.计算 0.退出\n";cout<<"输入0-5:";cin>>mx;switch(mx){ case 1: s1.prt_sq_LList(); break;case 2: int i; STUDENT b;cout<<"输入插入点位置和插入元素值:";cin>>i>>b.num>>>>b.score;s1.ins_sq_LList(i,b); s1.prt_sq_LList(); break; case 3: cout<<"请输入删除学生的位置:";cin>>i;s1.del_sq_LList(i);s1.prt_sq_LList(); break; case 4: int main(){ int mx;while (1){cout<<"1.按学号查找 2.按姓名查找 0.返"<<endl;cout<<"输入0-2:";cin>>mx;switch (mx){casecout<<"请输入要查找学生的学号:";s1.sea_num_sq_LList(i); break;casecout<<"请输入要查找学生的姓名:";s1.sea_name_sq_LList(); break;case 0: cout<<"返回"<<endl; return ;}}return 0;} break;case 5: s1.cal_sq_LList(); break;case 0: cout<<"程序结束"<<endl; return 0;}}return 0;2、正确程序:#include <iostream>using namespace std;typedef struct{ long double num; char name[10]; int score; } STUDENT; class sq_LList{ private:int mm;int nn;STUDENT *v;public:sq_LList(int);void prt_sq_LList();void ins_sq_LList(int, STUDENT);void del_sq_LList(int);void sea_num_sq_LList(int);void sea_name_sq_LList();void cal_sq_LList(int);/*输出*/sq_LList ::sq_LList(int m){ mm=m;v=new STUDENT [mm];v[0].num=970156; strcpy(v[0].name,"张小明"); v[0].score=87; v[1].num=970157; strcpy(v[1].name,"李小青"); v[1].score=96;v[2].num=970158; strcpy(v[2].name,"刘华");v[2].score=85; v[3].num=970159; strcpy(v[3].name,"王伟");v[3].score=93; v[4].num=970160; strcpy(v[4].name,"李启明"); v[4].score=88;nn=5;}void sq_LList ::prt_sq_LList(){ int i;for(i=0; i<nn; i++){ cout<<"学号: "<<v[i].num<<" 姓名: "<<v[i].name<<" "<<"分数: "<<v[i].score<<endl;}}/*插入*/void sq_LList ::ins_sq_LList(int i, STUDENT b){ int k;if(nn==mm){cout<<"overflow"; return ;}if(i>nn) i=nn+1;if(i<1) i=1;for(k=nn; k>=i; k--)v[k]=v[k-1];v[i-1]=b; nn=nn+1;}/*删除*/void sq_LList ::del_sq_LList(int i){ int k;if(nn==0){cout<<"underflow"<<endl; return ;}if((i<1)||(i>nn)){cout<<"Not this element in the list!"<<endl; return ;}for(k=i; k<nn; k++)v[k-1]=v[k];nn=nn-1;}/*按学号查找*/void sq_LList ::sea_num_sq_LList(int i){ int k,t ;cin>>k;t=0;for(i=0;i<nn;i++){ if(v[i].num==k){ t=t+1;cout<<"学号: "<<v[i].num<<" 姓名: "<<v[i].name<<" "<<"分数: "<<v[i].score<<endl;}}if(t==0)cout<<"No this student in the list!"<<endl;}/*按姓名查找*/void sq_LList ::sea_name_sq_LList(){ char y[10]; int i,t;cin>>y;t=0;for(i=0;i<nn;i++){ if(strcmp(y,v[i].name)==0){t=t+1;cout<<"学号: "<<v[i].num<<" 姓名: "<<v[i].name<<" "<<"分数: "<<v[i].score<<endl;}}if(t==0) cout<<"No this student in the list!"<<endl; }/*计算*/void sq_LList ::cal_sq_LList(int m){ int i;float sum,avr;{ sum=0;for(i=0;i<nn;i++){sum=sum+v[i].score;avr=sum/(i+1);}}cout<<"总分:"<<sum<<endl;cout<<"平均分:"<<avr<<endl;}int main(){ int mx; sq_LList s1(100);while (1){ cout<<"1.输出 2.插入 3.删除 4.查找 5.计算 0.退出\n";cout<<"输入0-5:";cin>>mx;switch(mx){ case 1: s1.prt_sq_LList(); break;case 2: int i; STUDENT b;cout<<"输入插入点位置和插入元素值:";cin>>i>>b.num>>>>b.score;s1.ins_sq_LList(i,b); s1.prt_sq_LList(); break; case 3: cout<<"请输入删除学生的位置:";cin>>i;s1.del_sq_LList(i);s1.prt_sq_LList(); break; case 4:{ int mx;while (1){cout<<"1.按学号查找 2.按姓名查找 0.返"<<endl;cout<<"输入0-2:";cin>>mx;switch (mx){case 1: cout<<"请输入要查找学生的学号:";s1.sea_num_sq_LList(i); break;case 2: cout<<"请输入要查找学生的姓名:";s1.sea_name_sq_LList(); break;case 0: cout<<"返回"<<endl; return 0;}}return 0;} break;case 5: s1.cal_sq_LList(i); break;case 0: cout<<"程序结束"<<endl; return 0;}}return 0;}四、实验总结通过此次试验,我对线性表(顺序存储)有了全面的认识,知道了什么是线性表,以及线性表有什么作用;并学会了如何根据要求建立一个实际的线性表,包括线性表的输出、插入、删除、查。
(完整版)数据结构线性表的应用实验报告
实验报告课程名称____数据结构上机实验__________ 实验项目______线性表的应用 ____________实验仪器________PC机___________________系别_____电子信息与通信学院___专业________ ___班级/学号______ __学生姓名______ ___________实验日期_______________________成绩_______________________指导教师_______________________实验一.线性表的应用1.实验目的:掌握线性链表的存储、运算及应用。
利用链表实现一元多项式计算。
2.实验内容:1)编写函数,实现用链表结构建立多项式;2)编写函数,实现多项式的加法运算;3)编写函数,实现多项式的显示;4)测试:编写主函数,它定义并建立两个多项式,显示两个多项式,然后将它们相加并显示结果。
变换测试用的多项式,检查程序的执行结果。
选做内容:修改程序,选择实现以下功能:5)多项式求值:编写一个函数,根据给定的x值计算并返回多项式f(x)的值。
测试该函数(从终端输入一个x的值,调用该函数并显示返回结果)。
6)多项式相减:编写一个函数,求两个多项式相减的多项式。
7)多项式相乘:编写一个函数,求两个多项式的乘积多项式。
3.算法说明:1)多项式的建立、显示和相加算法见讲义。
可修改显示函数,使输出的多项式更符合表达规范。
2)多项式减法:同次项的系数相减(缺项的系数是0)。
例如a(x)=-5x2+2x+3,b(x)= -4x3+3x,则a(x)-b(x)=4x3-5x2-x+3。
提示:a(x)-b(x) = a(x)+(-b(x))。
3)多项式乘法:两个多项式的相乘是“系数相乘,指数相加”。
算法思想是用一个多项式中的各项分别与另一个多项式相乘,形成多个多项式,再将它们累加在一起。
例如,a(x)=-5x2+2x+3,b(x)=-4x3+3x,则a(x)*b(x) = (-4x3)*(-5x2+2x+3)+(3x)*(-5x2+2x+3)= (20x5-8x4-12x3) + (-15x3+6x2+9x) =20x5-8x4-27x3+6x2+9x。
线性表及其实现(实验二)
实验二线性表及其实现一.实验目的及要求(1)熟悉线性表的基本运算在两种存储结构(顺序结构和链式结构)上的实现,以线性表的各种操作(建立、插入、删除等)的实现为实验重点;(2)通过本次实验帮助学生加深对顺序表、链表的理解,并加以应用;(3)掌握循环链表和双链表的定义和构造方法二.实验内容:(1)编程实现线性表两种存储结构(顺序存储、链式存储)中的基本操作的实现(线性表的创建、插入、删除和查找等),并设计一个菜单调用线性表的基本操作。
(2)建立一个按元素递增有序的单链表L,并编写程序实现:a)将x插入其中后仍保持L的有序性;b)将数据值介于min和max之间的结点删除,并保持L的有序性;c)将单链表L逆置并输出;(3)编程实现将两个按元素递增有序的单链表合并为一个新的按元素递增的单链表。
三.实验主要流程、基本操作或核心代码、算法片段(该部分如不够填写,请另加附页)(1)编程实现线性表两种存储结构(顺序存储、链式存储)中的基本操作的实现(线性表的创建、插入、删除和查找等),并设计一个菜单调用线性表的基本操作。
➢程序代码:顺序存储:头文件:#define INIT_SIZE 100#define INCREMENT 10#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef int ElemType;typedef struct{ElemType *elem;int length;int listsize;}Sq;Status Init_Sq(Sq &L);Status Insert_Sq(Sq &L,int i,ElemType e);Status Delete_Sq(Sq &L,int i,ElemType &e);主函数:#include"stdio.h"#include"1.h"#include"stdlib.h"int main(){Sq L;printf("是否建立顺序表?\n");printf("1、建立\n");printf("2、退出程序\n");int a;//选择是否建立scanf("%d",&a);switch(a){case 1:Init_Sq(L);break;case 2:printf("程序结束!\n");exit(OVERFLOW);default:printf("输入错误!\n");}printf("请输入要放入顺序表中的元素个数(不要超过100)\n");scanf("%d",&L.length);int i;//进行用户输入循环printf("请输入具体元素\n");for(i=0;i<L.length;i++){scanf("%d",&L.elem[i]);}int b;//选择操作do{printf("请选择下列操作\n");printf("1、向表中添加元素\n");printf("2、删除表中某一元素\n");printf("3、退出程序\n");scanf("%d",&b);switch(b){case 1:ElemType x;//新元素int c;//新元素位置printf("请输入要添加的元素,和添加的位置(空格隔开)\n");scanf("%d%d",&x,&c);Insert_Sq(L,c,x);int j;//新表输出循环printf("新表为:\n");for(j=0;j<L.length;j++){printf("%d ",L.elem[j]);}printf("\n");break;case 2:int d;//需要删除元素的位置ElemType y;//被删除的元素printf("请输入删除元素的位置\n");scanf("%d",&d);Delete_Sq(L,d,y);printf("被删除的元素是%d\n",y);printf("剩下的元素为:\n");int f;//输出循环for(f=0;f<L.length;f++){printf("%d ",*(L.elem+f));}printf("\n");break;case 3:printf("程序结束!\n");exit(OVERFLOW);default:printf("输入出错!\n");}}while(b!=3);return 0;}功能函数:#include"stdio.h"#include"stdlib.h"#include"1.h"Status Init_Sq(Sq &L){L.elem=(ElemType *)malloc(INIT_SIZE*sizeof(ElemType));if(!L.elem) exit(OVERFLOW);L.length=0;L.listsize=INIT_SIZE;return OK;}Status Insert_Sq(Sq &L,int i,ElemType e){if(L.length==100){int *newpase;newpase=(ElemType *)realloc(L.elem,(L.length+INCREMENT)*sizeof(ElemType));if(!newpase) exit(OVERFLOW);L.elem=newpase;L.listsize+=INCREMENT;}if(i<1||i>L.length+1){return ERROR;}L.length+=1;int b=L.length;//用于循环while(i<=b){L.elem[b]=L.elem[b-1];b--;}L.elem[i-1]=e;return OK;}Status Delete_Sq(Sq &L,int i,ElemType &e){if(i<1||i>L.length+1){return ERROR;}e=L.elem[i-1];int j;for(j=i-1;j<L.length-1;j++){L.elem[j]=L.elem[j+1];}L.length-=1;return OK;}链式存储:头文件:#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef int ElemType;typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkList;void Create_L(int n,LinkList &L);Status Insert_L(LinkList &L,int i,ElemType e); Status Delete_L(LinkList &L,int i,ElemType &e); Status GetElem_L(LinkList L,int i,ElemType &e);主函数:#include"stdio.h"#include"1.h"int main(){printf("是否建立链表\n");int a;//选择printf("1、建立\n");printf("2、退出程序\n");scanf("%d",&a);switch(a){case 1:LinkList L;printf("请输入链表长度(不计算头结点)\n");int n;//数据容纳度scanf("%d",&n);Create_L(n,L);int b;//选择功能printf("请选择以下功能:\n");do{printf("1、查找某位置元素\n");printf("2、在某位置插入元素\n");printf("3、删除某位置元素\n");printf("4、结束程序\n");scanf("%d",&b);switch(b){case 1:{printf("请输入查找位置\n");int c;//查找位置ElemType d;//数据容器scanf("%d",&c);if(c>n){printf("该位置大于数据个数,请重新选择\n");break;}GetElem_L(L,c,d);printf("第%d个数据为:%d\n",c,d);break;}case 2:{printf("请输入在什么位置插入什么数据(空格隔开)\n");int f,g;//位置、数据scanf("%d %d",&f,&g);Insert_L(L,f,g);printf("此时的数据为:\n");int h;n=n+1;LinkList l=L;for(h=0;h<n;h++){printf("%d ",l->next->data);l=l->next;}printf("\n");break;}case 3:{printf("请输入需要删除的位置\n");int m;ElemType o;scanf("%d",&m);Delete_L(L,m,o);n=n-1;printf("此时的数据还有:\n");int q;LinkList r=L;for(q=0;q<n;q++){printf("%d ",r->next->data);r=r->next;}printf("\n");break;}case 4:printf("程序结束\n");break;default:printf("输入出错\n");}}while(b!=4);break;case 2:printf("程序退出\n");break;default:printf("输入错误\n");}}#include"1.h"#include"stdio.h"#include"stdlib.h"void Create_L(int n,LinkList &L){L=(LinkList)malloc(sizeof(LNode));L->next=NULL;printf("请逆序输入相应个数的数据\n");int i;//用于循环LinkList p;for(i=n;i>0;i--){p=(LinkList)malloc(sizeof(LNode));scanf("%d",&p->data);p->next=L->next;L->next=p;}}Status GetElem_L(LinkList L,int i,ElemType &e) {int j;//用于循环LinkList p=L;if(p){for(j=0;j<i;j++){p=p->next;}e=p->data;}return OK;}Status Insert_L(LinkList &L,int i,ElemType e) {LinkList p;p=L;int j=0;while(p&&j<i-1){p=p->next;}if(!p||j>i-1)return ERROR;LinkList s;s=(LinkList) malloc (sizeof(LNode));s->data=e;s->next=p->next;p->next=s;return OK;}Status Delete_L(LinkList &L,int i,ElemType &e) {LinkList p=L;int j=0;while(p->next&&j<i-1){p=p->next;j++;}if(!(p->next)||j>i-1)return ERROR;LinkList q;q=p->next;p->next=q->next;e=q->data;printf("被删除的元素为:%d\n",e);free(q);return OK;}➢运行结果:(2)建立一个按元素递增有序的单链表L,并编写程序实现:a)将x插入其中后仍保持L的有序性;b)将数据值介于min和max之间的结点删除,并保持L 的有序性;c)将单链表L逆置并输出;程序代码部分:头文件:#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0#define OVERFLOW -1#define INFEASIBLE -2typedef int ElemType;typedef int Status;typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkList;Status Create(LinkList &L,int n);Status Insert(LinkList &L,ElemType e,int n);Status Delete(LinkList &L,int min,int max,int &n);Status Reverse(LinkList L,int n);主函数:#include"stdio.h"#include"1.h"int main(){printf("是否建立单链表?\n");printf("1、建立\n");printf("2、不建立并结束程序\n");int a;//判断是否建立链表scanf("%d",&a);switch(a){case 1:{LinkList L,p;printf("请确定单链表的节点个数\n");int node_num;//节点个数scanf("%d",&node_num);Create(L,node_num);p=L;printf("现在的单链表为:\n");for(int i=0;i<node_num;i++){p=p->next;printf("%d ",p->data);}printf("\n");printf("请选择下列操作\n");int b;//选择操作do{printf("1、插入一个元素\n");printf("2、删除某个范围内的元素(不删除上下限)\n");printf("3、逆置单链表中的元素\n");printf("4、结束程序\n");scanf("%d",&b);switch(b){case 1:{int insert;//插入的元素printf("请输入要插入的元素\n");scanf("%d",&insert);Insert(L,insert,node_num);LinkList p=L;printf("此时单链表中的元素为:\n");for(int i=0;i<node_num+1;i++){printf("%d ",p->next->data);p=p->next;}printf("\n");}node_num+=1;break;case 2:{printf("请输入删除范围的上下限(空格隔开)\n");int min,max;scanf("%d %d",&min,&max);printf("被删除的元素有:\n");Delete(L,min,max,node_num);printf("此时的单链表元素有:\n");LinkList p=L;for(int i=0;i<node_num;i++){printf("%d ",p->next->data);p=p->next;}printf("\n");}break;case 3:{Reverse(L,node_num);}break;case 4:printf("程序结束!\n");break;default:printf("输入错误!\n");}}while(b!=4);}break;case 2:printf("程序结束!\n");break;default: printf("输入错误!\n");}}功能函数:#include"stdio.h"#include"stdlib.h"#include"1.h"//顺序输入N个元素建立单链表与书上30页的2.10是不同的方法Status Create(LinkList &L,int n){L=(LinkList) malloc (sizeof(LNode));if(!L) exit(OVERFLOW);L->next=NULL;LinkList q=L;printf("请输入具体元素\n");for(int i=0;i<n;i++){LinkList p=(LinkList) malloc (sizeof(LNode));scanf("%d",&p->data);//与30页不同之处q->next=p;p->next=NULL;q=q->next;}return OK;}Status Insert(LinkList &L,ElemType e,int n){LinkList p;p=L;LinkList s=(LinkList) malloc (sizeof(LNode));if(!s) exit(OVERFLOW);s->data=e;for(int i=0;i<n;i++){if(e<=p->next->data){s->next=p->next;p->next=s;break;}p=p->next;}if(p->next==NULL){p->next=s;s->next=NULL;}return OK;}Status Delete(LinkList &L,int min,int max,int &n){ElemType e;//显示被删除的元素int a=n;//判别n是否变化LinkList p=L;for(int i=0;i<a;i++){if(p->next!=NULL){if(min<p->next->data&&max>p->next->data){n--;LinkList q;q=p->next;p->next=q->next;e=q->data;printf("%d ",e);free(q);}else if(p->next->data>=max)break;//如果一个元素大于等于max,说明后面的元素一定大于等于max,就没必要进行比较了}p=p->next;}if(n==a)//说明元素没变化,是min大于等于所有元素(或者max小于等于所有元素)造成的结果{printf("单链表在该范围内没有元素\n");return ERROR;}printf("\n");return OK;}Status Reverse(LinkList L,int n){LinkList w,p,q=L;//用于承载逆置的单链表q=q->next;w=(LinkList) malloc (sizeof(LNode));w->next=NULL;for(int i=n;i>0;i--){p=(LinkList) malloc (sizeof(LNode));p->data=q->data;q=q->next;p->next=w->next;w->next=p;}printf("逆置后的单链表中元素为:\n"); LinkList y;y=w;for(int j=0;j<n;j++){y=y->next;printf("%d ",y->data);}printf("\n");return OK;}➢运行结果:(3)编程实现将两个按元素递增有序的单链表合并为一个新的按元素递增的单链表。
LAB02 线性表的操作与应用
Lab02.线性表的操作与应用【实验目的和要求】1.掌握线性表的顺序表示和链表表示下的基本运算;2.能设计恰当的线性表解决具体问题。
【实验内容】1.创建顺序表示的线性表palist(线性表中的结点为整数),然后,1) 写一个插入算法,在palist所指顺序表中,下标为p的元素之后插入一个值为x的元素,返回插入成功与否的标志。
2) 写一个删除算法, 在palist所指顺序表中,删除第一个值为x的元素,删除成功,返回所删除元素的下标,否则返回-1。
3) 写一个置逆算法, 求palist所指顺序表的逆线性表,逆线性表仍占用原线性表的空间。
4) 写一个排序算法,将palist所指顺序表的元素按从小到大的顺序排序。
2.创建一个带头结点的单链表llist(每结点数据域仅有一个整数),然后,1) 写一个插入算法,在llist中,p所指结点前面插入值为x的新结点,返回插入成功与否的标志。
2) 写一个删除算法, 在llist中,删除下标为i的(第i+1个)结点,并返回删除成功与否的标志。
3) 编写一个算法,删除单链表中值相同的多余结点,即若链表中有多个结点具有相的数据域值,只保留其中的一个结点,其余结点均从链表中删去,使得最后得到的链表中的所有结点的数据域都不相同。
3. 设计一种用单链表存储多项式的结构(每个结点存储一项的系数和指数,类型都为int),并编写一个产生多项式链表的函数和实现两个多项式相加和相乘的函数。
4.将本章介绍的两种Josephus问题的求解过程在计算中实现,实现时要求输出的不是整数,而是实际的人名。
【实验仪器与软件】1.CPU主频在1GHz以上,内存在512Mb以上的PC;2.VC6.0,Word 2003及以上版本。
实验讲评:实验成绩:评阅教师:2012 年月日Lab02.线性表的操作与应用一、顺序表示的线性表的基本操作1.创建顺序表示的线性表palist:#include <stdio.h>#include <stdlib.h>#include <iostream.h>#define ListSize 100 //表空间大小可根据实际需要而定,这里假设为 100 typedef int DataType; //DataType 可以是任何相应的数据类型如 int, float 或 chartypedef struct //顺序表的定义{ DataType data[ListSize];//数组 data 用于存放表结点int length;//当前的表长度}SeqList;PSeqList createNullList_seq(int m){PSeqList palist =(PSeqList)malloc(sizeof(struct Seqlist));if (palist!=Null){palist ->element=(DataType*)malloc(sizeof(DataType)*m);if (palist->element){palist->MAXNUM=m;palist->n=0; //空表长度为0return palist;}else free(palist);}printf("Out of spase!!\n"); //储存分配失败return NNLL;}1) 写一个插入算法,在palist所指顺序表中,下标为p的元素之后插入一个值为x的元素,返回插入成功与否的标志:int insertPost_seq(PseqList palist, int p, DataType x) {/* 在palist 所指顺序表中下标为p 的元素之后插入元素x */int q;if ( palist->n >= palist-> MAXNUM ) { /* 溢出*/printf("Overflow!\n");return 0;}if (p<0 || p>palist->n-1 ) { /* 不存在下标为p 的元素*/printf("Not exist! \n");return 0;}for(q=palist->n - 1;q>=p+1; q--) /* 插入位置及之后的元素均后移一个位置/*palist->element[q+1] = palist->element[q];palist->element[p+1] = x; /* 插入元素x */palist->n = palist->n + 1; /* 元素个数加1 */return 1;}2) 写一个删除算法, 在palist所指顺序表中,删除第一个值为x的元素,删除成功,返回所删除元素的下标,否则返回-1:int deleteV_seq(PseqList palist, p, DataType x ) {/* 在palist 所指顺序表中删除值为x 的元素*/int p,q;for(p=0;p<n;p++) /*查找值为x 的元素的下标*/if(x==palist->element[p]){for(q=p; q<palist->n-1; q++) /* 被删除元素之后的元素均前移一个位置*/palist->element[q] = palist->element[q+1];palist->n = palist->n - 1;return 1 ; /* 元素个数减1 */}return 0;}3) 写一个置逆算法, 求palist所指顺序表的逆线性表,逆线性表仍占用原线性表的空间。
数据结构实验二 线性表
数据结构实验二线性表数据结构实验二线性表一、实验目的本实验旨在帮助学生掌握线性表的基本概念、构造和基本操作,以及通过实际编程实现线性表的功能。
二、实验内容本实验包括以下几个部分:⑴线性表的定义和基本概念介绍线性表的定义,以及线性表中的元素、长度等基本概念。
⑵线性表的顺序存储结构介绍线性表的顺序存储结构的原理和实现方式,包括顺序表的定义、顺序表的初始化、插入和删除等操作。
⑶线性表的链式存储结构介绍线性表的链式存储结构的原理和实现方式,包括链表的定义、链表的插入和删除等操作。
⑷线性表的应用介绍线性表的应用场景和实际应用,如多项式的表示和运算等。
三、实验步骤⑴实验准备准备实验所需的编程环境和开发工具,如C语言编译器、集成开发环境等。
⑵实验设计根据实验要求和目标,设计实现线性表的相关功能,包括定义线性表、初始化线性表、插入和删除元素等。
⑶编码实现根据实验设计,编写程序代码实现线性表的功能。
⑷调试测试对编写的程序进行调试和测试,确保程序的正确性和可靠性。
⑸实验总结总结实验过程中遇到的问题和解决方案,对实验结果进行分析和评价。
四、实验注意事项⑴遵守实验守则在进行实验过程中,要遵守实验守则,注意安全和人身财产的保护。
⑵注意程序的健壮性在编写程序时,要考虑到各种异常情况的处理,保证程序的健壮性。
⑶注意代码的可读性和可维护性编写代码时,要注意代码的可读性和可维护性,使其易于阅读和修改。
⑷注意实验文档的完整性实验报告应包含所有实验内容的详细说明和实验过程的总结分析。
附件:本文档无附件。
法律名词及注释:本文档不涉及法律名词及注释。
数据结构实验线性表及其应用
数据结构实验线性表及其应用在计算机科学的领域中,数据结构是一门极其重要的基础学科,它为我们有效地组织和管理数据提供了理论和方法。
而线性表作为一种常见且基础的数据结构,在实际的程序设计和算法应用中有着广泛的应用。
线性表是一种最基本的数据结构,它是由零个或多个数据元素组成的有限序列。
在这个序列中,每个元素都有其特定的位置和值。
从存储结构上来看,线性表可以分为顺序存储和链式存储两种方式。
顺序存储的线性表,就像是一排紧密排列的格子,每个格子里存放着一个数据元素。
这种存储方式的优点是可以随机访问表中的任意元素,时间复杂度为 O(1)。
比如说,如果我们要获取顺序表中第 5 个元素的值,只需要通过简单的计算就能直接找到对应的位置并获取其值。
然而,顺序存储也有它的不足之处。
当需要插入或删除元素时,可能需要移动大量的元素,以保持数据的连续性,这会导致时间复杂度较高,为 O(n)。
相比之下,链式存储的线性表则更加灵活。
它就像是一串珍珠项链,每个珍珠(数据元素)通过一根线(指针)与下一个珍珠相连。
在链式存储中,插入和删除元素相对较为方便,只需要修改相关指针的指向即可,时间复杂度通常为 O(1)。
但是,由于无法直接通过计算得到某个元素的位置,所以随机访问的效率较低,时间复杂度为 O(n)。
在实际应用中,线性表有着多种多样的用途。
比如,我们可以用线性表来实现一个学生成绩管理系统。
将每个学生的成绩作为一个元素存储在线性表中,可以按照学号或者成绩进行排序。
当有新的学生成绩需要添加时,根据具体的存储方式选择合适的插入操作;当需要删除某个学生的成绩时,也能快速准确地进行删除。
再比如,在一个购物网站的商品列表中,也可以使用线性表来存储商品的信息。
用户可以按照价格、销量、评价等因素对商品进行排序和筛选。
而网站后台在处理商品的上下架、库存管理等操作时,也会频繁地对线性表进行插入、删除和修改等操作。
此外,在文本编辑软件中,我们输入的文字也可以看作是一个线性表。
“线性表及其应用”实验报告
序号73 学号2013112000 姓名张三实验 2 实验名称线性表及其应用难度等级B+一、需求分析1、问题描述设计一个一元稀疏多项式简单计算器.2、基本要求一元稀疏多项式基本功能包括:1)输入并建立多项式⏹一元n次多项式:P n(x)=c m错误!未找到引用源。
+c m-1错误!未找到引用源。
+…+c1错误!未找到引用源。
,其中n=e m>e m-1>…>e1≥0,c i≠0(i=1,2,m)⏹输入(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.⽤顺序表和链表分别分别编程实现教材中例⼦2-1与2-2。
要求:(1)只能⽤C语⾔编程实现;(2)完全保持书中算法2.1与算法2.2形式,不允许有任何变化,除⾮语法上不允许;所调⽤各函数参照书中19页的功能描述,其中函数名、参数个数及性质、函数功能必须与书中完全⼀致,不能有变化。
2.利⽤线性表表⽰⼀元多项式完成多项式的加、减、乘、求导、求值运算。
要求:(1)输⼊的⼀元多项式可以采⽤只输⼊各项的系数与指数这种简化的⽅式。
如对于多项式2x2+6x5,输⼊可为: 2,2 6,5 这样的简单形式。
(2)遇到有消项时应当处理,如2x2+6x5与3x2-6x5进⾏相加时,结果为5*x^2。
(3)当给定x的值时,能计算表达式相加或相减的结果。
(4)操作的结果放⼊⼀个新线性表中,原来的两个表达式存储表⽰不变,也可以不是产⽣新的线性表,⽽是将两上线性表合并为⼀个。
(5)要求程序功能模块划分合理(每个函数功能单⼀、可重⽤性好),使⽤空间尽可能少,算法尽可能⾼效。
实验报告1.实现功能描述使⽤线性表表⽰⼀元多项式完成多项式的加、减,乘,求导、求值运算。
2.⽅案⽐较与选择(1)因为使⽤的是线性表,所以主要⽅案有数组法和链表法。
(2)从时间复杂度来说,使⽤数组法更优;从空间复杂度来说,链表法更优。
因为数组法是指定好空间的,若式⼦⼤⼩超出设置⼤⼩,那程序必然出错;若式⼦⼤⼩⼩于设置⼤⼩,那就意味着有多余的空间被浪费了。
综合来讲,若计算式⼦较为庞⼤,使⽤链表法更佳;相反,若计算式⼦较⼩,数组法更佳。
3.设计算法描述(1)单个项式的数据存储使⽤了结构体,数组法是在⼀个结构体中定义两个⼀维数组;链表法是通过⼀个结构体作为⼀个节点,通过next指针连接起来。
数据结构课程实验报告
数据结构课程实验报告数据结构课程实验报告引言:数据结构是计算机科学中非常重要的一门课程,它研究了数据的组织、存储和管理方法。
在数据结构课程中,我们学习了各种数据结构的原理和应用,并通过实验来加深对这些概念的理解。
本文将对我在数据结构课程中的实验进行总结和分析。
实验一:线性表的实现与应用在这个实验中,我们学习了线性表这种基本的数据结构,并实现了线性表的顺序存储和链式存储两种方式。
通过实验,我深刻理解了线性表的插入、删除和查找等操作的实现原理,并掌握了如何根据具体应用场景选择合适的存储方式。
实验二:栈和队列的实现与应用栈和队列是两种常见的数据结构,它们分别具有后进先出和先进先出的特点。
在这个实验中,我们通过实现栈和队列的操作,加深了对它们的理解。
同时,我们还学习了如何利用栈和队列解决实际问题,比如迷宫求解和中缀表达式转后缀表达式等。
实验三:树的实现与应用树是一种重要的非线性数据结构,它具有层次结构和递归定义的特点。
在这个实验中,我们学习了二叉树和二叉搜索树的实现和应用。
通过实验,我掌握了二叉树的遍历方法,了解了二叉搜索树的特性,并学会了如何利用二叉搜索树实现排序算法。
实验四:图的实现与应用图是一种复杂的非线性数据结构,它由节点和边组成,用于表示事物之间的关系。
在这个实验中,我们学习了图的邻接矩阵和邻接表两种存储方式,并实现了图的深度优先搜索和广度优先搜索算法。
通过实验,我深入理解了图的遍历方法和最短路径算法,并学会了如何利用图解决实际问题,比如社交网络分析和地图导航等。
实验五:排序算法的实现与比较排序算法是数据结构中非常重要的一部分,它用于将一组无序的数据按照某种规则进行排列。
在这个实验中,我们实现了常见的排序算法,比如冒泡排序、插入排序、选择排序和快速排序等,并通过实验比较了它们的性能差异。
通过实验,我深入理解了排序算法的原理和实现细节,并了解了如何根据具体情况选择合适的排序算法。
结论:通过这些实验,我对数据结构的原理和应用有了更深入的理解。
线性表及其应用实验报告
数据结构实验报告实验名称:线性表及其应用班级:12级电气本2学号:2012081227姓名:赵雪磊指导教师:梁海丽日期:2013年9月9日数学与信息技术学院一、实验目的1、掌握线性表的概念,理解线性表的顺序、链式存储。
2、掌握线性表的基本操作,插入、删除、查找,以及线性表合并等运算在顺序存储结构和链接存储结构上的运算。
二、实验要求1、建立顺序存储的线性表,并对之进行插入、删除操作。
2、建立链式存储的线性表,并对之进行插入、删除操作。
;三、算法描述#include <cstdlib>#include <iostream>#include "myList.h"using namespace std;template <class T> class Link {public:T data; // 用于保存结点元素的内容Link * next; // 指向后继结点的指针Link(const T info, Link* nextValue = NULL) { // 具有两个参数的Link构造函数data = info;next = nextValue;}Link(Link* nextValue = NULL) { // 具有一个参数的Link构造函数next = nextValue;}}// 【代码2.7】单链表的类型定义template <class T>class lnkList : public List<T> {protected:Link<T>* head, tail; // 单链表的头、尾指针public:lnkList(); // 构造函数~lnkList(); // 析构函数bool isEmpty(); // 判断链表是否为空void clear(); // 将链表存储的内容清除,成为空表int length(); // 返回此顺序表的当前实际长度bool append(T value); // 在表尾添加一个元素value,表的长度增1 bool insert(int p, T value); // 在位置p上插入一个元素value,表的长度增1 bool delete(int p); // 删除位置p上的元素,表的长度减 1int getPos(const T value); // 查找值为value的元素,并返回第1次出现的位置Link<T> setPos(int p); // 返回线性表指向第p个元素的指针值}template <class T>class lnkList:: lnkList() {head = tail = new Link<T>;}template <class T>class lnkList:: ~lnkList() {Link tmp;while (head != NULL) {tmp = head;head = head->next;delete tmp;}}template <class T> // 假定线性表的元素类型为TLink lnkList :: setPos(int i) {int count = 0;Link *p;if (i == -1) // i为-1则定位到"虚"头结点return head;p = head->next; // 若i为0则定位到第一个结点while (p != NULL && count < i) {p = p-> next;count++;};return p; // 指向第 i 结点,i=0,1,…,当链表中结点数小于i时返回NULL }template <class T> // 假定线性表的元素类型为Tbool lnkList :: insert (int i, T value) {Link *p, *q;q = new Link<T>;p = setPos(i-1); // p是第i个结点的前驱if (p == NULL ) {cout << " the inserted point is illegal"<<endl;return false;}q->next = p->next;q->data = value;p->next = q;if (q->next == NULL ) // 插入点在链尾,插入结点成为新的链尾tail = q;return true;}// delete a node from singly linked listtemplate <class T> // 假定线性表的元素类型为Tbool lnkList :: delete(int i) {Link *p, *q;p = setPos(i-1); // p是第i个结点的前驱if (p == NULL ) {cout << " the deletion point is illegal"<<endl;return false;}q = p->next; // q是真正待删结点if (q == tail) // 待删结点为尾结点,则修改尾指针tail = p;if (q != NULL) { // 删除结点q 并修改链指针p->next = q->next;delete q;}return true;}template <class T> // 假定顺序表的元素类型为Tvoid lnkList<T> :: print() {while (head != NULL) {cout << head->data;cout << endl; // 从位置p开始每个元素左移直到curLen, tmp = head;head = head->next;}}四、程序清单#include <iostream.h>#define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #defineOVERFLOW -2typedef int Status;typedef int ElemType;#define LIST_INIT_SIZE 10 #define LISTINCREMENT 2typedef struct shunxubiao{ ElemType *list;int size;int Maxsize; }SqList;int InitList_Sq(SqList &L) {// 构造一个空的线性表L。
实验二 线性表的应用
实验二线性表的应用
一、实验学时: 2学时
二、背景知识:
线性表的动态分配顺序存储结构:
#define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量
#define LISTINCREMENT 10 //线性表存储空间的分配增量
typedef struct{
ElemType *elem; //存储空间基址
int length; //当前长度
int listsize; //当前分配的存储容量(以sizeof(ElemType)为单位) } SqList;
链表的分类:带头结点的/不带头结点的(单链表、双向链表、循环链表等)
链表的基本操作:插入、删除及应用。
单链表的结点存储定义:
typedef struct LNode
{
ElemType data;
struct LNode *next;
}Lnode,*LinkList;
三、目的要求:
1.掌握顺序和链式存储结构的特点。
2.顺序表和链表在实际问题中的应用。
四、实验内容:
1.顺序表中元素的就地逆置。
2.顺序表中元素的奇偶对调:表中元素类型为整型,设计时间复杂度为O(n)的算法将其调整为左右两部分,左边所有元素为奇数,右边所有元素为偶数。
3.带头结点的单链表中元素的就地逆置。
4.利用带头结点的单链表实现一个班级学生信息管理(数据录入、插入、删除、排序、查找等)(提示:可以是任何一种链表形式)。
ds实验教案2
实验二:线性表基本运算及应用实验项目的和要求:1.掌握线性表的特点2.掌握线性表的顺序存储结构和链式存储结构的基本运算。
3.尽可能考虑算法的健壮性4.实验报告中要写出测试数据、错误分析以及收获。
实验项目名称一:实现两种存储结构的主要基本运算1.用结构体类型描述线性表的两种存储结构2.完成课堂上所讲的两种存储结构的基本运算3.要求用二级菜单实现****************************** 1-------顺序表 ** 2-------链表 ** 0-------退出 ******************************请输入的选择:(0-2):线性表的链式存储############################### 1----前插建立链表## 2----后插建立链表 ## 3----访问第i个元素 ## 4----插入 ## 5----删除 ## 6----求线性表的表长 ## 0----退出 ###############################请输入选择(0-6):实验项目名称2:超市密码存储箱系统的设计与实现问题描述:1.顾客使用箱子的流程为“投一元硬币”--------“找到一个空箱子,同时产生密码”(系统完成)--------“打印密码,打开箱子”(系统完成)--------“取密码并存包,并关闭箱子,入超市购物”--------“购物结束”--------“输入密码”--------“找到对应箱子并打开”(系统完成)--------“取包”。
2.现要求设计程序模拟以上系统完成的功能①界面:在我们的模拟系统中,箱子在屏幕上被画出来,并编号,空箱为蓝色,被使用时变成红色,再变为空后则恢复蓝色;②通过按“1”键模拟顾客投币;③当空箱子被顾客申请得到的同时,系统自动生成6位数密码,此密码不能与正在被使用的任何一个箱子的密码相同。
3.设计分析在设计时,可利用链表来组织所有的箱子,所有的箱子以结点的形式表示,结点中存放箱号、密码(满箱有,空箱无)以及指向下一个结点的指针。
实验二 线性表的应用
资料范本本资料为word版本,可以直接编辑和打印,感谢您的下载实验二线性表的应用地点:__________________时间:__________________说明:本资料适用于约定双方经过谈判,协商而共同承认,共同遵守的责任与义务,仅供参考,文档可直接下载或修改,不需要的部分可直接删除,使用时请详细阅读内容实验二线性表的应用(2学时)一、实验目的:掌握线性表的基本结构和操作方法,培养学生灵活使用结构解决实际问题的能力。
二、实验内容:设计一个100位以内的长整数加减运算的程序。
三、实验要求:1,输入输出要求:每四位一组,组间用逗号分隔;2,加和减分别用不同的程序实现3,程序应考虑输入数据的符号四、参考程序/*设计一个100位以内的长整数加减运算的程序。
实验要求:1,输入输出要求:每四位一组,组间用逗号分隔;2,程序应考虑输入数据的符号*/#include<stdio.h>#include<string.h>#include<stdlib.h>#include<conio.h>#include<malloc.h>#define LEN sizeof(struct student)struct student{int score;struct student *next;};int lenm,lenn,lensum;//m与n的长度void main(){struct student *creat(int *d,int *len);void print(struct student *head);struct student *add(struct student *m,struct student *n);struct student *sub(struct student *m,struct student *n);int compare(struct student *m,struct student *n);struct student *m,*n,*sum;int s1,s2,s3,k;char ch;printf("输入第一个数:\n");m=creat(&s1,&lenm);//输入第一个数放在链表m中,s1为其符号printf("\n选择运算,输入+或-:");scanf("%c",&ch);getchar();printf("\n输入第二个数:\n");n=creat(&s2,&lenn);//输入第一个数放在链表n中,s2为其符号k=compare(m,n);//k=1则m>n,k=-1则m<n,k=0则m=nif(ch=='+')//加法运算{if(s1*s2>0){s3=s1;sum=add(m,n);}else {if(s1>0&&k==1) {s3=1;sum=sub(m,n);}//m>0,n<0,m>|n|,m+n=m-|n|if(s1>0&&k==-1){s3=-1;sum=sub(n,m);}//m>0,n<0,m<|n|,m+n=-(|n|-m) if(s1<0&&k==1){s3=-1;sum=sub(m,n);}//m<0,n>0,|m|>|n|,m+n=-(|m|-n)if(s1<0&&k==-1){s3=1;sum=sub(n,m);}//m<0,n>0,|m|<|n|,m+n=n-|m| if(k==0) s3=0;}}//endif+if(ch=='-')//减法运算{if(s1*s2<0) {s3=s1;sum=add(m,n);}else{if(s1>0&&k==1) {s3=1;sum=sub(m,n);}//m>0,n>0,m>n,m-n=m-nif(s1>0&&k==-1){s3=-1;sum=sub(n,m);}//m>0,n>0,m<n,m-n=-(n-m)if(s1<0&&k==1){s3=-1;sum=sub(m,n);}//m<0,n<0,|m|>|n|,m-n=-(|m|-|n|)if(s1<0&&k==-1){s3=1;sum=sub(n,m);}//m<0,n<0,|m|<|n|,m-n=|n|-|m| if(k==0) s3=0;}}//endif-if(s3>0) {printf("结果为:+");print(sum);}if(s3<0) {printf("结果为:-");print(sum);}if(s3==0) printf("结果为:0");}//endmainstruct student *creat(int *sign,int *n)//输入数据并建立链表首结点存放最低4位数据{void print(struct student *head);struct student *p1,*p2;int i=0,j,k=0,len;char s[5],c[130];*sign=1;gets(c);if(c[0]=='-'){i=1;*sign=-1;}p1=p2=(struct student *)malloc(LEN);//建立尾结点p1->score=0;p1->next=NULL;len=strlen(c);for(;i<len;i++){j=0;while(c[i]>='0'&&c[i]<='9')//取出逗号之间的每一组数存放到字符数组s中{s[j++]=c[i++];k++;}s[j]='\0';p1=(struct student *)malloc(LEN);p1->score=atoi(s);//将s转换成整数p1->next=p2;//插入到链表头p2=p1;}*n=k;return(p1);struct student *add(struct student *m,struct student *n)//加法运算{struct student *p1,*p2,*head;//p2指向链表上最后一个结点,p1指向新建立的结点int sumb=0,n1,n2,n3;n1=lenm;n2=lenn;n3=n1>n2?n1:n2;p2=p1=(struct student *)malloc(LEN);p1->score=(m->score+n->score)%10000;sumb=(m->score+n->score+sumb)/10000;p2->next=NULL;head=p2;m=m->next;n=n->next;while(m!=NULL&&n!=NULL){p1=(struct student *)malloc(LEN);p1->score=(m->score+n->score+sumb)%10000;sumb=(m->score+n->score+sumb)/10000;p1->next=NULL;p2->next=p1;p2=p1;m=m->next;n=n->next;while(m!=NULL){p1=(struct student *)malloc(LEN); p1->score=(m->score+sumb)%10000; sumb=(m->score+sumb)/10000;p1->next=NULL;p2->next=p1;p2=p1;m=m->next;}while(n!=NULL){p1=(struct student *)malloc(LEN); p1->score=(n->score+sumb)%10000; sumb=(n->score+sumb)/10000;p1->next=NULL;p2->next=p1;p2=p1;n=n->next;}lensum=n3;return head;}//endaddstruct student *sub(struct student *m,struct student *n)//减法运算{struct student *p1,*p2,*head;int sumb=0,n1,n2;n1=lenm;n2=lenn;p2=p1=(struct student *)malloc(LEN);if(m->score>=n->score)p1->score=m->score+sumb-n->score;else{p1->score=m->score-n->score+10000;sumb=-1;}p1->next=NULL;m=m->next;n=n->next;head=p2;while(n){p1=(struct student *)malloc(LEN);p1->next=NULL;if(m->score+sumb>=n->score){p1->score=m->score+sumb-n->score;sumb=0;}else{p1->score=m->score+sumb-n->score+10000;sumb=-1;}p2->next=p1;p2=p1;m=m->next;n=n->next;}while(m){p1=(struct student *)malloc(LEN);p1->next=NULL;p1->score=m->score+sumb;sumb=0;p2->next=p1;p2=p1;m=m->next;}lensum=n1;return head;}//endsubint compare(struct student *m,struct student *n)//比较两数大小{int i=0;if(lenm>lenn) return 1;if(lenm<lenn) return -1;while(m&&n){if(m->score>n->score) i=1;if(m->score<n->score) i=-1;m=m->next;n=n->next;}return i;}//endcomparevoid print(struct student *head) {int num[100],k=0,i;while(head){num[k++]=head->score;head=head->next;}for(i=k-1;i>=0;i--)printf("%04d,",num[i]);getch();}。
实验二:线性表的链式表示和实现
实验二:线性表的链式表示和实现一、实验目的:1.掌握线性列表链式存储结构的表达与实现2.掌握对链表进行创建、插入、删除和查找等操作的算法。
3.掌握算法的设计与分析过程。
4.进一步熟悉VC++开发环境,熟悉应用程序的设计过程,掌握程序编辑、调试和集成的方法和技巧。
二、实验要求:1.采用教材中C语言描述的单链表存储结构,模块化设计流程,设计高效算法完成各种操作任务,并根据实际数据实现各种操作。
2.完成程序编写,调试成功后,书写实验报告。
三、实验任务:1.创建有n(n为正整数)数据元素的单链表,数据从键盘输入。
2.查找第i个结点,找到返回其值,否则返回0;3.对已经创建的单链表分别进行插入结点操作,在第i 个元素之前插入1个结点。
4.删除节点并删除第i个节点的元素。
5.在本地反转单链表。
6.将链表按值的奇偶数分解成两个链表。
要求:创建单链表后,其他操作可以是任意选择进行的。
(考虑设计菜单调用各功能模块)四、设计指南:1.结点的定义#include#includetypedefintdatatype;typedefstructnode{datatypedata;structnode*n ext;}lnode,*linklist;2.将复杂的问题分解成若干个相对容易的小问题,并设计好解决每个小问题的函数的函数名、入口参数及其返回值;设计出各个函数的程序框架及完整的主函数程序。
(注:每个功能一个函数)例如://输出链表数据voiddisplay(linklistl){linklistp;p=l->next;第1页/共3页而(p){printf(\p=p->next;}printf(\}//单链表初始化linklistlistinit(linklistl){l=(linklist)malloc(sizeof(lnode));l->next=null;returnl;}//创建单链表linklistlistcreate(linklistl,inta){inti;linklistp;//具体操作请大家自己完成display(l);returnl;}voidlistsearch(){}//单链表插入LinkListInsert(linklistl){linklistp,q;p=l;//具体操作请填写显示(L);returnl;}//单链表删除linklistlistdelete(linklistl){linklistp,q;p=l;//请自行完成具体操作voidmain(){第2页,共3页inti;inta,b,c;linklistl;l=listinit(l);while(1){printf(\单链表*****\\n\printf(\创建*****\\n\printf(\查找*****\\n\printf(\插入*****\\n\printf(\删除*****\\n\printf(\退出*****\\n\printf(\请输入您的选择:\\n\scanf(\switch(i){case1:printf(\请输入元素个数:\\n\scanf(\listcreate(l,a);break;case2:listsearch();break;case3:listinsert(l); break;case4:listdelete(l);display(l);break;case0:exit(0);default:printf(\您的输入有误,请重新输入!\\n\}}}第3页,共3页。
线性表及其应用实验
数据结构实验
实验一线性表及其应用
一、实验目的
1、掌握用上机调试线性表的基本方法;
2、掌握线性表的基本操作,插入、删除、查找,以及线性表在顺序存储结构上的
应用。
3、按要求完成实验报告
二、实验环境
硬件:PC 微型计算机、256M以上内存,40G以上硬盘。
软件:Windows XP,VC或
三、实验内容
定义一个可以存放学生元素的有序顺序表。
学生元素中包含两个数据项:姓名,成绩。
注意顺序表以学生成绩有序存放。
要求完成一个程序,能添加、删除学生元素,并显示顺序表中所有元素。
四、实验步骤
1、编写程序,定义学生类Student,记录两个数据项:姓名,成绩。
并提供构造函数。
2、
在此基础上添加三个学生,一个分数为45,一个分数为88,一个分数为75。
检查学生添加后顺学表中的学生信息是否还以成绩为序非递减排列。
实验代码:
头文件函数:
c1.h
c2.h
功能函数:
Basic_Operation.cpp
主函数:
插入:
合并并按非递减排序:
删除:。
线性表的实现及操作(二)
typedef struct
{
DataType list[MaxSize];
int size;
} SeqList;
void ListInitiate(SeqList *L)/*初始化顺序表L*/
{
L->size = 0;/*定义初始数据元素个数*/
}
int ListLength(SeqList L)/*返回顺序表L的当前数据元素个数*/
ListDelete(&myList, 4, &x);
for(i = 0; i < ListLength(myList); i++)
{
ListGet(myList, i, &x);//此段程序有一处错误
printf("%d ", x);
}
}
测试结果:
线性表的实现及操作(二)
一、实验目的
了解和掌握线性表的链式存储结构;掌握用C语言上机调试线性表的基本方法;掌握线性表的基本操作:插入、删除、查找以及线性表合并等运算在顺序存储结构和链接存储结构上的运算,以及对相应算法的性能分析。
p = p->next;
free(p1);
}
*head = NULL;
}
void main(void)
{
SLNode *head;
int i , x;
ListInitiate(&head);/*初始化*/
for(i = 0; i < 10; i++)
{
if(ListInsert(head, i, i+1) == 0)/*插入10个数据元素*/
线性表的应用
线性表的应用
【实验题目】
线性表的应用
【实验内容】
线性表的合并与排序
【实验目的】
掌握线性表的概念及原理,运用线性表的原理完成实验题目中的内容。
【实验要求】
通过程序设计,实现线性表的合并与排序。
更好的掌握与理解课堂上老师所讲的概念与原理,通过线性表的方法实现目标
【设计原理】
先将两个单独的线性表合并到另外一个空的线性表,然后对这个线性表进行排序,实现由小到大的输出。
利用线性表实现。
【程序清单及注释说明】
#include
using namespace std;
void print(int a[],int n)
{
int i;
for(i=0;ia[j])
{
a[i]=a[i]+a[j];
a[j]=a[i]-a[j];
a[i]=a[i]-a[j];
}
}
void main()
{
int a[100],b[100],ab[200],n,m,i,j,k;
i=j=0;
k=0;
printf(
scanf(
printf(
for(i=0;i k = 0;
k=m+n; ——> i = j = 0;
在/* 对两个线性表进行排序*/ 这一行的上方,加k = m + n;这句话。
然后实现了所要求的程序。
相关文档:
•
•
•
•
•
•
•
•
•
•
更多相关文档请访问:。
数据结构实验二 线性表
数据结构实验二线性表数据结构实验二线性表1. 实验目的1.1 理解线性表的概念和特性1.2 学习线性表的顺序存储结构和链式存储结构1.3 掌握线性表的基本操作:初始化、插入、删除、查找、修改、遍历等1.4 熟悉线性表的应用场景2. 实验内容2.1 线性表的顺序存储结构实现2.1.1 定义线性表结构体2.1.2 初始化线性表2.1.3 插入元素2.1.4 删除元素2.1.5 查找元素2.1.6 修改元素2.1.7 遍历线性表2.2 线性表的链式存储结构实现2.2.1 定义链表节点结构体2.2.2 初始化链表2.2.3 插入元素2.2.4 删除元素2.2.5 查找元素2.2.6 修改元素2.2.7 遍历链表3. 实验步骤3.1 实现顺序存储结构的线性表3.2 实现链式存储结构的线性表3.3 编写测试程序,验证线性表的各种操作是否正确3.4 进行性能测试,比较两种存储结构的效率差异4. 实验结果与分析4.1 执行测试程序,检查线性表的操作结果是否正确4.2 对比顺序存储结构和链式存储结构的性能差异4.3 分析线性表的应用场景,总结线性表的优缺点5. 实验总结5.1 总结线性表的定义和基本操作5.2 回顾实验中遇到的问题和解决方法5.3 提出对线性表实现的改进方向和思考附件:请参考附件中的源代码和实验报告模板。
法律名词及注释:1. 版权:指对某一作品享有的法律上的权利,包括复制权、发行权、改编权等。
2. 法律责任:指违反法律或合同规定所承担的责任。
3. 保密义务:指个人或组织根据法律、法规、合同等规定需要承担的保密责任。
4.知识产权:指人们在社会实践中所创造的智力劳动成果所享有的权利,包括专利权、著作权、商标权等。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实验二线性表的应用(2学时)一、实验目的:掌握线性表的基本结构和操作方法,培养学生灵活使用结构解决实际问题的能力。
二、实验内容:设计一个100位以内的长整数加减运算的程序。
三、实验要求:1,输入输出要求:每四位一组,组间用逗号分隔;2,加和减分别用不同的程序实现3,程序应考虑输入数据的符号四、参考程序/*设计一个100位以内的长整数加减运算的程序。
实验要求:1,输入输出要求:每四位一组,组间用逗号分隔;2,程序应考虑输入数据的符号*/#include<stdio.h>#include<string.h>#include<stdlib.h>#include<conio.h>#include<malloc.h>#define LEN sizeof(struct student)struct student{int score;struct student *next;};int lenm,lenn,lensum;//m与n的长度void main(){struct student *creat(int *d,int *len);void print(struct student *head);struct student *add(struct student *m,struct student *n);struct student *sub(struct student *m,struct student *n);int compare(struct student *m,struct student *n);struct student *m,*n,*sum;int s1,s2,s3,k;char ch;printf("输入第一个数:\n");m=creat(&s1,&lenm);//输入第一个数放在链表m中,s1为其符号printf("\n选择运算,输入+或-:");scanf("%c",&ch);getchar();printf("\n输入第二个数:\n");n=creat(&s2,&lenn);//输入第一个数放在链表n中,s2为其符号k=compare(m,n);//k=1则m>n,k=-1则m<n,k=0则m=nif(ch=='+')//加法运算{if(s1*s2>0){s3=s1;sum=add(m,n);}else {if(s1>0&&k==1) {s3=1;sum=sub(m,n);}//m>0,n<0,m>|n|,m+n=m-|n|if(s1>0&&k==-1){s3=-1;sum=sub(n,m);}//m>0,n<0,m<|n|,m+n=-(|n|-m)if(s1<0&&k==1){s3=-1;sum=sub(m,n);}//m<0,n>0,|m|>|n|,m+n=-(|m|-n)if(s1<0&&k==-1){s3=1;sum=sub(n,m);}//m<0,n>0,|m|<|n|,m+n=n-|m|if(k==0) s3=0;}}//endif+if(ch=='-')//减法运算{if(s1*s2<0) {s3=s1;sum=add(m,n);}else{if(s1>0&&k==1) {s3=1;sum=sub(m,n);}//m>0,n>0,m>n,m-n=m-nif(s1>0&&k==-1){s3=-1;sum=sub(n,m);}//m>0,n>0,m<n,m-n=-(n-m)if(s1<0&&k==1){s3=-1;sum=sub(m,n);}//m<0,n<0,|m|>|n|,m-n=-(|m|-|n|)if(s1<0&&k==-1){s3=1;sum=sub(n,m);}//m<0,n<0,|m|<|n|,m-n=|n|-|m|if(k==0) s3=0;}}//endif-if(s3>0) {printf("结果为:+");print(sum);}if(s3<0) {printf("结果为:-");print(sum);}if(s3==0) printf("结果为:0");}//endmainstruct student *creat(int *sign,int *n)//输入数据并建立链表首结点存放最低4位数据{void print(struct student *head);struct student *p1,*p2;int i=0,j,k=0,len;char s[5],c[130];*sign=1;gets(c);if(c[0]=='-'){i=1;*sign=-1;}p1=p2=(struct student *)malloc(LEN);//建立尾结点p1->score=0;p1->next=NULL;len=strlen(c);for(;i<len;i++){j=0;while(c[i]>='0'&&c[i]<='9')//取出逗号之间的每一组数存放到字符数组s中{s[j++]=c[i++];k++;}s[j]='\0';p1=(struct student *)malloc(LEN);p1->score=atoi(s);//将s转换成整数p1->next=p2;//插入到链表头p2=p1;}*n=k;return(p1);}struct student *add(struct student *m,struct student *n)//加法运算{struct student *p1,*p2,*head;//p2指向链表上最后一个结点,p1指向新建立的结点int sumb=0,n1,n2,n3;n1=lenm;n2=lenn;n3=n1>n2?n1:n2;p2=p1=(struct student *)malloc(LEN);p1->score=(m->score+n->score)%10000;sumb=(m->score+n->score+sumb)/10000;p2->next=NULL;head=p2;m=m->next;n=n->next;while(m!=NULL&&n!=NULL){p1=(struct student *)malloc(LEN);p1->score=(m->score+n->score+sumb)%10000;sumb=(m->score+n->score+sumb)/10000;p1->next=NULL;p2->next=p1;p2=p1;m=m->next;n=n->next;}while(m!=NULL){p1=(struct student *)malloc(LEN);p1->score=(m->score+sumb)%10000;sumb=(m->score+sumb)/10000;p1->next=NULL;p2->next=p1;p2=p1;m=m->next;}while(n!=NULL){p1=(struct student *)malloc(LEN);p1->score=(n->score+sumb)%10000;sumb=(n->score+sumb)/10000;p1->next=NULL;p2->next=p1;p2=p1;n=n->next;}lensum=n3;return head;}//endaddstruct student *sub(struct student *m,struct student *n)//减法运算{struct student *p1,*p2,*head;int sumb=0,n1,n2;n1=lenm;n2=lenn;p2=p1=(struct student *)malloc(LEN);if(m->score>=n->score)p1->score=m->score+sumb-n->score;else{p1->score=m->score-n->score+10000;sumb=-1;}p1->next=NULL;m=m->next;n=n->next;head=p2;while(n){p1=(struct student *)malloc(LEN);p1->next=NULL;if(m->score+sumb>=n->score){p1->score=m->score+sumb-n->score;sumb=0;}else{p1->score=m->score+sumb-n->score+10000;sumb=-1;}p2->next=p1;p2=p1;m=m->next;n=n->next;}while(m){p1=(struct student *)malloc(LEN);p1->next=NULL;p1->score=m->score+sumb;sumb=0;p2->next=p1;p2=p1;m=m->next;}lensum=n1;return head;}//endsubint compare(struct student *m,struct student *n)//比较两数大小{int i=0;if(lenm>lenn) return 1;if(lenm<lenn) return -1;while(m&&n){if(m->score>n->score) i=1;if(m->score<n->score) i=-1;m=m->next;n=n->next;}return i;}//endcomparevoid print(struct student *head){int num[100],k=0,i;while(head){num[k++]=head->score;head=head->next;}for(i=k-1;i>=0;i--)printf("%04d,",num[i]);getch();}。