一元多项式计算顺序存储设计报告

㈠ 一元稀疏多项式计算器的课程设计（数据结构）

//头文件
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>

//定义多项式的项
typedefstructPolynomial{
floatcoef;
intexpn;
structPolynomial*next;
}*Polyn,Polynomial;

voidInsert(Polynp,Polynh){
if(p->coef==0)free(p);//系数为0的话释放结点
else
{
Polynq1,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;
}
}
}

PolynCreatePolyn(Polynhead,intm){
//建立一个头指针为head、项数为m的一元多项式
inti;
Polynp;
p=head=(Polyn)malloc(sizeof(structPolynomial));
head->next=NULL;
for(i=0;i<m;i++)
{
p=(Polyn)malloc(sizeof(structPolynomial));//建立新结点以接收数据
printf("请输入第%d项的系数与指数:",i+1);
scanf("%f%d",&p->coef,&p->expn);
Insert(p,head);//调用Insert函数插入结点
}
returnhead;
}

voidDestroyPolyn(Polynp){
//销毁多项式p
Polynq1,q2;
q1=p->next;
q2=q1->next;
while(q1->next)
{
free(q1);
q1=q2;
q2=q2->next;
}
}

voidPrintPolyn(PolynP){
Polynq=P->next;
intflag=1;//项数计数器
if(!q)
{//若多项式为空，输出0
putchar('0');
printf("
");
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');
elseif(q->expn)printf("X^%d",q->expn);
}
else
{
if(q->coef==1)
{
if(!q->expn)putchar('1');
elseif(q->expn==1)putchar('X');
elseprintf("X^%d",q->expn);
}
if(q->coef==-1)
{
if(!q->expn)printf("-1");
elseif(q->expn==1)printf("-X");
elseprintf("-X^%d",q->expn);
}
}
q=q->next;
flag++;
}
printf("
");
}

intcompare(Polyna,Polynb){
if(a&&b)
{
if(!b||a->expn>b->expn)return1;
elseif(!a||a->expn<b->expn)return-1;
elsereturn0;
}
elseif(!a&&b)return-1;//a多项式已空，但b多项式非空
elsereturn1;//b多项式已空，但a多项式非空
}

PolynAddPolyn(Polynpa,Polynpb){//求解并建立多项式a+b，返回其头指针
Polynqa=pa->next;
Polynqb=pb->next;
Polynheadc,hc,qc;
hc=(Polyn)malloc(sizeof(structPolynomial));//建立头结点
hc->next=NULL;
headc=hc;
while(qa||qb)
{
qc=(Polyn)malloc(sizeof(structPolynomial));
switch(compare(qa,qb)){
case1:
{
qc->coef=qa->coef;
qc->expn=qa->expn;
qa=qa->next;
break;
}
case0:
{
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;
}
}
if(qc->coef!=0)
{
qc->next=hc->next;
hc->next=qc;
hc=qc;
}
elsefree(qc);//当相加系数为0时，释放该结点
}
returnheadc;
}

PolynSubtractPolyn(Polynpa,Polynpb){//求解并建立多项式a-b，返回其头指针
Polynh=pb;
Polynp=pb->next;
Polynpd;
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;
returnpd;
}

intValuePolyn(Polynhead,intx){
//输入x值，计算并返回多项式的值
Polynp;
inti;
intsum=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;
}
returnsum;
}

PolynDerivative(Polynhead){
//求解并建立导函数多项式，并返回其头指针
Polynq=head->next,p1,p2,hd;
hd=p1=(Polyn)malloc(sizeof(structPolynomial));//建立头结点
hd->next=NULL;
while(q)
{
if(q->expn!=0)
{//该项不是常数项时
p2=(Polyn)malloc(sizeof(structPolynomial));
p2->coef=q->coef*q->expn;
p2->expn=q->expn-1;
p2->next=p1->next;//连接结点
p1->next=p2;
p1=p2;
}
q=q->next;
}
returnhd;
}

PolynMultiplyPolyn(Polynpa,Polynpb){
//求解并建立多项式a*b，返回其头指针
Polynhf,pf;
Polynqa=pa->next;
Polynqb=pb->next;
hf=(Polyn)malloc(sizeof(structPolynomial));//建立头结点
hf->next=NULL;
for(;qa;qa=qa->next)
{
for(qb=pb->next;qb;qb=qb->next)
{
pf=(Polyn)malloc(sizeof(structPolynomial));
pf->coef=qa->coef*qb->coef;
pf->expn=qa->expn+qb->expn;
Insert(pf,hf);//调用Insert函数以合并指数相同的项
}
}
returnhf;
}

