一元稀疏多项式简单计算器

如何设计“一个一元稀疏多项式简单计算器”？~

#include
#include
#include
#define N 40
typedef struct node{
int x,z;
struct node *next;
}*pnode;
int isnum(char c)
{
if(c>='0'&&c<='9') return 1;
else return 0;
}
pnode create(char *c,int i,int j)
{
if(j<i) return NULL;
int a=0,b=0,flag=0;
//处理系数。
if(!isnum(c[i])) a=1;
else
while(isnum(c[i])&&i<=j)
{
a=a*10+c[i]-'0';
i++;
}
//跳过系数与指数间非数字字符。
while(!isnum(c[i])&&i<=j)
{
flag=1;
i++;
}
//处理指数。
if(i>j&&flag==1) b=1;
else
{
if(c[i-1]=='-'&&c[i-2]=='^') flag=2;//指数是负数情况记录。
while(isnum(c[i])&&i<=j)
{
b=b*10+c[i]-'0';
i++;
}
}
if(flag==2) b=-b;//指数是负数情况处理。
pnode p;
p=(pnode)malloc(sizeof(node));
p->x=a;
p->z=b;
return p;
}//创建一个结点，表示多项式的一项。把"12X^3"这样字符串转化成一个只有系数、指数、后继的结构体。
pnode create_duo(char *c,int m)
{
if(c[m]=='\0') return NULL;
int i,j;
pnode p,q;
i=m;
if(c[i]=='+'||c[i]=='-')i++;
j=i;
while(c[j]!='\0'&&c[j]!='+'&&(c[j]!='-'||c[j-1]=='^'))
{
j++;
}//移动到多项式字符串的从下标m起第一项末。
if(c[i]!='0')
{
p=create(c,i,j-1);
if(i>0&&c[i-1]=='-') p->x=-(p->x);
q=create_duo(c,j);
p->next=q;
return p;
}
else
return create_duo(c,j); //系数为0项，不建立，跳过。
}//把一元多项式的字符串用链式存储。
pnode plus(pnode p,pnode q)
{
pnode P,H,t,m,n;
m=p;
n=q;
H=P=(pnode)malloc(sizeof(node));
while(m!=NULL&&n!=NULL)
{
t=(pnode)malloc(sizeof(node));
if(m->z>n->z)
{
t->x=m->x;
t->z=m->z;
m=m->next;
}
else
if(m->z==n->z)
{
if(m->x==-(n->x))
{
m=m->next;
n=n->next;
continue;
}//指数相同，系数相反，情况处理。
t->x=m->x+n->x;
t->z=n->z;
m=m->next;
n=n->next;
}
else
{
t->x=n->x;
t->z=n->z;
n=n->next;
}
P->next=t;
P=P->next;
}
while(m!=NULL)
{
t=(pnode)malloc(sizeof(node));
t->x=m->x;
t->z=m->z;
m=m->next;
P->next=t;
P=P->next;
}
while(n!=NULL)
{
t=(pnode)malloc(sizeof(node));
t->x=n->x;
t->z=n->z;
n=n->next;
P->next=t;
P=P->next;
}
P->next=NULL;
P=H;
H=H->next;
free(P);
return H;
}//两个一元多项式的相加。
pnode minus(pnode p,pnode q)
{
if(q==NULL) return p;
pnode t,h,g,q1;
t=q;
h=(pnode)malloc(sizeof(node));
h->x=-(t->x);
h->z=t->z;
t=t->next;
q1=h;
g=h;
while(t!=NULL)
{
h=(pnode)malloc(sizeof(node));
h->x=-(t->x);
h->z=t->z;
g->next=h;
g=g->next;
t=t->next;
}
g->next=NULL;
if(p==NULL) return q1;
return (plus(p,q1));
}//两个一元多项式的差。
pnode chen(pnode p,pnode q)
{
pnode k,h,t,g;
k=p;
t=(pnode)malloc(sizeof(node));
h=t;
h->x=(k->x)*(q->x);
h->z=k->z+q->z;
k=k->next;
g=h;
while(k!=NULL)
{
h=(pnode)malloc(sizeof(node));
h->x=(k->x)*(q->x);
h->z=k->z+q->z;
g->next=h;
g=g->next;
k=k->next;
}
g->next=NULL;
return t;
}//多项式中的一项与另一个多项式的乘。
pnode chenduo(pnode p1,pnode p2)
{
void free_pnode(pnode p);//释放一个链表空间。
if(p1==NULL||p2==NULL) return NULL;
pnode m,n,t,g;
n=p2;
t=NULL;
while(n!=NULL)
{
m=chen(p1,n);
g=plus(t,m);
free_pnode(m);
free_pnode(t);
t=g;
n=n->next;
}
return t;
}//两个多项式的乘。
void print(pnode p)
{
if(p==NULL)
{
cout<<"0"<<endl;
return;
}
while(p!=NULL)
{
if(p->x==-1&&p->z!=0)cout<<"-";
else if(p->x!=1||p->z==0)
coutx;
if(p->z)
{
cout<<"X";
if(p->z!=1)
coutz;
}
p=p->next;
if(p!=NULL&&p->x>0) cout<<"+";
}
cout<<endl;
}//输出链式存储多项式。
void main()
{
cout<<"****************************************************************************"<<endl;
cout<<"***********************一元多项式的计算(和差积)*****************************"<<endl;
cout<<"****************************************************************************"<<endl;
char ch1[N];//="30X^45-X-9";
char ch2[N];//="-4X^3-2X+1";
int n=1;
pnode p1,p2;
cout<<"输入第一个多项式(行式如.22X^31+X^22+X-1):
";
cin>>ch1;
p1=create_duo(ch1,0);
cout<<"输入第二个多项式(行式如.22X^31+X^24+X-1):
";
cin>>ch2;
p2=create_duo(ch2,0);
cout<<"多项式p1：";
print(p1);
cout<<"多项式p2：";
print(p2);
cout<<"******************************************"<<endl;
cout<<"********* 用 户 选 择 ************"<<endl;
cout<<"********* ************"<<endl;
cout<<"********* 1 . 两 多 项 式 和 ************"<<endl;
cout<<"********* ************"<<endl;
cout<<"********* 2 . 两 多 项 式 差 ************"<<endl;
cout<<"********* ************"<<endl;
cout<<"********* 3 . 两 多 项 式 积 ************"<<endl;
cout<<"********* ************"<<endl;
cout<<"********* 0 . 退 出 ************"<<endl;
cout<<"********* ************"<<endl;
cout<<"******************************************"<<endl;
while(n)
{ cout<<"请输入你的选择：";
cin>>n;
switch(n)
{
case 1:
cout<<"两多项式和(p1+p2)为：";
print(plus(p1,p2));
break;
case 2:
cout<<"两多项式差(p1-p2)为：";
print(minus(p1,p2));
break;
case 3:
cout<<"两多项式积(p1*p2)为：";
print(chenduo(p1,p2));
break;
default: cout<<" 错误选择！ "<<endl;
}
}
}

