多项式运算与链表.docx

多项式运算与链表.docx

《多项式运算与链表.docx》由会员分享，可在线阅读，更多相关《多项式运算与链表.docx（16页珍藏版）》请在冰豆网上搜索。

多项式运算与链表

#include

#include

#include

//首先要构造多项式的数据结构

structduoxiangshi

{

charch;//变量名

floatcoef;//系数coefficient

intexpo;//指数exponent

structduoxiangshi*next;

};

//初始化一个链表

duoxiangshi*initlink（）

{

duoxiangshi*p;

p=（duoxiangshi*）malloc（sizeof（duoxiangshi））;

//如果申请内存空间失败

if（p==NULL）

{

printf（"申请空间失败"）;

exit（0）;

}

p->next=NULL;

returnp;

}

//销毁整个链表

voiddestroy_link（duoxiangshi*p）

{

duoxiangshi*q;

while（p!

=NULL）

{

q=p;

p=p->next;

free（q）;

}

}

//将多项式存入链表中

duoxiangshi*creat_ploy（duoxiangshi*p）

{

charc[1];

inti=0,n=0;

duoxiangshi*p1;

p=initlink（）;

printf（"输入变量名:

\n"）;

scanf（"%s",c）;

printf（"输入多项式项数\n"）;

scanf（"%d",&n）;

for（i=0;i

{

p1=（duoxiangshi*）malloc（sizeof（duoxiangshi））;

if（p1==NULL）//如果分配失败时

{

printf（"申请空间失败"）;

exit（0）;

}

printf（"输入第%d项的系数：

\n",i+1）;

scanf（"%f",&p1->coef）;

printf（"输入变量的指数：

\n"）;

scanf（"%d",&p1->expo）;

p1->ch=c[0];

p1->next=p->next;

p->next=p1;

}

returnp;

}

//删除节点返回剩下的链表首地址

duoxiangshi*deletenode（duoxiangshi*h,duoxiangshi*maxp）

{

duoxiangshi*t;

t=h;

//找到要删除的节点的前节点

while（t->next!

=maxp）

{

t=t->next;

}

//删除节点

t->next=maxp->next;

maxp->next=NULL;

returnh;

}

//求表长a用来记录长度

voidlink_length（duoxiangshi*p,int&a）

{

while（p->next!

=NULL）

{

p=p->next;

a++;

}

}

//将链表中的多项式的指数的大小排序

duoxiangshi*sort（duoxiangshi*h）

{

intmin;//用于保存指数最小的值

duoxiangshi*t=NULL,*minp=NULL,*head=NULL;

if（h->next==NULL）

{

printf（"链表中不存在数据\n"）;

exit（0）;

}

//链表排序的思想和冒泡排序差不多，需要临时变量来存在当前最小值

while（h->next!

=NULL）

{

t=h->next;//临时指针

min=t->expo;//临时最小的指数值

minp=t;//把当前t中的值作为最小

while（t->next!

=NULL）//如果t后面有节点就需要比较

{

t=t->next;//向后移动一位当前最小比较

if（t->expo

{

min=t->expo;//每次记录最小的

minp=t;

}

}

h=deletenode（h,minp）;//删除保存最小的指数的节点返回剩余的

minp->next=head;//将每次的最小节点接在头结点之前

head=minp;//head重新回到该链开头

}

h->next=head;//把head接在头结点之后

returnh;

}

//显示多项式

voiddisplay_poly（duoxiangshi*p）

{

inta;

p=sort（p）;//排序

while（p->next!

=NULL）

{

a=1;

p=p->next;

if（p->coef<0）a=0;

a?

printf（"+"）:

printf（""）;

printf（"%.6f%c^%d",p->coef,p->ch,p->expo）;

}

printf（"\n"）;

}

//查找指数为index的节点

duoxiangshi*locate_link（duoxiangshi*p,intindex）

{

p=p->next;

while（p!

=NULL&&p->expo!

=index）

p=p->next;

if（p==NULL）

returnNULL;

else

returnp;

}

//多一元多项式求导

duoxiangshi*poly_qiudao（duoxiangshi*p）

{

duoxiangshi*n,*q;

q=p;

if（p->next==NULL）

{

printf（"链表中没有数据\n"）;

exit（0）;

}

while（p->next!

=NULL）

{

p=p->next;

if（p->expo==0||p->coef==0）

{

q=deletenode（q,p）;

}

}

n=q;//保存删除无用节点的链表之后的头结点，用于返回

//有可能删除后就没有数据了

if（q->next==NULL）

{

printf（"链表中没有数据\n"）;

exit（0）;

}

while（q->next!

=NULL）

{

q=q->next;

//求导特点

q->coef=q->coef*q->expo;

q->expo=q->expo-1;

}

returnn;

}

//创建多项式

voidcreat（duoxiangshi*&p1,duoxiangshi*&p2）

{

printf（"创建第一个多项式\n"）;

p1=creat_ploy（p1）;//创建多项式

printf（"创建第二个多项式\n"）;

p2=creat_ploy（p2）;//创建多项式

printf（"第一个多项式:

\n"）;

display_poly（p1）;

printf（"第二个多项式:

\n"）;

display_poly（p2）;

}

//多项式相加

duoxiangshi*poly_add（duoxiangshi*head1,duoxiangshi*head2,chara）

