一元n次实验报告.docx
《一元n次实验报告.docx》由会员分享，可在线阅读，更多相关《一元n次实验报告.docx（16页珍藏版）》请在冰点文库上搜索。
一元n次实验报告
《程序设计》实习报告（2012-4-8）
姓名：
秦炜杰学号：
110520021日期：
2011-4-8
一、[题目]编出程序,在键盘上输入两个一元n次多项式，按指数减少的形式输出，求出两个一元n次多项式的和，化简后并按指数减少的形式输出。
我们可以利用数组来表示一个一元多项式。
例如多项式：
3X9-6X4+2X+7
可表示为
（指数和系数均为0表示结束）
设每个一元多项式项数都不会超过十项。
编出程序实现如下功能：
在键盘上输入指数ne和系数nf，分别生成两个一元多项式HA和HB；
输出亿元多项式HA和HB；
把一元多项式HA和HB相加，生成新的一元多项式HC（HC可能超过十项）；
输出新形成的一元多项式HC（原HA、HB不变）；
询问“Continue（n）?
”,当输入回答字符‘n’时结束，否则回到第一点继续执行；
注意：
进行多项式相加时，只有该两项的指数相同时才能相加，若相加后系数为0，
则取消该项；
建立多项式，可以严格按指数从大到小的次序输入，此时，当发现当前项的指数比前一项的指数大时，则要求多项式各项依照指数重新输入；
若建立多项式时可以不按指数由大到小的次序输入时，则应在输入结束后用程序进行调整，使数组内多项式各项依照指数从大到小次序存放；
在一个多项式中若发现有两项（或两项以上）的指数相等时，应进行合并，或合并后系数为0则取消该项；
多项式输出形式：
设有多项式3X8-2X+7，则输出形式为：
3X∧8-2X∧1+7X∧0或3X8-2X1+7X0
【进一步要求】：
以链表形式，编程实现上述功能。
二、[基本要求]
1．链表的基本操作要熟练，在建立链表的同时要进行排序，避免把整条链进行排序。
2．输入和输出要清晰，输入提示要清楚。
三、实习报告
1．实习题：
编出程序使用户输入两个一元n次多项式，按指数减小的形式输出键入的两条链，并把两条链进行求和合并同类项，然后按指数减少的形式输出。
2．解题的基本算法：
（1）根据题意，先输入一个多项式的指数，再输入该项的系数，以指数和系数为0结束该多项式的输入，再以同样的输入形式第二个多项式，最后进行相加，合并同类项，
最后输出该结果。
所以，程序的主要结构应如下：
1.输出提示后依次输入对应的指数和系数；
2.在不改变两个多项式的情况下进行相加化简；
3.最后输出最后结果。
（2）从程序的结构上看，输出并不难，边输入边排序和两个多项式的相加后化简比较难
（3）进一步讨论两个多项式的相加和化简：
先把两条链的头指针赋给HA和HB；
先看分别HA和HB的第一项，看是否都为空，若是，则结果为0；
若HA为空，HB不为空，则把HA中第一项赋给第三条结果链HC，再把HA后移一位；
若HB为空，HA不为空，则把HA中第一项赋给第三条结果链HC，再把HB后移一位；
若HA和HB都不为空，则再进一步比较指数的大小，然后再把HA和HB后移一位：
若HA的指数大于HB的指数，则把HA写入HC；若HA的指数小于HB的指数，则把HB写入HC；若两项的指数相同，则把两项相加后看是否为0，如果为0，则不写入HC，如果不为0，则写入HC中。
（4）进一步讨论创建链表时是按顺序插入的：
在插入第二个节点前先扫描一次链表，在刚好的位置插入。
3．程序流程图（为了更直观地反映出程序的逻辑关系，我们仍采用了传统的表示方法
（注意：
HA和HB分别为两条链的头指针。
）
4.源程序代码。
//一元n次多项式的链表形式
#include
#include
#include
structduo_xiang_shi//建立结构体
{floatzi_shu;//指数
floatxi_shu;//系数
duo_xiang_shi*next;//指向下一个节点
};
intn;
duo_xiang_shi*creat_order（void）//建立链表并且按指数从大到小插入
{duo_xiang_shi*head;
duo_xiang_shi*p,*p0,*point;
floatt;
n=0;
p0=newduo_xiang_shi;
cout<<"\nPleaseInputthe"<<（n+1）<<"shizhi'szi_shu:
";
cin>>p0->zi_shu;
cout<<"\nPleaseInputthe"<<（n+1）<<"shizhi'sxi_shu:
";
cin>>p0->xi_shu;
head=NULL;
while（（p0->zi_shu!
=0||p0->xi_shu!
=0）&&（n<=9））//找到节点的合适位置
{n=n+1;
if（n==1）
{
head=p0;
p0->next=NULL;
}
else
{
p=head;
while（p0->zi_shuzi_shu&&p->next!
=NULL）//插入第一个节点
{
point=p;
p=p->next;
}
if（p0->zi_shu>=p->zi_shu）
{
if（p==head）//插入第二个节点，第二个节点大于第一个节点
{
p0->next=head;
head=p0;
}
else//插入节点
{
p0->next=point->next;
point=p0->next;
}
}
else//尾节点后插入
{
p->next=p0;
p0->next=NULL;
}
}
p0=newduo_xiang_shi;
cout<<"\nPleaseInputthe"<<（n+1）<<"shizhi'szi_shu:
";
cin>>p0->zi_shu;
cout<<"\nPleaseInputthe"<<（n+1）<<"shizhi'sxi_shu:
";
cin>>p0->xi_shu;
}
return（head）;
}
duo_xiang_shi*make（duo_xiang_shi*head,duo_xiang_shi*node）//形成HC链
{duo_xiang_shi*temp;
staticduo_xiang_shi*last;
temp=newduo_xiang_shi;
if（NULL==temp）
{
cout<<"Sorry,youcannotapplyformemory";
exit（-1）;
}
else
{
temp->zi_shu=node->zi_shu;
temp->xi_shu=node->xi_shu;
temp->next=NULL;
if（NULL==head）
{
head=temp;
last=temp;
temp->next=NULL;
}
else
{
last->next=temp;
last=temp;
temp->next=NULL;
}
}
returnhead;
}
//两个多项式求和并化简
duo_xiang_shi*add（duo_xiang_shi*HA,duo_xiang_shi*HB）
{
duo_xiang_shi*HC,*head_HC=NULL;
do
{
HC=newduo_xiang_shi;
if（HA==NULL&&HB==NULL）//两个链表都为空
{
HC=NULL;
head_HC=make（head_HC,HC）;
}
if（HA!
=NULL&&HB==NULL）//HA为空，HB不为空
{
HC->zi_shu=HA->zi_shu;
HC->xi_shu=HA->xi_shu;
HA=HA->next;
head_HC=make（head_HC,HC）;
}
if（HA==NULL&&HB!
=NULL）//HA不为空，HB为空
{
HC->zi_shu=HB->zi_shu;
HC->xi_shu=HB->xi_shu;
HB=HB->next;
head_HC=make（head_HC,HC）;
}
if（HA!
=NULL&&HB!
=NULL）//HA，HB都不为空
{
if（HA->zi_shu==HB->zi_shu）//HA的指数大于HB
{
HC->xi_shu=HA->xi_shu+HB->xi_shu;
HC->zi_shu=HA->zi_shu;
if（HC->xi_shu!
=0）//相加后系数不为0
{
head_HC=make（head_HC,HC）;
}
HA=HA->next;HB=HB->next;
}
if（HA->zi_shu>HB->zi_shu）//HA的指数大于HB
{
HC->zi_shu=HA->zi_shu;
HC->xi_shu=HA->xi_shu;
head_HC=make（head_HC,HC）;
HA=HA->next;
}
if（HB->zi_shu>HA->zi_shu）//HB的指数大于HA
{
HC->zi_shu=HB->zi_shu;
HC->xi_shu=HB->xi_shu;
head_HC=make（head_HC,HC）;
HB=HB->next;
}
}
}while（HA!
=NULL||HB!
=NULL）;//当HA，HB都为空时，跳出循环
returnhead_HC;
}
voidprint（duo_xiang_shi*head）//输出链表
{duo_xiang_shi*p;intflag=0;
p=head;
if（p==NULL）cout<<"0";
else
{
while（p!
=NULL）
{if（p->xi_shu!
=0）
{cout<xi_shu<<"X^"<zi_shu;flag++;
p=p->next;
if（p->xi_shu>0&&p!
=NULL）
cout<<"+";
}
}
if（flag==0）cout<<"0";
}
}
intmain（）
{charch;
do{
duo_xiang_shi*head_1,*head_2,*head_3;clrscr（）;
cout<<"\n[PleaseInputthefirstshi_zi]";
head_1=creat_order（）;//建立链表一
cout<<"\n[PleaseInputthesecondshi_zi]";
head_2=creat_order（）;//建立链表二
cout<<"\n****************************************";
cout<<"\nThefirstshizhiis:
";
print（head_1）;//输出链表一
cout<<"\nThesecondshizhiis:
";
print（head_2）;//输出链表二
head_3=add（head_1,head_2）;//合并一二成链表三
cout<<"\nTheLastshizhiis:
";
print（head_3）;//输出链表三
cout<<"\n\tContinue（Yes__anykey/No__'n'）?
";
ch=getche（）;
if（ch=='N'）ch='n';
if（ch!
='n'）cout<<"\n";
}while（ch!
='n'）;
return0;
}
5．调试：
第一组：
输入：
（A）9x8-7x3+3x-5
（B）-5x9+6x5-4x4+x2
输出：
（C）-5X^9+9X^8+6X^5-4X^4-7X^3+X^2+3X^1-5
第二组：
输入：
（A）9x8-7x3+3x-5
（B）x6+5x3-2x+3
输出：
（C）9X^8+X^6-2X^3+X^1-2
第三组：
输入：
（A）9x8-7x3+3x-5
（B）-9x8+7x3-3x
输出：
（C）-5
第四组：
输入：
（A）9x8-7x3+3x-5
（B）2x10-8x8+7x3-3x-5
输出：
（C）2X^10+X^8-10
第五组：
输入：
（A）9x8-7x3+3x-5
（B）-9x10+x7-5x4+3x2
输出：
（C）-9X^10+9X^8+X^7-5X^4-7X^3+3X^2+3X^1-5
第六组：
输入：
（A）9x8-7x3+3x-5
（B）-9x8+7x3-3x+5
输出：
（C）0
第七组：
输入：
（A）9x8-7x3
（B）7x9-9x8+6x4+7x3+2x-5
输出：
（C）7X^9+6X^4+2X^1-5
第八组：
输入：
（A）9x8-7x3+3x-5
（B）0
输出:
（C）9X^8-7X^3+3X^1-5
第九组：
输入：
（A）0
（B）9x8-7x3+3x-5
输出：
（C）9X^8-7X^3+3X^1-5
第十组：
输入：
（A）0
（B）0
输出：
（C）0
6、主要的体会和教训。
1）在插入链表时就要按顺序插入，即不用再对链表进行排序，减少运行时间。
2）考虑的情形要具体一些，比如输出函数中要考虑相加后为0的情形。
3）函数，链表，指针应十分熟悉，不到掌握，而且会运用。
7.主要参考资料。
1.《面向对象程序设计基础》（第二版）（作者：
李师贤等）
2.《C++程序设计实验》（作者：
李宏新等）
3.《C程序设计》（第三版）（作者：
谭浩强）
升级会员 