void free_pnode(pnode p)
{
pnode t;
while(p!=NULL)
{
t=p;
p=p->next;
free(t);
}
}
采纳吧，100%能用，我测试过了

#include
#include
#include
typedef struct Polynode
{
float coef; //系数
int exp; //指数
struct Polynode *next;
}*Poly,Polynode; //Poly为结点指针类型void Insert(Poly p,Poly head)
{
if(p->coef==0) //系数为0时释放结点
free(p);
else
{
Poly q1,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;
}
}
}//InsertPoly CreateList(Poly head,int m)
{ //建立一个头指针为head、项数为m的一元多项式
int i;
Poly p;
Polynode *q;
p=head=(Poly)malloc(sizeof(struct Polynode));
head->next=NULL;
for(i=0;i<m;i++)
{
p=(Poly)malloc(sizeof(struct Polynode));//建立新结点以接收数据
cout<<"请输入第"<<i+1<<"项的系数与指数: ";
cin>>p->coef>>p->exp;
Insert(p,head); //调用Insert函数插入结点
}
q=head->next;
while(q!=NULL)
{
coutcoefexp<<endl;
q=q->next;
}
return head;
}//CreatePolyvoid DestroyList(Poly p)
{ //销毁多项式p
Poly q1,q2;
if(p->next!=NULL)
{
q1=p->next;
q2=q1->next;
while(q1->next)
{
free(q1);
q1=q2;//指针后移
q2=q2->next;
}
}

}int OutputList(Poly P)
{ //输出多项式
Poly q=P->next;
int flag=1;//项数计数器
if(!q)
{ //若多项式为空，输出0
cout<<" 0 "<<endl;
return(0);
}
while (q)
{
if(q->coef>0&&flag!=1) //系数大于0且不是第一项
cout<<"+";
if(q->coef!=1&&q->coef!=-1)//系数非1或-1的普通情况
{
coutcoef;
if(q->exp==1)
cout<<"X";
else if(q->exp)
coutexp;
}
else
{
if(q->coef==1)
{
if(!q->exp)
cout<<"1";
else if(q->exp==1)
cout<<"X";
else if(q->exp)
coutexp;
}
if(q->coef==-1)
{
if(!q->exp) cout<<"-1";
else if(q->exp==1) cout<<"-X";
else coutexp;
}
}
q=q->next;
flag++;
}//while
cout<<endl;
return(0);
}//OutputPolyint compare(Poly a,Poly b)
{
if(a&&b)
{
if(!b||a->exp>b->exp) return 1;
else if(!a||a->expexp) return -1;
else return 0;
}
else if(!a&&b) return -1;//a多项式已空，但b多项式非空
else return 1;//b多项式已空，但a多项式非空
}//comparePoly AddPoly(Poly pa,Poly pb)
{//求解并建立和多项式a+b，返回其头指针
Poly qa=pa->next;
Poly qb=pb->next;
Poly headc,hc,qc;
hc=(Poly)malloc(sizeof(struct Polynode));//建立头结点
hc->next=NULL;
headc=hc;
while(qa||qb){
qc=(Poly)malloc(sizeof(struct Polynode));
switch(compare(qa,qb))
{
case 1:
{
qc->coef=qa->coef;
qc->exp=qa->exp;
qa=qa->next;
break;
}
case 0:
{
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;
}
else free(qc);//当相加系数为0时，释放该结点
}//while
return headc;
}//AddPolyPoly SubtractPoly(Poly pa,Poly pb)
{//求解并建立和多项式a-b，返回其头指针
Poly qa=pa->next;
Poly qb=pb->next;
Poly headc,hc,qc;
hc=(Poly)malloc(sizeof(struct Polynode));//建立头结点
hc->next=NULL;
headc=hc;
while(qa||qb)
{
qc=(Poly)malloc(sizeof(struct Polynode));
switch(compare(qa,qb))
{
case 1:
{
qc->coef=qa->coef;
qc->exp=qa->exp;
qa=qa->next;
break;
}
case 0:
{
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;
}
else free(qc);//当相减系数为0时，释放该结点
}//while
return headc;
}//AddPolyPoly MultiplyPoly(Poly pa,Poly pb)
{//求解并建立积多项式a*b，返回其头指针
Poly hf,pf;
Poly qa=pa->next;
Poly qb=pb->next;
hf=(Poly)malloc(sizeof(struct Polynode));//建立头结点
hf->next=NULL;
for(qa=pa->next;qa;qa=qa->next)
{
for(qb=pb->next;qb;qb=qb->next)
{
pf=(Poly)malloc(sizeof(struct Polynode));
pf->coef=qa->coef*qb->coef;
pf->exp=qa->exp+qb->exp;
Insert(pf,hf);//调用Insert函数以合并指数相同的项
}
}
return hf;
}//MultiplyPolyvoid DevicePoly(Poly pa,Poly pb)
{//求解并建立商多项式a/b，返回其头指针
Poly hf,pf,temp1,temp2;
Poly qa=pa->next;
Poly qb=pb->next;
hf=(Poly)malloc(sizeof(struct Polynode));//建立头结点,存储商
hf->next=NULL;
pf=(Poly)malloc(sizeof(struct Polynode));//建立头结点，存储余数
pf->next=NULL;
temp1=(Poly)malloc(sizeof(struct Polynode));
temp1->next=NULL;
temp2=(Poly)malloc(sizeof(struct Polynode));
temp2->next=NULL;
temp1=AddPoly(temp1,pa);
while(qa!=NULL&&qa->exp>=qb->exp)
{
temp2->next=(Poly)malloc(sizeof(struct Polynode));
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);
}//DevicePolyfloat ValuePoly(Poly head,float x)
{//输入x值，计算并返回多项式的值
Poly p;
int i;
float sum=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;
}
return sum;
}//ValuePolyPoly Derivative(Poly head)
{//求解并建立a的导函数多项式，并返回其头指针
Poly q=head->next,p1,p2,hd;
hd=p1=(Poly)malloc(sizeof(struct Polynode));//建立头结点
hd->next=NULL;
while(q)
{
if(q->exp!=0)
{ //该项不是常数项时
p2=(Poly)malloc(sizeof(struct Polynode));
p2->coef=q->coef*q->exp;
p2->exp=q->exp-1;
p2->next=p1->next;//尾插法插入结点
p1->next=p2;
p1=p2;
}
else if(q->exp==0) //该项为常数项
break;
q=q->next;
}
return hd;
}//Dervativeint main()
{
int m,n,flag=0;
float x;
Poly pa=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<<"*********************************************************************"<<endl;
cout<<" 1.输出多项式a和b 2.建立多项式a+b 3.建立多项式a-b"<<endl;
cout<<" 4.建立多项式a*b 5.建立多项式a/b"<<endl;
cout<<" 6.计算多项式a在x处的值 7.求多项式a的导函数 8.退出程序"<<endl;
cout<<"*********************************************************************"<<endl;
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的值为:"<<ValuePoly(pa,x)<<endl;
continue;
}
if(flag==7)
{
pf=Derivative(pa);
cout<<"多项式a的导函数为：";
OutputList(pf);
DestroyList(pf);
continue;
}
if(flag==8)
break;
if(flag8)
cout<<"输入错误!!!请重新选择!!";
continue;
}
DestroyList(pa);
DestroyList(pb);
return 0;
}

