数据结构课程设计一元多项式的运算，照着书上敲的代码，运行的结果是这个样子的

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

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

#include
#include
#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->expnexpn) /*若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->expnexpn)
{
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 :
");
printf("%f",las); /*最终的计算结果*/
sleep(3);

}
void main()
{
node * pa,* pb,*pc,*p,*q,*pre;
int driver=VGA,mode=VGAHI;
initgraph(&driver,&mode,"c:\c ");
setbkcolor(BLUE);
setcolor(RED);
printf("Welcome,Let's go!
");
printf("Next, you will see the process of computing !");
printf("
Please input the coef and expn of pa:
");
pa=create(); /*调用建立链表函数，创建多项式A*/
print(pa);
printf("
Please input the coef and expn of pb:
");
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("
the first ordered one:
");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("
the second ordered one:
");print(pb); /*输出排序后的pb*/
printf("
Sum of the polys is:
");
polyadd(pa,pb); /*调用一元多项式相加函数*/
print(pa); /*调用输出函数，打印结果*/
printf("
");
setbkcolor(RED);
calculate(); /*调用计算多项式值的函数*/
}

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

#include "stdafx.h"
#include "iostream"
using namespace std;
#define MAXSIZE 10
typedef struct
{
int xi;
int zhi;
}DataType;
typedef struct node
{
DataType data[MAXSIZE];
int length;
}Dx,*PDx;
PDx Init_List()
{
Dx *S;
S=(Dx *)malloc(sizeof(Dx));
if(S)
S->length=0;
return S;
}
int Empty(Dx *S)
{
if(S->length==0)
return 1;
else return 0;
}
int In_list(Dx *S,DataType a)//建立多项式存储结构
{
if(S&&S->length<MAXSIZE)
{
S->length++;
S->data[S->length-1]=a;
return 1;
}
else return 0;
}
int Insert_list(Dx *S,int j,DataType e)//插入
{
if(S&&S->length<MAXSIZE)
{
S->length++;
for(int i=S->length-1;i>j;i--)
S->data[i]=S->data[i-1];
S->data[j]=e;
return 1;
}
else return 0;
}
int Delete_list(Dx *S,int m)//m就是数组下标
{
if(!S)
{
cout<<"多项式不存在！"<<endl;
return -1;
}
if(mS->length)
{
cout<<"删除位置不合法！"<<endl;
return 0;
}
for(int j=m;jlength;j++)
S->data[j-1]=S->data[j];
S->length--;
return 1;
}
PDx Luru(int n)//录入多项式，并存储起来,n为多项式的项数！
{
Dx *S;
S=Init_List();
DataType e;
cout<<"按从高指数到低指数，输入一元多项式的系数和指数；"<<endl;
for(int i=0;i<n;i++)
{
cout<<"指数：";
cin>>e.zhi;
if((S->length-1>=0&&e.zhi>=S->data[S->length-1].zhi)||e.zhi<0)
{
i--;
cout<<"输入指数大于前一项错误请重输或小于0！"<<endl;
continue;
}
cout<<"系数：";
cin>>e.xi;
In_list(S,e);
}
return S;
}
void print(Dx *S)
{
for(int i=0;ilength;i++)
{
if(i>0&&S->data[i].xi>=0)
cout<<"+";
cout<data[i].xi<<"X^"<data[i].zhi;
}
cout<<endl;
}
PDx Add(Dx *S1,Dx *S2)
{
Dx *S3;
S3=Init_List();
for(int x=0;xlength;x++)
{
S3->length++;
S3->data[S3->length-1]=S1->data[x];
}
for(int i=0;ilength;i++)
{ for(int j=0;jlength;j++)
{
if(S2->data[i].zhi==S3->data[j].zhi)
{
S3->data[j].xi+=S2->data[i].xi;
break;
}
else if(S2->data[i].zhi>S3->data[j].zhi)
{
Insert_list(S3,j,S2->data[i]);
break;
}
}
if(S2->data[i].zhidata[S3->length-1].zhi)
{
In_list(S3,S2->data[i]);
}
}
return S3;
}
PDx Sub(Dx *S1,Dx *S2)//S1-S2
{
Dx *S3;
S3=Init_List();
DataType e;
for(int x=0;xlength;x++)
{
S3->length++;
S3->data[S3->length-1]=S1->data[x];
}
for(int i=0;ilength;i++)
{ for(int j=0;jlength;j++)
{
if(S2->data[i].zhi==S3->data[j].zhi)
{
S3->data[j].xi-=S2->data[i].xi;
if(S3->data[j].xi==0)
Delete_list(S3,j+1);
break;
}
else if(S2->data[i].zhi>S3->data[j].zhi)
{
e=S2->data[i];
e.xi=-1*e.xi;
Insert_list(S3,j,e);
break;
}
}
if(S2->data[i].zhidata[S3->length-1].zhi)
{
e=S2->data[i];
e.xi=-1*e.xi;
In_list(S3,e);
}
}
return S3;
}
PDx Bin(Dx *S1,Dx *S2)
{
Dx *S3;
S3=Init_List();
DataType e,a;
a.xi=0;
a.zhi=0;
In_list(S3,a);
for(int i=0;ilength;i++)
for(int j=0;jlength;j++)
{
e.xi=S1->data[i].xi*S2->data[j].xi;
e.zhi=S1->data[i].zhi*S2->data[j].zhi;
for(int k=0;klength;k++)
{
if(e.zhi==S3->data[k].zhi)
{
S3->data[k].xi+=S2->data[j].xi;
break;
}
else if(e.zhi>S3->data[k].zhi)
{
Insert_list(S3,k,e);
break;
}
if(S3->length-2>=0&&e.zhidata[S3->length-2].zhi)
{
Insert_list(S3,S3->length-1,e);
}
}
}
return S3;
}

int _tmain(int argc, _TCHAR* argv[])
{
Dx *S1,*S2,*S3,*S4,*S5;
int i,j;
cout<<"要录入的1多项式项数:";
cin>>i;
S1=Luru(i);
cout<<"要录入的2多项式项数:";
cin>>j;
S2=Luru(j);
S3=Add(S1,S2);
S4=Sub(S1,S2);
S5=Bin(S1,S2);
cout<<"第一个多项式:"<<endl;
print(S1);
cout<<"第二个多项式:"<<endl;
print(S2);
cout<<"两多项式的和:"<<endl;
print(S3);
cout<<"两多项式的差"<<endl;
print(S4);
cout<<"两多项式的积"<<endl;
print(S5);
return 0;
}

给你其实是在害你，给你知识点，如果还不会再来问我
　线性代数的学习切入点：线性方程组。换言之，可以把线性代数看作是在研究线性方程组这一对象的过程中建立起来的学科。
　　线性方程组的特点：方程是未知数的一次齐次式，方程组的数目s和未知数的个数n可以相同，也可以不同。
　　关于线性方程组的解，有三个问题值得讨论：
　　（1）、方程组是否有解，即解的存在性问题；
　　（2）、方程组如何求解，有多少个解；
　　（3）、方程组有不止一个解时，这些不同的解之间有无内在联系，即解的结构问题。
　　高斯消元法，最基础和最直接的求解线性方程组的方法，其中涉及到三种对方程的同解变换：
　　（1）、把某个方程的k倍加到另外一个方程上去；
　　（2）、交换某两个方程的位置；
　　（3）、用某个常数k乘以某个方程。我们把这三种变换统称为线性方程组的初等变换。
　　任意的线性方程组都可以通过初等变换化为阶梯形方程组。
　　由具体例子可看出，化为阶梯形方程组后，就可以依次解出每个未知数的值，从而求得方程组的解。
　　对方程组的解起决定性作用的是未知数的系数及其相对位置，所以可以把方程组的所有系数及常数项按原来的位置提取出来，形成一张表，通过研究这张表，就可以判断解的情况。我们把这样一张由若干个数按某种方式构成的表称为矩阵。
　　可以用矩阵的形式来表示一个线性方程组，这至少在书写和表达上都更加简洁。
　　系数矩阵和增广矩阵。
　　高斯消元法中对线性方程组的初等变换，就对应的是矩阵的初等行变换。阶梯形方程组，对应的是阶梯形矩阵。换言之，任意的线性方程组，都可以通过对其增广矩阵做初等行变换化为阶梯形矩阵，求得解。
　　阶梯形矩阵的特点：左下方的元素全为零，每一行的第一个不为零的元素称为该行的主元。
　　对不同的线性方程组的具体求解结果进行归纳总结（有唯一解、无解、有无穷多解），再经过严格证明，可得到关于线性方程组解的判别定理：首先是通过初等变换将方程组化为阶梯形，若得到的阶梯形方程组中出现0=d这一项，则方程组无解，若未出现0=d一项，则方程组有解；在方程组有解的情况下，若阶梯形的非零行数目r等于未知量数目n，方程组有唯一解，若r在利用初等变换得到阶梯型后，还可进一步得到最简形，使用最简形，最简形的特点是主元上方的元素也全为零，这对于求解未知量的值更加方便，但代价是之前需要经过更多的初等变换。在求解过程中，选择阶梯形还是最简形，取决于个人习惯。
　　常数项全为零的线性方程称为齐次方程组，齐次方程组必有零解。
　　齐次方程组的方程组个数若小于未知量个数，则方程组一定有非零解。
　　利用高斯消元法和解的判别定理，以及能够回答前述的基本问题（1）解的存在性问题和（2）如何求解的问题，这是以线性方程组为出发点建立起来的最基本理论。
　　对于n个方程n个未知数的特殊情形，我们发现可以利用系数的某种组合来表示其解，这种按特定规则表示的系数组合称为一个线性方程组（或矩阵）的行列式。行列式的特点：有n！项，每项的符号由角标排列的逆序数决定，是一个数。
　　通过对行列式进行研究，得到了行列式具有的一些性质（如交换某两行其值反号、有两行对应成比例其值为零、可按行展开等等），这些性质都有助于我们更方便的计算行列式。
　　用系数行列式可以判断n个方程的n元线性方程组的解的情况，这就是克莱姆法则。
　　总而言之，可把行列式看作是为了研究方程数目与未知量数目相等的特殊情形时引出的一部分内容

---

海曙区13319027964： 数据结构课程设计 -- 一元多项式计算 - ？
酆面美辛： #include 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＂,...

海曙区13319027964： 设计算法实现一元多项式的简单运算.基本要求:(1) 输入并建立多项式;(2) 输出多项式;(3) 多项式加法(4) 多项式减法.测试数据:(1)(2x+5x8 - ... - ？
酆面美辛：[答案] 1用两个堆栈来分别存储读取的数据和符号,建一个数组来存储符号优先级. 2存数和符号,遇到符号判断优先级(和堆栈最上层的对比,如果为高优先级)取其两边的数计算 3将结果存入堆栈(删除已经用过的数据和符号),重复2 关键是优先级判断...

海曙区13319027964： 数据结构一元多项式的代数运算 - ？
酆面美辛： //多项式相加(用单链表实现,用尾插法建表,用墨守成连线法求新的多项式) #include<stdio.h> #include<stdlib.h> typedef struct LNode //单链表的结构 {int coef,exp;struct LNode *next; }LNode,*LinkList;void InitList(LinkList &L) //单链表的初始...

海曙区13319027964： 数据结构.c语言版.一元多项式的计算要求,对高次多项式进行加减运算,并输出运算结果.要求用链表实现. 功能;1多项式的表示2多项式的加减运算3... - ？
酆面美辛：[答案] 高二数学里有这个例子 排列组合里面的

海曙区13319027964： 数据结构课程设计(C语言版) 一元稀疏多项式的运算 - ？
酆面美辛： 数据关系:R=约定a1为栈底,an 为栈顶.基本操作:Push(&s,e) 初始条件:栈s已经存在.操作结果:插入元素e为新的栈顶元素 Pop(&s,&e) 初始条件:栈s已经存在且非空. 操作结果:删除s的栈顶元素,并用e返回其值

海曙区13319027964： 数据结构 一元多项式相乘的代码? - ？
酆面美辛： 这是数组实现,别人写的. #include void mul(int a[],int b[],int w) {int shi[40]; int q,k,p,l; for ( k=0;k<40;k++) {shi[k]=0;} for( q=w;q>=0;q--) {for( p=w;p>=0;p--) { shi[q+p]=shi[q+p]+a[q]*b[p]; } } printf(＂\np(x)*q(x) = ＂); for( l=2*w;l>=0;l--) { printf(＂%dx^%d + ...

海曙区13319027964： 用数据结构(C语言版)实现一元多项式的表示及相加 - ？
酆面美辛： 每个项用一个结点来表示,每个结点包含两个成员,分别表示该项的系数和次数.如果是用链表来实现线性表,那么结点还要包含next成员.此题最好用链表来实现.表示多项式,最好按照习惯,以次数的降序来排列各项.相加时,就是将其中一个链表的各结点保持降序,依次插入另一个链表.如果遇到次数相同的,就合并.如果合并后系数为0,则删除该结点.

海曙区13319027964： 数据结构一元多项式相加求C语言程序:f(X)=x^10+x^7+x^3+1加g(x)=x^5+3x^3+x^2+1 - ？
酆面美辛：[答案] 以前写的代码.#include using namespace std; #define max 10000000 struct node { float coef; int exp; node *next; }; struct Poly { char name; node *other; }poly[max]; int count;//poly的个数; //生成多项式的函数 void creat(node *&L) { node *p,*...

海曙区13319027964： 数据结构课程设计顺序结构、动态链表结构下的一元多项式加法的实现.(难度**) 设有一元多项式Am(x)和Bn(x). Am(x)=A0+A1x1+A2x2+A3x3+… +Amxm ... - ？
酆面美辛：[答案] void Poly(LNode *&p) { LNode *q = p; if (p !=NULL) { if (p -> data.exp == 0){ q = p->next; delete p; p = q; // 修改表头指针 } while(q != NULL){ q -> data.coef *= q -> data.exp; q -> data.exp--; q = q -> next; } } }

海曙区13319027964： 数据结构(c++)一元多项式的代数运算 - ？
酆面美辛： #include<iostream.h>