中南民族大学数据结构实验报告.docx

中南民族大学数据结构实验报告.docx

《中南民族大学数据结构实验报告.docx》由会员分享，可在线阅读，更多相关《中南民族大学数据结构实验报告.docx（50页珍藏版）》请在冰豆网上搜索。

中南民族大学数据结构实验报告

中南民族大学

学生实验报告

院系：

计算机科学学院

专业：

计算机科学与技术

年级：

2011级

课程名称：

数据结构

学号：

********

***********************************

********************************

2013年6月10日

设计题目一：

一元稀疏多项式计算器

【问题描述】

一元稀疏多项式计算器

【基本要求】

一元稀疏多项式简单计算器的功能是：

（1）输入并建立多项式；

（2）输出多项式，输出形式为整数序列：

n，c1,e1,c2,e2,………cn,en,其中n是多项式的项数，ci和ei分别是第i项的系数和指数，序列按指数降序排列；

（3）多项式a和b相加，建立多项式a+b；

（4）多项式a和b相减，建立多项式a-b。

一、需求分析

1.定义线性表的动态分配顺序存储结构；

2.建立多项式存储结构，定义指针*next

3.利用链表实现队列的构造。

每次输入一项的系数和指数，可以输出构造的一元多项式

4.演示程序以用户和计算机的对话方式执行，即在计算机终站上显示“提示信息”之后，由用户在键盘上输入演示程序中规定的运行命令；最后根据相应的输入数据（滤去输入中的非法字符）建立的多项式以及多项式相加的运行结果在屏幕上显示。

多项式显示的格式为：

c1x^e1+c2x^e2+…+cnx^en

序列按指数降序排列。

5.设计思路分析

要解决多项式相加，必须要有多项式，所以必须首先建立两个多项式，在这里采用链表的方式存储链表，所以我将结点结构体定义为:

序数coef指数expn指针域next

运用尾插法建立两条单链表，以单链表LinkListp和LinkListh分别表示两个一元多项式a和b，a+b的求和运算等同于单链表的插入问题,将单链表LinkListp中的结点插入到单链表LinkListh中即可。

为了实现处理，设p、q分别指向单链表LinkLista和LinkListb的当前项，比较p、q结点的指数项，由此得到下列运算规则：

若p->expnexpn，则结点p所指的结点应是“和多项式”中的一项，令指针p后移;若p->expn=q->expn，则将两个结点中的系数相加，当和不为0时修改结点p的系数;若p->expn>q->expn，则结点q所指的结点应是“和多项式”中的一项，将结点q插入在结点p之前，且令指针q在原来的链表上后移。

6.测试数据

（1）（2x+5x^8-3.1x^11）+（7-5x^8+11x^9）=（-3.1x^11+11x^9+2x+7）;

（2）（6x^-3-x+4.4x^2-1.2x^9+1.2x^9）-（-6x^-3+5.4x^2-x^2+7.8x^15

）=（-7.8x^15-1.2x^9+12x^-3-x）;

（3）（1+x+x^2+x^3+x^4+x^5）+（-x^3-x^4）=（1+x+x^2+x^5）;

（4）（x+x^3）+（-x-x^3）=0;

（5）（x+x^100）+（x^100+x^200）=（x+2x^100+x^200）;

（6）（x+x^2+x^3）+0=x+x^2+x^3.

（7）互换上述测试数据中的前后两个多项式

二、概要设计

1、元素类型、结点类型和指针类型：

typedefstructPolynode

{

floatcoef;//系数

intexp;//指数

structPolynode*next;

}*Poly,Polynode;//Poly为结点指针类型

2、建立一个头指针为head、项数为m的一元多项式,建立新结点以接收数据,调用Insert函数插入结点:

LinkListCreateLinkList（LinkListhead,intm）{

inti;

LinkListp;

p=head=（LinkList）malloc（sizeof（structLNode））;

head->next=NULL;

for（i=0;i

{

p=（LinkList）malloc（sizeof（structLNode））;

printf（"请输入第%d项的系数与指数:

",i+1）;

scanf（"%f%d",&p->coef,&p->expn）;

Insert（p,head）;

}

returnhead;

}

3、主函数和其他函数：

intmain（）

{

intm,n,flag=0;

floatx;

Polypa=0,pb=0,pc,pd,pe,pf;//定义各式的头指针，pa与pb在使用前付初值NULL

·········

}

主函数-建立链表->多项式相加减—>输出多项式