除以上功能外，还有乘法和除法的计算和导数计算呢。
这是我以前做的数据结构课程设计。希望能帮上你的忙。

#include<stdio.h>
#include<malloc.h>
typedef struct Polynomial{
float coef;
int expn;
struct Polynomial *next;
}*Polyn,Polynomial; //Polyn为结点指针类型
void Insert(Polyn p,Polyn h){
if(p->coef==0) free(p); //系数为0的话释放结点
else{
Polyn q1,q2;
q1=h;q2=h->next;
while(q2&&p->expn<q2->expn){ //查找插入位置
q1=q2;
q2=q2->next;
}
if(q2&&p->expn==q2->expn){ //将指数相同相合并
q2->coef+=p->coef;
free(p);
if(!q2->coef){ //系数为0的话释放结点
q1->next=q2->next;
free(q2);
}
}
else{ //指数为新时将结点插入
p->next=q2;
q1->next=p;
}
}
}//Insert
Polyn CreatePolyn(Polyn head,int m){//建立一个头指针为head、项数为m的一元多项式
int i;
Polyn p;
p=head=(Polyn)malloc(sizeof(struct Polynomial));
head->next=NULL;
for(i=0;i<m;i++){
p=(Polyn)malloc(sizeof(struct Polynomial));//建立新结点以接收数据
printf("请输入第%d项的系数与指数:",i+1);
scanf("%f %d",&p->coef,&p->expn);
Insert(p,head); //调用Insert函数插入结点
}
return head;
}//CreatePolyn
void DestroyPolyn(Polyn p){//销毁多项式p
Polyn q1,q2;
q1=p->next;
q2=q1->next;
while(q1->next){
free(q1);
q1=q2;//指针后移
q2=q2->next;
}
}
void PrintPolyn(Polyn P){
Polyn q=P->next;
int flag=1;//项数计数器
if(!q) { //若多项式为空，输出0
putchar('0');
printf("\n");
return;
}
while (q){
if(q->coef>0&&flag!=1) putchar('+'); //系数大于0且不是第一项
if(q->coef!=1&&q->coef!=-1){//系数非1或-1的普通情况
printf("%g",q->coef);
if(q->expn==1) putchar('X');
else if(q->expn) printf("X^%d",q->expn);
}
else{
if(q->coef==1){
if(!q->expn) putchar('1');
else if(q->expn==1) putchar('X');
else printf("X^%d",q->expn);
}
if(q->coef==-1){
if(!q->expn) printf("-1");
else if(q->expn==1) printf("-X");
else printf("-X^%d",q->expn);
}
}
q=q->next;
flag++;
}//while
printf("\n");
}//PrintPolyn
int compare(Polyn a,Polyn b){
if(a&&b){
if(!b||a->expn>b->expn) return 1;
else if(!a||a->expn<b->expn) return -1;
else return 0;
}
else if(!a&&b) return -1;//a多项式已空，但b多项式非空
else return 1;//b多项式已空，但a多项式非空
}//compare
Polyn AddPolyn(Polyn pa,Polyn pb){//求解并建立多项式a+b，返回其头指针
Polyn qa=pa->next;
Polyn qb=pb->next;
Polyn headc,hc,qc;
hc=(Polyn)malloc(sizeof(struct Polynomial));//建立头结点
hc->next=NULL;
headc=hc;
while(qa||qb){
qc=(Polyn)malloc(sizeof(struct Polynomial));
switch(compare(qa,qb)){
case 1:
{
qc->coef=qa->coef;
qc->expn=qa->expn;
qa=qa->next;
break;
}
case 0:
{
qc->coef=qa->coef+qb->coef;
qc->expn=qa->expn;
qa=qa->next;
qb=qb->next;
break;
}
case -1:
{
qc->coef=qb->coef;
qc->expn=qb->expn;
qb=qb->next;
break;
}
}//switch
if(qc->coef!=0){
qc->next=hc->next;
hc->next=qc;
hc=qc;
}
else free(qc);//当相加系数为0时，释放该结点
}//while
return headc;
}//AddPolyn
Polyn SubtractPolyn(Polyn pa,Polyn pb){//求解并建立多项式a+b，返回其头指针
Polyn h=pb;
Polyn p=pb->next;
Polyn pd;
while(p){ //将pb的系数取反
p->coef*=-1;
p=p->next;
}
pd=AddPolyn(pa,h);
for(p=h->next;p;p=p->next) //恢复pb的系数
p->coef*=-1;
return pd;
}//SubtractPolyn
float ValuePolyn(Polyn head,float x){//输入x值，计算并返回多项式的值
Polyn p;
int i;
float sum=0,t;
for(p=head->next;p;p=p->next){
t=1;
for(i=p->expn;i!=0;){
if(i<0){t/=x;i++;}//指数小于0，进行除法
else{t*=x;i--;}//指数大于0，进行乘法
}
sum+=p->coef*t;
}
return sum;
}//ValuePolyn
Polyn Derivative(Polyn head){//求解并建立a的导函数多项式，并返回其头指针
Polyn q=head->next,p1,p2,hd;
hd=p1=(Polyn)malloc(sizeof(struct Polynomial));//建立头结点
hd->next=NULL;
while(q){
if(q->expn!=0){ //该项不是常数项时
p2=(Polyn)malloc(sizeof(struct Polynomial));
p2->coef=q->coef*q->expn;
p2->expn=q->expn-1;
p2->next=p1->next;//连接结点
p1->next=p2;
p1=p2;
}
q=q->next;
}
return hd;
}//Dervative
Polyn MultiplyPolyn(Polyn pa,Polyn pb){//求解并建立多项式a*b，返回其头指针
Polyn hf,pf;
Polyn qa=pa->next;
Polyn qb=pb->next;
hf=(Polyn)malloc(sizeof(struct Polynomial));//建立头结点
hf->next=NULL;
for(;qa;qa=qa->next){
for(qb=pb->next;qb;qb=qb->next){
pf=(Polyn)malloc(sizeof(struct Polynomial));
pf->coef=qa->coef*qb->coef;
pf->expn=qa->expn+qb->expn;
Insert(pf,hf);//调用Insert函数以合并指数相同的项
}
}
return hf;
}//MultiplyPolyn
void DevicePolyn(Polyn pa,Polyn pb){//求解并建立多项式a*b，返回其头指针
Polyn hf,pf,af,temp1,temp2,q;
Polyn qa=pa->next;
Polyn qb=pb->next;
hf=(Polyn)malloc(sizeof(struct Polynomial));//建立头结点,存储商
hf->next=NULL;
pf=(Polyn)malloc(sizeof(struct Polynomial));//建立头结点，存储余数
pf->next=NULL;
temp1=(Polyn)malloc(sizeof(struct Polynomial));
temp1->next=NULL;
temp2=(Polyn)malloc(sizeof(struct Polynomial));
temp2->next=NULL;
temp1=AddPolyn(temp1,pa);
while(qa!=NULL&&qa->expn>=qb->expn){
temp2->next=(Polyn)malloc(sizeof(struct Polynomial));
temp2->next->coef=(qa->coef)/(qb->coef);
temp2->next->expn=(qa->expn)-(qb->expn);
Insert(temp2->next,hf);
pa=SubtractPolyn(pa,MultiplyPolyn(pb,temp2));
qa=pa->next;
temp2->next=NULL;
}
pf=SubtractPolyn(temp1,MultiplyPolyn(hf,pb));
pb=temp1;
printf("商是：");
PrintPolyn(hf);
printf("余数是：");
PrintPolyn(pf);
}//DevicePolyn