{

charch[1];

duoxiangshi*p1,*p2,*p,*r;

p1=head1;

p2=head2;

if（a=='+'）//只能是多项式的加法可以使用

{

system（"cls"）;

creat（p1,p2）;//创建p1,p2

}

r=p1;

while（r->next!

=NULL）

{

p1=r->next;

r=deletenode（r,p1）;//删除p1

p=locate_link（p2,p1->expo）;//查找p2中是否有系数等于p1->expn的节点，有就返回该点，否则返回NULL

if（p!

=NULL）

{

p->coef=p->coef+p1->coef;

}

else

{

p1->next=p2->next;

p2->next=p1;

}

}

if（a=='+'）

{

printf（"多项式相加后的结果是:

\n"）;

display_poly（p2）;

printf（"需要知道多项式求导后的结果吗？

:

Y/N\n"）;

scanf（"%s",ch）;

//继续创建

if（ch[0]=='Y'||ch[0]=='y'）

{

p2=poly_qiudao（p2）;

display_poly（p2）;//显示p2

destroy_link（p2）;//销毁链表

}

//不继续进行

else

{

destroy_link（p2）;//销毁链表

}

getchar（）;//吃掉输入的字符，让屏幕显示停在运算结果上

returnNULL;

}

returnp2;

}

//多项式相减可以重用多项式相加只是变了符号

voidpoly_sub（duoxiangshi*p1,duoxiangshi*p2）

{

charch[1];

duoxiangshi*n,*p;

system（"cls"）;//清屏

creat（p1,p2）;

p=p2;

//将后面的多项式全部相当于乘以-1

while（p->next!

=NULL）

{

p=p->next;

p->coef=-1*p->coef;

}

printf（"多项式的相减结果是:

\n"）;

n=poly_add（p1,p2,'-'）;

display_poly（n）;

printf（"需要知道多项式求导后的结果吗？

:

Y/N\n"）;

scanf（"%s",ch）;

if（ch[0]=='Y'||ch[0]=='y'）

{

n=poly_qiudao（n）;//求导

display_poly（n）;

destroy_link（n）;//销毁

}

else

destroy_link（n）;

getchar（）;

}

//多项式相乘的其中一个重用方法

duoxiangshi*poly_multiply（duoxiangshi*p,floatcoef,intindex）

{

//传入系数和指数，分别与p的每个节点运算最后返回该链

duoxiangshi*q,*n;

n=（duoxiangshi*）malloc（sizeof（duoxiangshi））;

//作为头节点

n->next=NULL;

while（p->next!

=NULL）

{

p=p->next;

q=（duoxiangshi*）malloc（sizeof（duoxiangshi））;

q->ch=p->ch;

q->coef=coef*p->coef;

q->expo=index+p->expo;

q->next=n->next;

n->next=q;

}

returnn;

}

//多项式相乘重用所用方法

voidrun_mul（duoxiangshi*p1,duoxiangshi*p2,intnum）

{

inti=0;

charch[1];

duoxiangshi**p,*q;

//二维指针存每次poly_multiply（）函数返回的链表

p=（duoxiangshi**）malloc（num*sizeof（duoxiangshi））;

//从p1的第一项开始依次乘以p2的每一项

while（p1->next!

=NULL）

{

p1=p1->next;

p[i++]=poly_multiply（p2,p1->coef,p1->expo）;

}

q=poly_add（p[0],p[1],'*'）;

for（i=2;i

{

q=poly_add（q,p[i],'*'）;

}

printf（"多项式相乘后的结果是:

\n"）;

display_poly（q）;

printf（"需要知道多项式求导后的结果吗？

:

Y/N\n"）;

scanf（"%s",ch）;

if（ch[0]=='Y'||ch[0]=='y'）

{

q=poly_qiudao（q）;//求导

display_poly（q）;

destroy_link（q）;//销毁

}

elsedestroy_link（q）;

getchar（）;

}

//多项式相乘时真正方法

voidpoly_mul（duoxiangshi*p1,duoxiangshi*p2）

{

intnum1=0,num2=0;

system（"cls"）;

creat（p1,p2）;

//求两个链表长度保存在mum1和mum2中

link_length（p1,num1）;

link_length（p2,num2）;

if（num2>=num1）/*根据链表*/

{

run_mul（p1,p2,num1）;

}

else

{

run_mul（p2,p1,num2）;

}

}

//选择函数

intselect（）

{

printf（"输入任何字符进入主菜单\n"）;

getchar（）;//读入字符但不显示

system（"cls"）;/*清屏*/

printf（"选择多项式的操作\n\n"）;

printf（"##################################\n"）;

printf（"1.多项式相加\n"）;

printf（"2.多项式相减\n"）;

printf（"3.多项式相乘\n"）;

printf（"4.退出\n"）;

printf（"##################################\n"）;

intn=0;

do

{

printf（"输入你的选择\n"）;

scanf（"%d",&n）;

}while（n<1||n>4）;//如果操作不对则一直循环

returnn;

}

intmain（）

{

duoxiangshi*head1=NULL;

duoxiangshi*head2=NULL;

duoxiangshi*head3=NULL;

//无限次死循环

for（;;）

{

switch（select（））

{

case1:

head3=poly_add（head1,head2,'+'）;break;

case2:

poly_sub（head1,head2）;break;

case3:

poly_mul（head1,head2）;break;

case4:

exit（0）;//退出

}

}

return0;

}