三、详细设计：

#include

#include

#include

typedefstructPolynode

{

floatcoef;//系数

intexp;//指数

structPolynode*next;

}*Poly,Polynode;//Poly为结点指针类型

voidInsert（Polyp,Polyhead）

{

if（p->coef==0）//系数为0时释放结点

free（p）;

else

{

Polyq1,q2;

q1=head;

q2=head->next;

while（q2&&p->expexp）

{//后移查找插入位置

q1=q2;

q2=q2->next;

}

if（q2&&p->exp==q2->exp）

{//将指数相同的相合并

q2->coef+=p->coef;

free（p）;

if（!

q2->coef）//系数为0时释放结点

{

q1->next=q2->next;

free（q2）;

}

}

else

{

p->next=q2;

q1->next=p;

}

}

}//Insert

PolyCreateList（Polyhead,intm）

{//建立一个头指针为head、项数为m的一元多项式

inti;

Polyp;

Polynode*q;

p=head=（Poly）malloc（sizeof（structPolynode））;

head->next=NULL;

for（i=0;i

{

p=（Poly）malloc（sizeof（structPolynode））;//建立新结点以接收数据

cout<<"请输入第"<

";

cin>>p->coef>>p->exp;

Insert（p,head）;//调用Insert函数插入结点

}

q=head->next;

while（q!

=NULL）

{

cout<<"系数：

"<coef<<"\t"<<"指数:

"<exp<

q=q->next;

}

returnhead;

}//CreatePoly

voidDestroyList（Polyp）

{//销毁多项式p

Polyq1,q2;

if（p->next!

=NULL）

{

q1=p->next;

q2=q1->next;

while（q1->next）

{

free（q1）;

q1=q2;//指针后移

q2=q2->next;

}

}

}

intOutputList（PolyP）

{//输出多项式

Polyq=P->next;

intflag=1;//项数计数器

if（!

q）

{//若多项式为空，输出0

cout<<"0"<

return（0）;

}

while（q）

{

if（q->coef>0&&flag!

=1）//系数大于0且不是第一项

cout<<"+";

if（q->coef!

=1&&q->coef!

=-1）//系数非1或-1的普通情况

{

cout<coef;

if（q->exp==1）

cout<<"X";

elseif（q->exp）

cout<<"X^"<exp;

}

else

{

if（q->coef==1）

{

if（!

q->exp）

cout<<"1";

elseif（q->exp==1）

cout<<"X";

elseif（q->exp）

cout<<"X^"<exp;

}

if（q->coef==-1）

{

if（!

q->exp）cout<<"-1";

elseif（q->exp==1）cout<<"-X";

elsecout<<"-X^"<exp;

}

}

q=q->next;

flag++;

}//while

cout<

return（0）;

}//OutputPoly

intcompare（Polya,Polyb）

{

if（a&&b）

{

if（!

b||a->exp>b->exp）return1;

elseif（!

a||a->expexp）return-1;

elsereturn0;

}

elseif（!

a&&b）return-1;//a多项式已空，但b多项式非空

elsereturn1;//b多项式已空，但a多项式非空

}//compare

PolyAddPoly（Polypa,Polypb）

{//求解并建立和多项式a+b，返回其头指针

Polyqa=pa->next;

Polyqb=pb->next;

Polyheadc,hc,qc;

hc=（Poly）malloc（sizeof（structPolynode））;//建立头结点

hc->next=NULL;

headc=hc;

while（qa||qb）{

qc=（Poly）malloc（sizeof（structPolynode））;

switch（compare（qa,qb））

{

case1:

{

qc->coef=qa->coef;

qc->exp=qa->exp;

qa=qa->next;

break;

}

case0:

{

qc->coef=qa->coef+qb->coef;

qc->exp=qa->exp;

qa=qa->next;

qb=qb->next;

break;

}

case-1:

{

qc->coef=qb->coef;

qc->exp=qb->exp;

qb=qb->next;

break;

}

}//switch

if（qc->coef!

=0）

{

qc->next=hc->next;

hc->next=qc;

hc=qc;

}

elsefree（qc）;//当相加系数为0时，释放该结点

}//while

returnheadc;

}//AddPoly

PolySubtractPoly（Polypa,Polypb）