int main(){
int m,n,flag=0;
float x;
Polyn pa=0,pb=0,pc,pd,pe,pf;//定义各式的头指针，pa与pb在使用前付初值NULL
printf("请输入a的项数:");
scanf("%d",&m);
pa=CreatePolyn(pa,m);//建立多项式a
printf("请输入b的项数:");
scanf("%d",&n);
pb=CreatePolyn(pb,n);//建立多项式a
//输出菜单
printf("**********************************************\n");
printf("操作提示：\n\t1.输出多项式a和b\n\t2.建立多项式a+b\n\t3.建立多项式a-b\n");
printf("\t4.计算多项式a在x处的值\n\t5.求多项式a的导函数\n\t6.建立多项式a*b\n");
printf("\t7.建立多项式a/b\n\t8.退出\n**********************************************\n");
for(;;flag=0){
printf("执行操作");
scanf("%d",&flag);
if(flag==1){
printf("多项式a：");PrintPolyn(pa);
printf("多项式b：");PrintPolyn(pb);continue;
}
if(flag==2){
pc=AddPolyn(pa,pb);
printf("多项式a+b：");PrintPolyn(pc);
DestroyPolyn(pc);continue;
}
if(flag==3){
pd=SubtractPolyn(pa,pb);
printf("多项式a-b：");PrintPolyn(pd);
DestroyPolyn(pd);continue;
}
if(flag==4){
printf("输入x的值：x=");
scanf("%f",&x);
printf("多项式a的值%g\n",ValuePolyn(pa,x));continue;
}
if(flag==5){
pe=Derivative(pa);
printf("多项式a的导函数：");PrintPolyn(pe);
DestroyPolyn(pe);continue;
}
if(flag==6){
pf=MultiplyPolyn(pa,pb);
printf("多项式a*b：");PrintPolyn(pf);
DestroyPolyn(pf);continue;
}
if(flag==7){
DevicePolyn(pa,pb);
continue;
}
if(flag==8) break;
if(flag<1||flag>8) printf("Error!!!\n");continue;
}//for
DestroyPolyn(pa);
DestroyPolyn(pb);
return 0;
}

---

一元稀疏多项式简单计算器视频