voidmain()
{
intm,n,a,x;
charflag;
Polynpa=0,pb=0,pc;

printf("欢迎使用多项式操作程序

");
printf("请输入a的项数:");
scanf("%d",&m);
pa=CreatePolyn(pa,m);//建立多项式a
printf("请输入b的项数:");
scanf("%d",&n);
pb=CreatePolyn(pb,n);//建立多项式b

//输出菜单
printf("*******************************************************
");
printf("*多项式操作程序*
");
printf("**
");
printf("*A:输出多项式B:输出多项式b*
");
printf("**
");
printf("*C:输出a的导数D:输出b的导数*
");
printf("**
");
printf("*E:代入x的值计算aF:代入x的值计算b*
");
printf("**
");
printf("*G:输出a+bH:输出a-b*
");
printf("**
");
printf("*I:输出a*bJ:退出程序*
");
printf("**
");
printf("*******************************************************
");

while(a)
{
printf("
请选择操作：");
scanf("%c",&flag);//空格符号一定要注意
switch(flag)
{

case'A':
case'a':
{
printf("
多项式a=");
PrintPolyn(pa);
break;
}
case'B':
case'b':
{
printf("
多项式b=");
PrintPolyn(pb);
break;
}
case'C':
case'c':
{
pc=Derivative(pa);
printf("
多项式a的导函数为：a'=");
PrintPolyn(pc);
break;
}
case'D':
case'd':
{
pc=Derivative(pb);
printf("
多项式b的导函数为：b'=");
PrintPolyn(pc);
break;
}
case'E':
case'e':
{
printf("输入x的值：x=");
scanf("%d",&x);
printf("
x=%d时，a=%d
",x,ValuePolyn(pa,x));
break;
}
case'F':
case'f':
{
printf("输入x的值：x=");
scanf("%d",&x);
printf("
x=%d时，b=%d
",x,ValuePolyn(pb,x));
break;
}
case'G':
case'g':
{
pc=AddPolyn(pa,pb);
printf("
a+b=");
PrintPolyn(pc);
break;
}
case'H':
case'h':
{
pc=SubtractPolyn(pa,pb);
printf("
a-b=");
PrintPolyn(pc);
break;
}
case'I':
case'i':
{
pc=MultiplyPolyn(pa,pb);
printf("
a*b=");
PrintPolyn(pc);
break;
}
case'J':
case'j':
{
printf("
感谢使用此程序！
");
DestroyPolyn(pa);
DestroyPolyn(pb);
a=0;
break;
}
default:
printf("
您的选择错误，请重新选择!
");
}
}
}

把楼上的回答用代码格式重新排版了一下，方便阅读

㈡ 基本内容：设计一个一元稀疏多项式简单计算器。输入并建立多项式、按指数降序输出多项式、多项式相加、多

#include <iostream.h>
#include<string.h>
#include<malloc.h>
#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_o(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_o(c,j);
p->next=q;
return p;
}
else
return create_o(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 cheno(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)
cout<<p->x;
if(p->z)
{
cout<<"X";
if(p->z!=1)
cout<<"^"<<p->z;
}
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):\n";
cin>>ch1;
p1=create_o(ch1,0);
cout<<"输入第二个多项式(行式如.22X^31+X^24+X-1):\n";
cin>>ch2;
p2=create_o(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(cheno(p1,p2));
break;
default: cout<<" 错误选择！ "<<endl;
}
}
}

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

㈢ 程序设计 一元多项式

一个用数组的程序，这个我已在win-tc下调试通过。数据用数组存放，是顺序存储结构，没有使用链表。使用链表的程序我也有，但还需要完善。这题只是多项式的加法，所以算法很简单的，应该多看看下面的乘法的算法。
/*
本题的一个完整的c程序如下，在win-tc和Dev-c++下调试通过。
需要说明的是这里的m,n表示x的幂分别是m-1次和n-1次,
同时p[]和q[]的各系数是从x^(m-1)和x^(n-1)到x^0前的系数，
比如px=3x^3+2x+1,qx=x^2-11x+3，那么m=4,n=3，px和qx的系数分别为
3,0,2,1和1,-11,3
*/
/*多项式加法程序*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define MAX 50

void npadd(double p[],int m,double q[],int n,double s[])
{
int i,j;
for(i=0;i<m-n;i++)
s[i]=p[i]; /*计算各项系数，将幂指数高的多项式中高出的各项系数先复制到数组s[]中*/
for (i=m-n,j=0; i<=m-1; i++,j++)
s[i]=p[i]+q[j]; /*计算各项系数，剩下的幂指数相同的各项系数对应相加，减法运算只要将这里的加号改成减号即可*/
return;
}

double compute(double s[],int k,double x) /*计算所给多项式的值*/
{
int i;
double multip = 1,sum = 0;
for (i=0;i<k-1;i++)
multip = multip * x; /*先求出x的最高次项的值*/
for (i=0;i<=k-1;i++)
{
sum = sum + s[i] * multip; /*依次从高到低求出相对应次项的值*/
if (x!=0)
multip = multip / x;
}
return sum;
}

int main()
{
int i,j,m,n;
double px[MAX],qx[MAX],rx[MAX],x;
system("cls");
for(i=0;i<MAX;i++)
rx[i]=0;
puts("Please input two polynomials one by one");
puts("P(x)=Pm-1*x^(m-1)+Pm-2*x^(m-2)+...+P1*x+P0");
puts("Q(x)=Qn-1*x^(n-1)+Qn-2*x^(n-2)+...+Q1*x+Q0");
printf("\nPlease input m (>=1): ");
scanf("%d",&m);
printf("Please input P%d, ... P0 one by one:\n",m-1);
for(i=0;i<m;i++)
scanf("%lf",&px[i]);
printf("\nPlease input n (1=<n<=m): ");/* 为简化程序设幂次数低的后输入 */
scanf("%d",&n);
printf("Please input Q%d, ... Q0 one by one:\n",n-1);
for(i=0;i<n;i++)
scanf("%lf",&qx[i]);
npadd(px,m,qx,n,rx);
printf("\nThe addition of two polynomials R(x) is :\n");
for (i=m,j=0;i>=1;i--) /*逐行逐项打印出结果多项式*/
{
printf(" (%f*x^%d) ",rx[m-i],i-1);
if(i-1>0)
printf(" + ");
else
printf(" . ");
if(j==2)
{
printf("\n");
j=0;
}
else
j++;
}
printf("\n");
printf("Input the value of x: ");
scanf("%lf",&x);
printf("\nThe value of the R(%f) is: %13.7f\n",x,compute(rx,m,x));
system("pause");
return 0;
}
用数组表示的相乘的地址如下：
http://..com/question/76281392.html
用链表的网上有，给你个链接，但是正确性我不能保证：
http://..com/question/80603134.html

㈣ 如何用C语言实现一元多项式简单计算器的设计

/*:--------------一元稀疏多项式计算（部分）--------------*
* 基本功能：(1)输入并建立多项式； *
* (2)多项式输出,以 c1,e1,c2,e2,...输出 *
* 其中ci为系数，ei为指数； *
* (3)多项式相加，c=a+b。 *
* 说明： (1)多项式一指数升序排序，但输入时不检查； *
* (2)以带头指针的单链表存储。 *
*-------------------------------------------------------*/
#define OK 1
#define FAILE 0
#define ERROR 0
#define OVERFLOW 0

#include <iostream>
using namespace std;

typedef struct PolynNode { /*某一项*/
double coef; /*系数*/
int expn; /*指数*/
} ElemType,term;

typedef struct LNode {
ElemType data;
struct LNode *next;
}LNode,*LinkList;

typedef LinkList Polyn; /*带头结点*/

int init_polyn(Polyn head,int n)
{/*创建有n项的多项式,n应大于0，但不作检查*/
/*指数e1<e2<e3...,但不作检查，间隔地输入系数与指数，即c1 e1 ...*/
Polyn p,q = head;
double coef;
int expn,count;

if(head == NULL)
return ERROR;

if((p = (Polyn)malloc(sizeof(LNode))) == NULL)
return OVERFLOW;
printf("Please input n pairs of coef and expn.\n");
for(count = 0;count < n;count++) {
q->next = p;
q = p;
scanf("%f%d",&coef,&expn);
p->data.coef = coef;
p->data.expn = expn;
if((p = (Polyn)malloc(sizeof(LNode))) == NULL)
return OVERFLOW;
}
q->next = NULL;/*尾*/
return OK;
}
int print_polyn(Polyn head)
{/*输出*/
Polyn p=head->next;
int count;

if(head == NULL)
return ERROR;

while(p != NULL) {
printf("%.4lf % 3d",p->data.coef,p->data.expn);
count++;
if((count % 10 == 0) && (!count))
printf("\n");
p = p->next;
}
return OK;
}
int add_polyn(Polyn ha,Polyn hb,Polyn hc)
{/*多项式相加*/
Polyn p1 = ha,p2 = ha,q1 = hb,q2 = hb;
hc = ha;

while( (p1 != NULL) && (q1 != NULL)) {
if(p1->data.expn < q1->data.expn) { /*p1指数<q1指数*/
p2 = p1;
p1 = p1->next;
}
else {
if(p1->data.expn == q1->data.expn) { /*q1指数==p1指数*/
if(!(p1->data.coef + q1->data.coef)) {/*系数之和为0*/
p1 = p1->next;
free(p2->next);
p2->next = p1;
q1 = q1->next;
free(q2->next);
q2->next =q1;
}
else { /*系数之和不为0*/
p1->data.coef += q1->data.coef;
p2 = p1;
p1 = p1->next;
q1 = q1->next;
free(q2->next);
q2->next =q1;
}
}
else { /*q1指数<p1指数*/
p2->next = q1;
q1->next = p1;
p2 = p2->next;
q1 = q1->next;
q2->next = q1;
}
}
}
if(p1 == NULL) { /*p1结束了，q1未结束*/
p2->next = q1;
}
ha->next = NULL;
free(ha);
free(hb);
return OK;
}

int main()
{
int creat_polyn(Polyn head);
int init_polyn(Polyn head,int n);
int print_polyn(Polyn head);
int add_polyn(Polyn ha,Polyn hb,Polyn hc);

LNode polyn1,polyn2;
Polyn ha = &polyn1,hb = &polyn2,hc;
int n;

printf("How many terms do you want to initial the polynomial ha?Input a number.\n");
scanf("%d",&n);
init_polyn(ha,n);
print_polyn(ha);
printf("How many terms do you want to initial the polynomial hb?Input a number.\n");
scanf("%d",&n);
init_polyn(hb,n);
print_polyn(hb);
add_polyn(ha,hb,hc);
print_polyn(hc);

return 0;
}

㈤ 一元多项式的运算 程序功能简介: 一元多项式的加法、减法和乘法的实现，已知如下两个多项式

dim x as int
dim i as int
//记录p(x)
for (i<x-1;i++);//数组是从0开始的所以成员数上限是x-1
p(i)=p*i+p*i+p
Q(i)=q*i+q*i+q
s(i)=p(i)
S(x+i)=S(i)
next
大概就是这样

㈥ C语言课程设计 急求！ 100悬赏！！多项式计算（用数组储存）！

#include<stdio.h>
#defineN10
//字符串s按c字符分隔成小字符串t
intsplit(char*s,chart[][20],charc){
	inti=0,k=0,ii;
	while(s[i]!=0){
		while(s[i]==c&&s[i]!=0)i++;
		if(s[i]==0)break;
		ii=i;
		while(s[i]!=c&&s[i]!=0){
			t[k][i-ii]=s[i];
			i++;
		}
		t[k][i-ii]=0;
		k++;
	}
	returnk;
}
//输入多项式
voidinput(floata[],intn){
	chars[200]="1234";
	chart[N][20];
	intm,i;
	printf("请在一行内输入多项式各系数
");
	fflush(stdin);//清除输入缓冲
	gets(s);
	m=split(s,t,'');//把s以''为分隔为数组
	for(i=0;i<n-m;i++)a[i]=0;
	for(i=n-m;i<n;i++){
		sscanf(t[i-n+m],"%f",&a[i]);
	}
}

//输出多项式
voidprintit(floata[],intn){
	inti=0;
	while(a[i]==0&&i<n-1)i++;
	for(;i<n;i++)
		printf("%.2f",a[i]);
}

voidmenu(){//显示主菜单
	printf("============================================
");
	printf("1.多项式加法
");
	printf("2.多项式减法
");
	printf("3.多项式乘法
");
	printf("0.退出
");
	printf("请选择：");
}
//多项式相加
voidaddit(floata[],floatb[],floatc[],intn){
	inti;
	for(i=0;i<2*n;i++)c[i]=0;
	for(i=0;i<n;i++)
		c[n+i]=a[i]+b[i];
}
//多项式相减
voidsubit(floata[],floatb[],floatc[],intn){
	inti;
	for(i=0;i<2*n;i++)c[i]=0;
	for(i=0;i<n;i++)
		c[n+i]=a[i]-b[i];
}
//多项式相乘
voidmulit(floata[],floatb[],floatc[],intn){
	inti,j;
	for(i=0;i<2*n;i++)c[i]=0;
	for(i=0;i<n;i++)
	for(j=0;j<n;j++)
		c[i+j+1]+=a[i]*b[j];
}
intmain(){
	floata[N],b[N],c[N*2];
	intx;
	printf("多项式运算，运算项数<=%d项
",N);
	while(1){
		menu();
		fflush(stdin);//清除输入缓冲
		scanf("%d",&x);
		switch(x){
			case1:
				printf("输入第一个多项式，");
				input(a,N);
				printf("输入第二个多项式，");
				input(b,N);
				addit(a,b,c,N);//多项式相加
				printf("相加的结果是:
");
				printit(c,2*N);//输出结果
				printf("
");
				break;
			case2:
				printf("输入第一个多项式，");
				input(a,N);
				printf("输入第二个多项式，");
				input(b,N);
				subit(a,b,c,N);//多项式相减
				printf("相减的结果是:
");
				printit(c,2*N);//输出结果
				printf("
");
				break;
			case3:
				printf("输入第一个多项式，");
				input(a,N);
				printf("输入第二个多项式，");
				input(b,N);
				mulit(a,b,c,N);//多项式相乘
				printf("相乘的结果是:
");
				printit(c,2*N);//输出结果
				printf("
");
				break;
		}
		if(x==0)break;
	}
}

㈦ 编写一元多项式的计算器程序

#include <stdio.h>
#include <stdlib.h>

typedef struct LNode{
float coef;
int expn;
struct LNode *next;
}LNode, *LinkList, *Link;

Link MakeNode(float c, int e){
Link p;
p=(Link)malloc(sizeof(LNode));
p->coef=c; p->expn=e; p->next=NULL;
return p;
}

void InitPoly(LinkList &P){
P=MakeNode(0,-1);
}

void Create(LinkList &P){
Link rear;
float c; int e;
InitPoly(P);
rear=P;
printf("Input coef expn, (0 0)Exit\n");
while(1){
scanf("%f%d",&c,&e);
if(c==0) break;
rear->next=MakeNode(c,e);
rear=rear->next;
}
}

void PrintPoly(LinkList P){
Link p;
if(P==NULL)
printf("NULL\n");
else if(P->next==NULL)
printf("0\n");
else{
p=P->next;
while(p){
printf("%fX^%d",p->coef,p->expn);
p=p->next;
if(p && p->coef>0) printf("+");
}
printf("\n");
}
}

void Copy(LinkList P1, LinkList &P2){
Link p1, p2;
if(P1==NULL) return;
InitPoly(P2);
p1=P1->next;
p2=P2;
while(p1){
p2->next=MakeNode(p1->coef,p1->expn);
p1=p1->next; p2=p2->next;
}
}

void AddPoly(LinkList P1, LinkList P2, LinkList &P3){
Link q1,q2,q3;
if(!P1 || !P2) return;
InitPoly(P3);
q3=P3;
q1=P1->next; q2=P2->next;
while(q1&&q2){
if(q1->expn<q2->expn){
q3->next=MakeNode(q1->coef,q1->expn);
q3=q3->next; q1=q1->next;
}
else if(q1->expn>q2->expn){
q3->next=MakeNode(q2->coef,q2->expn);
q3=q3->next; q2=q2->next;
}
else{
if(q1->coef+q2->coef!=0){
q3->next=MakeNode(q2->coef+q1->coef,q2->expn);
q3=q3->next;
}
q1=q1->next;q2=q2->next;
}
}
while(q1){
q3->next=MakeNode(q1->coef,q1->expn);
q3=q3->next; q1=q1->next;
}
while(q2){
q3->next=MakeNode(q2->coef,q2->expn);
q3=q3->next; q2=q2->next;
}
}

void SubPoly(LinkList P1, LinkList P2, LinkList &P3){
Link q1,q2,q3;
if(!P1 || !P2) return;
InitPoly(P3);
q3=P3;
q1=P1->next; q2=P2->next;
while(q1&&q2){
if(q1->expn<q2->expn){
q3->next=MakeNode(q1->coef,q1->expn);
q3=q3->next; q1=q1->next;
}
else if(q1->expn>q2->expn){
q3->next=MakeNode(-(q2->coef),q2->expn);
q3=q3->next; q2=q2->next;
}
else{
if(q1->coef+q2->coef!=0){
q3->next=MakeNode(q2->coef-q1->coef,q2->expn);
q3=q3->next;
}
q1=q1->next;q2=q2->next;
}
}
while(q1){
q3->next=MakeNode(q1->coef,q1->expn);
q3=q3->next; q1=q1->next;
}
while(q2){
q3->next=MakeNode(-(q2->coef),q2->expn);
q3=q3->next; q2=q2->next;
}
}

void Qiu(LinkList P1, LinkList &P2){
Link p1, p2;
if(P1==NULL) return;
InitPoly(P2);
p1=P1->next;
p2=P2;
while(p1){
p2->next=MakeNode((p1->coef)*(p1->expn),p1->expn-1);
p1=p1->next; p2=p2->next;
}
}

void jifenpolyn(LinkList P1, LinkList &P2){
Link p1, p2;
if(P1==NULL) return;
InitPoly(P2);
p1=P1->next;
p2=P2;
while(p1){

p2->next=MakeNode((p1->coef)/(p1->expn+1),p1->expn+1);
p1=p1->next; p2=p2->next;
}
}

void IS(LinkList P1, LinkList &P2,float c, int e){
if(P1==NULL) return;
Link q1,q2;
InitPoly(P2);
q1=P1->next;
q2=P2;
while(q1){
q2->next=MakeNode((q1->coef)*c,q1->expn+e);
q1=q1->next; q2=q2->next;
}
}
void Multiplypolynl(LinkList P1, LinkList P2, LinkList &P3,LinkList &P4){
Link q2;
q2=P2;
if(!P1 || !P2) return;
InitPoly(P3);
InitPoly(P4);
while(q2){
q2=q2->next;
IS(P1,P3,q2->coef,q2->expn);
AddPoly(P3,P4,P4 );
}
}

void Destroypolyn(LinkList P){
Link rear;
while(rear){
rear=P->next;
P->next=rear->next;
free(rear);}
free(P);
}

void Changepolyn(LinkList P,float c, int e){
Link rear;
while(rear->expn<e)
rear=rear->next;
rear->coef=c;

}

void Insert( LinkList P1,LinkList P3,float c, int e){
LinkList P2;
P2=MakeNode(c,e);
AddPoly(P1,P2,P3);}

#define N 12
void main(){
LinkList P[N]={NULL};
int i1,i2,i3,i4,menu,i;

while(1){
printf(" 0 -- Exit\n");
printf(" 1 -- Create\n");
printf(" 2 -- Print\n");
printf(" 3 -- Copy\n");
printf(" 4 -- Add\n");
printf(" 5 -- sub\n");
printf(" 6 -- qiu\n");
printf(" 7 -- jifeng\n");
printf(" 8 -- multi\n");
printf(" 9 -- destory\n");
printf(" 10 -- change\n");
printf(" 11 -- insert\n");

printf(" Select: ");
scanf("%d", &menu);

switch(menu){
case 0: return;
case 1:
printf(" Address: ");
scanf("%d", &i1);
Create(P[i1]);
break;
case 2:
printf("\n");
for(i=0;i<N; i++){
printf(" P(%d)= ", i);
PrintPoly(P[i]);
}
printf("\n");
break;
case 3:
printf(" A-->B, Input A,B: ");
scanf("%d%d",&i1,&i2);
Copy(P[i1],P[i2]);
break;
case 4:
printf(" A+B=C, Input A,B,C: ");
scanf("%d%d%d",&i1,&i2,&i3);
AddPoly(P[i1],P[i2],P[i3]);
break;
case 5:
printf(" A-B=C, Input A,B,C: ");
scanf("%d%d%d",&i1,&i2,&i3);
SubPoly(P[i1],P[i2],P[i3]);
break;

case 6:
printf(" 对A求导, Input A,B:");
scanf("%d%d",&i1,&i2);
Qiu(P[i1],P[i2]);
break;
case 7:
printf(" 对A积分 Input A,B:");
scanf("%d%d",&i1,&i2);
jifenpolyn(P[i1],P[i2]);
break;
case 8:
printf(" A*B=C, Input A,B,C: ");
scanf("%d%d%d%d",&i1,&i2,&i3,&i4);
Multiplypolynl(P[i1],P[i2],P[i3],P[i4]);
break;
case 9:
printf("销毁A Input A:");
scanf("%d",&i1);
Destroypolyn(P[i1]);
break;
case 10:
float c; int e;
printf("change Input A,e,c:");
scanf("%d%d%f",&i1,&e,&c);
Changepolyn(P[i1],c,e);
break;
case 11:
float d; int f;
printf("insert Input A,B,e,c: ");
scanf("%d%d%d%f",&i1,&i2,&f,&d);
Insert(P[i1],P[i2],c,e);
break;
default: ;
}
}
}

㈧ 简单的整系数一元多项式计算系统(绝对高分)

#include<stdio.h>
#include<stdlib.h>
typedef struct
{ float coef; //系数
int expn; //指数
}term;
typedef struct LNode
{ term data; //term多项式值
struct LNode *next;
}LNode,*LinkList;
typedef LinkList polynomail;
/*比较指数*/
int cmp(term a,term b)
{ if(a.expn>b.expn) return 1;
if(a.expn==b.expn) return 0;
if(a.expn<b.expn) return -1;
else exit(-2);
}
/*又小到大排列*/
void arrange1(polynomail pa)
{ polynomail h=pa,p,q,r;
if(pa==NULL) exit(-2);
for(p=pa;p->next!=NULL;p=p->next); r=p;
for(h=pa;h->next!=r;)//大的沉底
{ for(p=h;p->next!=r&&p!=r;p=p->next)
if(cmp(p->next->data,p->next->next->data)==1)
{ q=p->next->next;
p->next->next=q->next;
q->next=p->next;
p->next=q;
}
r=p;//r指向参与比较的最后一个，不断向前移动
} }
/*由大到小排序*/
void arrange2(polynomail pa)
{ polynomail h=pa,p,q,r;
if(pa==NULL) exit(-2);
for(p=pa;p->next!=NULL;p=p->next); r=p;
for(h=pa;h->next!=r;)//小的沉底
{ for(p=h;p->next!=r&&p!=r;p=p->next)
if(cmp(p->next->next->data,p->next->data)==1)
{ q=p->next->next;
p->next->next=q->next;
q->next=p->next;
p->next=q;
}
r=p;//r指向参与比较的最后一个，不断向前移动
} }
/*打印多项式,求项数*/
int printpolyn(polynomail P)
{ int i;
polynomail q;
if(P==NULL) printf("无项！\n");
else if(P->next==NULL) printf("Y=0\n");
else
{ printf("该多项式为Y=");q=P->next;i=1;
if(q->data.coef!=0&&q->data.expn!=0)
{ printf("%.2fX^%d",q->data.coef,q->data.expn); i++; }
if(q->data.expn==0&&q->data.coef!=0)
printf("%.2f",q->data.coef);//打印第一项
q=q->next;
if(q==NULL)
{printf("\n");return 1;}
while(1)//while中，打印剩下项中系数非零的项，
{ if(q->data.coef!=0&&q->data.expn!=0)
{ if(q->data.coef>0) printf("+");
printf("%.2fX^%d",q->data.coef,q->data.expn); i++;
}
if(q->data.expn==0&&q->data.coef!=0)
{ if(q->data.coef>0) printf("+");
printf("%f",q->data.coef);
}
q=q->next;
if(q==NULL)
{ printf("\n"); break; }
}
}
return 1;
}
/*1、创建并初始化多项式链表*/
polynomail creatpolyn(polynomail P,int m)
{ polynomail r,q,p,s,Q;
int i;
P=(LNode*)malloc(sizeof(LNode));
r=P;
for(i=0;i<m;i++)
{ s=(LNode*)malloc(sizeof(LNode));
printf("请输入第%d项的系数和指数：",i+1);
scanf("%f%d",&s->data.coef,&s->data.expn);
r->next=s; r=s;
}
r->next=NULL;
if(P->next->next!=NULL)
{ for(q=P->next;q!=NULL/*&&q->next!=NULL*/;q=q->next)//合并同类项
for(p=q->next,r=q;p!=NULL;)
if(q->data.expn==p->data.expn)
{ q->data.coef=q->data.coef+p->data.coef;
r->next=p->next;
Q=p;p=p->next;
free(Q);
}
else
{ r=r->next;
p=p->next;
}
}
return P;
}
/*2、两多项式相加*/
polynomail addpolyn(polynomail pa,polynomail pb)
{ polynomail s,newp,q,p,r;int j;
p=pa->next;q=pb->next;
newp=(LNode*)malloc(sizeof(LNode));
r=newp;
while(p&&q)
{ s=(LNode*)malloc(sizeof(LNode));
switch(cmp(p->data,q->data))
{case -1: s->data.coef=p->data.coef;
s->data.expn=p->data.expn;
r->next=s; r=s;
p=p->next;
break;
case 0: s->data.coef=p->data.coef+q->data.coef;
if(s->data.coef!=0.0)
{ s->data.expn=p->data.expn;
r->next=s;
r=s;
}
p=p->next;
q=q->next;
break;
case 1: s->data.coef=q->data.coef;
s->data.expn=q->data.expn;
r->next=s; r=s;
q=q->next;
break;
}//switch
}//while
while(p)
{ s=(LNode*)malloc(sizeof(LNode));
s->data.coef=p->data.coef;
s->data.expn=p->data.expn;
r->next=s; r=s;
p=p->next;
}
while(q)
{ s=(LNode*)malloc(sizeof(LNode));
s->data.coef=q->data.coef;
s->data.expn=q->data.expn;
r->next=s; r=s;
q=q->next;
}
r->next=NULL;
for(q=newp->next;q->next!=NULL;q=q->next)//合并同类项
for(p=q;p!=NULL&&p->next!=NULL;p=p->next)
if(q->data.expn==p->next->data.expn)
{ q->data.coef=q->data.coef+p->next->data.coef;
r=p->next;
p->next=p->next->next;
free(r);
}
printf("升序 1 , 降序 2\n");
printf("选择:");
scanf("%d",&j);
if(j==1) arrange1(newp);
else arrange2(newp);
return newp;
}
/*3、两多项式相减*/
polynomail subpolyn(polynomail pa,polynomail pb)
{ polynomail s,newp,q,p,r,Q; int j;
p=pa->next;q=pb->next;
newp=(LNode*)malloc(sizeof(LNode));
r=newp;
while(p&&q)
{ s=(LNode*)malloc(sizeof(LNode));
switch(cmp(p->data,q->data))
{case -1: s->data.coef=p->data.coef;
s->data.expn=p->data.expn;
r->next=s; r=s;
p=p->next;
break;
case 0: s->data.coef=p->data.coef-q->data.coef;
if(s->data.coef!=0.0)
{ s->data.expn=p->data.expn;
r->next=s;
r=s;
}
p=p->next;
q=q->next;
break;
case 1: s->data.coef=-q->data.coef;
s->data.expn=q->data.expn;
r->next=s; r=s;
q=q->next;
break;
}//switch
}//while
while(p)
{ s=(LNode*)malloc(sizeof(LNode));
s->data.coef=p->data.coef;
s->data.expn=p->data.expn;
r->next=s; r=s;
p=p->next;
}
while(q)
{ s=(LNode*)malloc(sizeof(LNode));
s->data.coef=-q->data.coef;
s->data.expn=q->data.expn;
r->next=s; r=s;
q=q->next;
}
r->next=NULL;
if(newp->next!=NULL&&newp->next->next!=NULL)//合并同类项
{ for(q=newp->next;q!=NULL;q=q->next)
for(p=q->next,r=q;p!=NULL;)
if(q->data.expn==p->data.expn)
{ q->data.coef=q->data.coef+p->data.coef;
r->next=p->next;
Q=p;p=p->next;
free(Q); }
else
{ r=r->next;
p=p->next; }
} printf("升序 1 , 降序 2\n");
printf("选择:");
scanf("%d",&j);
if(j==1) arrange1(newp);
else arrange2(newp);
return newp;}
/*4两多项式相乘*/
polynomail mulpolyn(polynomail pa,polynomail pb)
{ polynomail s,newp,q,p,r;
int i=20,j;
newp=(LNode*)malloc(sizeof(LNode));
r=newp;
for(p=pa->next;p!=NULL;p=p->next)
for(q=pb->next;q!=NULL;q=q->next)
{ s=(LNode*)malloc(sizeof(LNode));
s->data.coef=p->data.coef*q->data.coef;
s->data.expn=p->data.expn+q->data.expn;
r->next=s;
r=s;}
r->next=NULL;
printf("升序 1 , 降序 2\n");
printf("选择:");
scanf("%d",&j);
if(j==1) arrange1(newp);
else arrange2(newp);
for(;i!=0;i--)
{for(q=newp->next;q->next!=NULL;q=q->next)//合并同类项
for(p=q;p!=NULL&&p->next!=NULL;p=p->next)
if(q->data.expn==p->next->data.expn)
{ q->data.coef=q->data.coef+p->next->data.coef;
r=p->next;
p->next=p->next->next; free(r);
}
}
return newp;
}
/*5、销毁已建立的两个多项式*/
void delpolyn(polynomail pa,polynomail pb)
{ polynomail p,q;
p=pa;
while(p!=NULL)
{ q=p;
p=p->next;
free(q);
}
p=pb;
while(p!=NULL)
{ q=p;
p=p->next;
free(q);
}
printf("两个多项式已经销毁\n");
}
void main()
{ polynomail pa=NULL,pb=NULL;
polynomail p,q;
polynomail addp=NULL,subp=NULL,mulp=NULL;
int n,m;
int sign='y';
printf("1、创建两个一元多项式\n");
printf("2、两多项式相加得一新多项式\n");
printf("3、两多项式相减得一新多项式\n");
printf("4、两多项式相乘得一新多项式\n");
printf("5、销毁已建立的两个多项式\n");
printf("6、退出\n");
printf("\n");
while(sign!='n')
{ printf("请选择：");
scanf("%d",&n);
switch(n)
{case 1:
if(pa!=NULL)
{ printf("已建立两个一元多项式，请选择其他操作！");
break;
}
printf("请输入第一个多项式：\n");
printf("要输入几项：");
scanf("%d",&m);
while(m==0)
{ printf("m不能为0，请重新输入m:");
scanf("%d",&m);
}
pa=creatpolyn(pa,m);
printpolyn(pa);
printf("请输入第二个多项式：\n");
printf("要输入几项：");
scanf("%d",&m);
pb=creatpolyn(pb,m);
printpolyn(pb);
break;
case 2:
if(pa==NULL)
{ printf("请先创建两个一元多项式！\n");
break;
}
addp=addpolyn(pa,pb);
printpolyn(addp);
break;
case 3:
if(pa==NULL)
{ printf("请先创建两个一元多项式！\n");
break;
}
subp=subpolyn(pa,pb);
printpolyn(subp);
break;
case 4:
if(pa==NULL)
{ printf("请先创建两个一元多项式！\n");
break;
}
mulp=mulpolyn(pa,pb);
printpolyn(mulp);
break;
case 5:
if(pa==NULL)
{ printf("请先创建两个一元多项式！\n");
break;
}
delpolyn(pa,pb);
pa=pb=NULL;
break;
case 6:
if(addp!=NULL)
{ p=addp;
while(p!=NULL)
{ q=p;
p=p->next;
free(q);
}
}
if(subp!=NULL)
{ p=subp;
while(p!=NULL)
{ q=p;
p=p->next;
free(q);
}
}
exit(-2);
}//switch
}//while
}

㈨ 数据结构课程设计报告（一元多项式的计算）

【问题描述】
编程实现一元多项式的加法计算。
【基本要求】
能用链表实现一元多项式的加法计算，并能打印出计算结果。
【所需知识】
（1）基本编程方法和程序设计知识。
（2）链表的理解和运算与运用。
【所用算法】
遍历算法和递归算法。
【操作平台】
Visual C++

#include<stdio.h>
#include<graphics.h>
#define MAX 100
typedef struct polynode
{ float coef;
int expn;
struct polynode *next;
}node;

node * create(void) /*指针函数，返回指针类型；用尾插法建立一元多项式的链表的函数*/
{
node *h,*r,*s;
float c;
int e;
h=(node *)malloc(sizeof(node)); /*建立多项式的头结点，为头结点分配存储空间*/
r=h; /*r指针始终动态指向链表的当前表尾，以便于做尾插入，其初值指向头结点*/
printf("coef:");
scanf("%f",&c); /*输入系数*/
printf("expn: ");
scanf("%d",&e); /*输入指数*/
while(c!=0.0) /*输入系数为0时，表示多项式的输入结束*/
{
s=(node *)malloc(sizeof(node)); /*申请新结点*/
s->coef=c; /*申请新结点后赋值*/
s->expn=e; /*申请新结点后赋值*/
r->next=s; /*做尾插，插入新结点*/
r=s; /*r始终指向单链表的表尾*/
printf("coef:");
scanf("%f",&c);
printf("expn: ");
scanf("%d",&e);
}
r->next=NULL; /*将表的最后一个结点的next置NULL，以示表结束*/
return(h);
}

void polyadd(node *pa, node *pb) /*一元多项式相加函数，用于将两个多项式相加，
然后将和多项式存放在多项式pa中，并将多项式pb删除*/
{
node *p,*q,*pre,*temp;
int sum;
p=pa->next; /*令p和q分别指向pa和pb多项式链表中的第一个结点*/
q=pb->next;
pre=pa; /*位置指针，指向和多项式pa*/
while(p!=NULL&&q!=NULL) /*当两个多项式均未扫描结束时，执行以下操作*/
{
if(p->expn<q->expn) /*若p指向的多项式指数小于q指的指数*/
{
pre->next=p; /*将p结点加入到和多项式中*/
pre=pre->next;
p=p->next;
}
if(p->expn==q->expn) /*若指数相等，则相应的系数相加*/
{
sum=p->coef+q->coef;
if(sum!=0)
{
p->coef=sum;
pre->next=p;pre=pre->next;p=p->next;
temp=q;q=q->next;free(temp);
}
else /*如果系数和为零，则删除结点p与q，并将指针指向下一个结点*/
{
temp=p->next;free(p);p=temp;
temp=q->next;free(q);q=temp;
}
}
if (q->expn<p->expn)
{
pre->next=q; /*将q结点加入到和多项式中*/
pre=pre->next;
q=q->next;
}
}
if(p!=NULL) /*多项式A中还有剩余，则将剩余的结点加入到和多项式中*/
pre->next=p;
else /*否则将B的结点加入到和多项式中*/
pre->next=q;
}

void print(node * p) /*输出函数，打印出一元多项式*/
{
while(p->next!=NULL)
{
p=p->next;
printf(" %f*x^%d",p->coef,p->expn);
}
}

void calculate() /*给多项式赋值并计算*/
{ float cal=1.0,mid=0.0,las;
int j;
float num, x;
int i=0;
float later=0.0;
int e[MAX];float c[MAX];
printf("Please input num:"); /*输入常数的值*/
scanf("%f",&num);
printf("Please input x:"); /*输入未知数X的值*/
scanf("%f",&x);
printf("Please input e[0]:"); /*输入数组的初值以判断是否循环*/
scanf("%d",&e[0]);
printf("Please input c[0]:");
scanf("%f",&c[0]);
while(e[i]!=0 && c[i]!=0.0 ) /*此循环用于多项式的计算*/
{ cal=1;
for(j=0;j<e[i];j++) /*表示出X的几次方*/
{
cal=cal*x;
}
i++;
mid=cal*c[i-1]; /*表示出单项*/
later+=mid;
printf("Please input e[%d] and c[%d] :",i,i);
scanf("%d%f",&e[i],&c[i]);

}
las=later+num; /*表示出完整的多项式*/
printf("The Result is :\n");
printf("%f",las); /*最终的计算结果*/
sleep(3);

}
void main()
{
node * pa,* pb,*pc,*p,*q,*pre;
int driver=VGA,mode=VGAHI;
initgraph(&driver,&mode,"c:\\tc ");
setbkcolor(BLUE);
setcolor(RED);
printf("Welcome,Let's go!\n");
printf("Next, you will see the process of computing !");
printf("\nPlease input the coef and expn of pa:\n");
pa=create(); /*调用建立链表函数，创建多项式A*/
print(pa);
printf("\nPlease input the coef and expn of pb:\n");
pb=create(); /*同理，创建B*/
print(pb);
p=pa->next; /*以下代码用于排序*/
pa->next=NULL;
while(p!=NULL)
{
if(pa->next==NULL)
{
pa->next=p;p=p->next;
pa->next->next=NULL;
}
else
{ pre=pa;q=pre->next;
while(q!=NULL && p->expn>q->expn)
{
pre=q;q=q->next;
}
q=p->next;
p->next=pre->next;
pre->next=p;
p=q;

}
}
printf("\nthe first ordered one:\n");print(pa); /*输出排序后的pa*/
p=pb->next; /*以下代码用于给pb排序*/
pb->next=NULL;
while(p!=NULL)
{
if(pb->next==NULL)
{
pb->next=p;p=p->next;
pb->next->next=NULL;
}
else
{ pre=pb;q=pre->next;
while(q!=NULL && p->expn>q->expn)
{
pre=q;q=q->next;
}
q=p->next;
p->next=pre->next;
pre->next=p;
p=q;

}
}
printf("\nthe second ordered one:\n");print(pb); /*输出排序后的pb*/
printf("\nSum of the polys is:\n");
polyadd(pa,pb); /*调用一元多项式相加函数*/
print(pa); /*调用输出函数，打印结果*/
printf("\n");
setbkcolor(RED);
calculate(); /*调用计算多项式值的函数*/
}

【编后总结】
本程序在逻辑设计，详细设计，程序编码和程序调试阶段时本来都城有设计save()保存函数，和load()下载函数，分别用来保存创建的多项式，和下载其它需计算的多项式数据，这样这个系统才能更加实用，void createadj()原来的函数原型为arcnode *createdj()函数中用链表结构把adjmatrix[][]的数据都保存其中，这样就能实现数据的保存，但随之要把Dijkstra中的adjmatrix[][]转换成用arcnode 指针的形式进行表示，因为只有这样，下载后的数据才能使用。但在最后的调试阶段中，发现dijkstra无法运行，但又苦于无法用save()函数保存adjmatrix[][],最后只放弃save()和load()函数，在 main()主函数中初始化该算式。从这次程序设计中我看到自己的不足之处，今后要更努力的学习和掌握好数据结构程序设计的知识。

㈩ 数据结构一元多项式计算(急求)

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>

typedef struct polynode
{
int coef; //多项式的系数
int exp; //指数
struct polynode *next;
}node;

node *create() //用尾插法建立一元多项式的链表
{
node *h,*r,*s;
int c,e;
h=(node*)malloc(sizeof(node));
r=h;
printf("coef:");
scanf("%d",&c);
printf("exp: ");
scanf("%d",&e);
while(c!=0) //输入系数为0时，多项式的输入结束
{
s=(node*)malloc(sizeof(node));
s->coef=c;
s->exp=e;
r->next=s;
r=s;
printf("coef:");
scanf("%d",&c);
printf("exp: ");
scanf("%d",&e);
}
r->next=NULL;
return(h);
}

void print(node *p) //输出函数，打印出一元多项式
{
while(p->next!=NULL)
{
p=p->next;
printf(" %d*x^%d",p->coef,p->exp);

}
}

void polyadd(node *ha, node *hb)//一元多项式相加函数，用于将两个多项式相加，然后将和多项式存放在多项式ha中，并将多项式hb删除
{
node *p,*q,*pre,*temp;
int sum;
p=ha->next;
q=hb->next;
pre=ha;
while(p!=NULL&&q!=NULL)
{
if(p->exp<q->exp)
{
pre->next=p;
pre=pre->next;
p=p->next;
}
else if(p->exp==q->exp)
{
sum=p->coef+q->coef;
if(sum!=0)
{
p->coef=sum;
pre->next=p;pre=pre->next;p=p->next;
temp=q;q=q->next;free(temp);
}
else //如果系数和为零，则删除结点p与q，并将指针指向下一个结点
{
temp=p->next;free(p);p=temp;
temp=q->next;free(q);q=temp;
}
}
else
{
pre->next=q;
pre=pre->next;
q=q->next;
}
}
if(p!=NULL) //将多项式A中剩余的结点加入到和多项式中
pre->next=p;
else
pre->next=q;
}

void multipoly(node *ha,node *hb)
{ node *p,*q,*n,*m;
p=ha->next;
n=(node*)malloc(sizeof(node));
n->next=NULL;
while(p!=NULL)
{ m=(node*)malloc(sizeof(node));
for(q=hb->next;q;q=q->next)
{ m->coef=p->coef*q->coef;
m->exp=p->exp+q->exp;
m->next=NULL;
}
p=p->next;
polyadd(n,m);
}
printf("多项式的积是:\n");
print(n);
}

void main()
{
node *ha,*hb;
printf("请输入多项式ha的系数与指数:\n");
ha=create();
print(ha);
printf("\n");
printf("请输入多项式hb的系数与指数:\n");
hb=create();
print(hb);
printf("\n");
printf("多项式的和是:\n");
polyadd(ha,hb);
print(ha);
printf("\n");
multipoly(ha,hb);
}