{//求解并建立和多项式a-b，返回其头指针

Polyqa=pa->next;

Polyqb=pb->next;

Polyheadc,hc,qc;

hc=（Poly）malloc（sizeof（structPolynode））;//建立头结点

hc->next=NULL;

headc=hc;

while（qa||qb）

{

qc=（Poly）malloc（sizeof（structPolynode））;

switch（compare（qa,qb））

{

case1:

{

qc->coef=qa->coef;

qc->exp=qa->exp;

qa=qa->next;

break;

}

case0:

{

qc->coef=qa->coef-qb->coef;

qc->exp=qa->exp;

qa=qa->next;

qb=qb->next;

break;

}

case-1:

{

qc->coef=-qb->coef;

qc->exp=qb->exp;

qb=qb->next;

break;

}

}//switch

if（qc->coef!

=0）

{

qc->next=hc->next;

hc->next=qc;

hc=qc;

}

elsefree（qc）;//当相减系数为0时，释放该结点

}//while

returnheadc;

}//AddPoly

PolyMultiplyPoly（Polypa,Polypb）

{//求解并建立积多项式a*b，返回其头指针

Polyhf,pf;

Polyqa=pa->next;

Polyqb=pb->next;

hf=（Poly）malloc（sizeof（structPolynode））;//建立头结点

hf->next=NULL;

for（qa=pa->next;qa;qa=qa->next）

{

for（qb=pb->next;qb;qb=qb->next）

{

pf=（Poly）malloc（sizeof（structPolynode））;

pf->coef=qa->coef*qb->coef;

pf->exp=qa->exp+qb->exp;

Insert（pf,hf）;//调用Insert函数以合并指数相同的项

}

}

returnhf;

}//MultiplyPoly

voidDevicePoly（Polypa,Polypb）

{//求解并建立商多项式a/b，返回其头指针

Polyhf,pf,temp1,temp2;

Polyqa=pa->next;

Polyqb=pb->next;

hf=（Poly）malloc（sizeof（structPolynode））;//建立头结点,存储商

hf->next=NULL;

pf=（Poly）malloc（sizeof（structPolynode））;//建立头结点，存储余数

pf->next=NULL;

temp1=（Poly）malloc（sizeof（structPolynode））;

temp1->next=NULL;

temp2=（Poly）malloc（sizeof（structPolynode））;

temp2->next=NULL;

temp1=AddPoly（temp1,pa）;

while（qa!

=NULL&&qa->exp>=qb->exp）

{

temp2->next=（Poly）malloc（sizeof（structPolynode））;

temp2->next->coef=（qa->coef）/（qb->coef）;

temp2->next->exp=（qa->exp）-（qb->exp）;

Insert（temp2->next,hf）;

pa=SubtractPoly（pa,MultiplyPoly（pb,temp2））;

qa=pa->next;

temp2->next=NULL;

}

pf=SubtractPoly（temp1,MultiplyPoly（hf,pb））;

cout<<"商是：

";

OutputList（hf）;

cout<<"余数是：

";

OutputList（pf）;

}//DevicePoly

floatValuePoly（Polyhead,floatx）

{//输入x值，计算并返回多项式的值

Polyp;

inti;

floatsum=0,t;

for（p=head->next;p;p=p->next）

{

t=1;

for（i=p->exp;i!

=0;）

{

if（i<0）

{

t/=x;

i++;

}//指数小于0，进行除法

else

{

t*=x;

i--;

}//指数大于0，进行乘法

}

sum+=p->coef*t;

}

returnsum;

}//ValuePoly

PolyDerivative（Polyhead）

{//求解并建立a的导函数多项式，并返回其头指针

Polyq=head->next,p1,p2,hd;

hd=p1=（Poly）malloc（sizeof（structPolynode））;//建立头结点

hd->next=NULL;

while（q）

{

if（q->exp!

=0）

{//该项不是常数项时

p2=（Poly）malloc（sizeof（structPolynode））;

p2->coef=q->coef*q->exp;

p2->exp=q->exp-1;

p2->next=p1->next;//尾插法插入结点

p1->next=p2;

p1=p2;

}

elseif（q->exp==0）//该项为常数项

break;

q=q->next;

}

returnhd;

}//Dervative

intmain（）

{

intm,n,flag=0;

floatx;

Polypa=0,pb=0,pc,pd,pe,pf;//定义各式的头指针，pa与pb在使用前付初值NULL

cout<<"请输入a的项数:

";

cin>>m;

pa=CreateList（pa,m）;//建立多项式a

cout<<"请输入b的项数:

";

cin>>n;

pb=CreateList（pb,n）;//建立多项式a

//输出菜单

cout<<"---------------------------------------------------------------------"<

cout<<"1.输出多项式a和b\n";

cout<<"2.建立多项式a+b\n";

cout<<"3.建立多项式a-b\n";

cout<<"4.建立多项式a*b\n";

cout<<"5.建立多项式a/b\n";

cout<<"6.计算多项式a在x处的值\n";

cout<<"7.求多项式a的导函数\n";

cout<<"8.退出程序\n";

cout<<"----------------------------------------------------------------------"<

for（;;flag=0）

{

cout<<"执行操作为:

";

cin>>flag;

if（flag==1）

{

cout<<"多项式a为：

";

OutputList（pa）;

cout<<"多项式b为：

";

OutputList（pb）;

continue;

}

if（flag==2）

{

pc=AddPoly（pa,pb）;

cout<<"多项式a+b为：

";

OutputList（pc）;

DestroyList（pc）;

continue;

}

if（flag==3）

{

pd=SubtractPoly（pa,pb）;

cout<<"多项式a-b为：

";

OutputList（pd）;

DestroyList（pd）;

continue;

}

if（flag==4）

{

pe=MultiplyPoly（pa,pb）;

cout<<"多项式a*b为：

";

OutputList（pe）;

DestroyList（pe）;

continue;

}

if（flag==5）

{

DevicePoly（pa,pb）;

continue;

}

if（flag==6）

{

cout<<"请输入x的值：

x=";

cin>>x;

cout<<"多项式a的值为:

"<

continue;

}

if（flag==7）

{

pf=Derivative（pa）;

cout<<"多项式a的导函数为：

";

OutputList（pf）;

DestroyList（pf）;

continue;

}

if（flag==8）

break;

if（flag<1||flag>8）

cout<<"输入错误请重新选择!

!

";

continue;

}

DestroyList（pa）;

DestroyList（pb）;

return0;

}

四、运行结果截屏：

（七项测试数据经运行皆正确）

以测试数据

（1）（2x+5x^8-3.1x^11）+（7-5x^8+11x^9）=（-3.1x^11+11x^9+2x+7）;

为例：

五、心得体会

设计题目二：

马踏棋盘

【问题描述】

设计一个国际象棋的马踏遍棋盘的演示程序。

【基本要求】

将马随机放在国际象棋的8*8棋盘Board[8][8]的某个方格中，马按走棋规则进行移动。

要求每个方格只进入一次，走遍棋盘上全部64个方格。

编制非递归程序，求出马的行走路线，并按求出的行走路线，将数字1,2，……，64依次填入一个8*8的方阵，输出之。

一、需求分析

1.定义栈的类型及棋盘intboard[8][8]；

2.建立数组intHtry1[8]，intHtry2[8]，存放马的各个出口位置

3.利用数组及栈的作用，每次输入行数和列数，可以输出由此点开始马踏棋盘的行走路径并展示在棋盘上。

4.演示程序以用户和计算机的对话方式执行，即在计算机终站上显示“提示信息”之后，由用户在键盘上输入演示程序中规定的运行命令；最后根据相应的输入信息，将每一步的路径显示在屏幕上。

格式为8*8棋盘。

5.设计思路分析

要显示马踏棋盘，必须要有行坐标和列坐标，所以必须首先建立两个记录下标的数组，并确保不超出棋盘。

先输入起始位置坐标voidInitLocation（intxi,intyi），再利用栈来对马走的每一步进行试探，这里用TryPath（inti,intj）来完成，最后输出马儿的行走路径Display（）。

其中，起始位置的横坐标和纵坐标进栈x=stack[top].i；y=stack[top].j;试探路径则用i=stack[top].i+Htry1[h];j=stack[top].j+Htry2[h];来完成，如果如果找到下一位置则记录条数并存放在数组中a[h]=number，找不到则继续探寻，找到下一个位置则进栈，top++指针前移并标记键盘，否则指针前移退栈，清除标记，最后，走完整个棋盘返回1.

二、概要设计

1、元素类型、栈类型：

structStack{//定义栈类型

inti;//行坐标

intj;//列坐标

}stack[MAXSIZE];//定义一个栈数组

2、定义数组，存储马的各个出口位置及各个出口位置相对当前位置列下标的增量数组

intHtry1[8]={1,-1,-2,2,2,1,-1,-2};

/*存储马各个出口位置相对当前位置行下标的增量数组*/

intHtry2[8]={2,-2,