线性表及其应用（多项式相加、相乘）----根据程序画出流程图及对每句程序加注释(c语言）
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了线性表及其应用（多项式相加、相乘）----根据程序画出流程图及对每句程序加注释(c语言）相关的知识，希望对你有一定的参考价值。
#include "stdio.h"
typedef struct node
int c,e;
struct node *next;
PN;
PN *createPoly()
int n, e, c;
PN *head, *p;
//printf("请输入多项式项数:");
scanf("%d", &n);
head=p=new PN ; // * malloc(sizeof(PN));
while( n-- )
p->next=new PN;// * malloc(sizeof(PN));
p=p->next;
// printf("c e:");
scanf("%d%d" , &p->c, &p->e);
p->next=NULL;
return head;
void printPoly( PN *head)
PN *p=head->next;
while(p)
printf(" (%d,%d) ", p->c, p->e);
p=p->next;
printf("\n");
void freePoly( PN *head)
PN *p;
while( head )
p=head;
head=head->next;
delete(p);
PN *polyAdd(PN *ha, PN *hb)
int c, e;
PN *pa=ha->next, *pb=hb->next,
*hc, *pc;
hc=pc=new PN;
while( pa || pb )
if( pa && (pb==NULL || pa->e < pb->e))
c=pa->c;
e=pa->e;
pa=pa->next;
else if( pb && (pa==NULL || pa->e > pb->e))
c=pb->c;
e=pb->e;
pb=pb->next;
else
c=pa->c+pb->c;
e=pa->e;
pa=pa->next;
pb=pb->next;
if( c )
pc->next=new PN;
pc=pc->next;
pc->c=c;
pc->e=e;
pc->next=NULL;
return hc;
PN *mulxmul(PN *ha, PN *hb)
PN *t, *hc, *pa=ha->next;
PN *onexmul( PN *pa , PN *hb);
t=new PN; t->next=NULL;
while( pa )
hc=onexmul( pa, hb );
t=polyAdd( t, hc );
freePoly( hc );
pa=pa->next;
return t;
PN *onexmul ( PN *pa, PN *hb )
PN *hc, *pc, *pb=hb->next;
hc=pc=new PN;
while( pb )
pc->next=new PN;
pc=pc->next;
pc->c=pa->c * pb->c;
pc->e=pa->e + pb->e;
pb=pb->next;
pc->next=NULL;
return hc;
int main()
PN *ha, *hb, *hc;
freopen("poly.in" , "r" , stdin);
freopen("poly.txt", "w", stdout);
ha=createPoly();
printPoly(ha);
hb=createPoly();
printPoly(hb);
hc=polyAdd(ha, hb);
printPoly(hc);
freePoly(hc);
hc=mulxmul(ha,hb);
printPoly(hc);
freePoly(ha);
freePoly(hb);
freePoly(hc);
return 0;
符合要求的加分（qq:182285777)
typedef struct node
int c,e; //节点的数据域，c是多项式的系数，e是多项式的指数
struct node *next; //节点的指针域
PN; //自定义节点结构体，类型PN
PN *createPoly() //这个函数用来建立链表，返回值是一个节点指针
int n, e, c;
PN *head, *p; //定义头结点指针head，和节点指针p
printf("请输入多项式项数:");
scanf("%d", &n); //得到n的值，既项数
head=p=new PN ; // * malloc(sizeof(PN));//让head,p都指向头结点（头结点不用来存放数据）
p->next=NULL; //到这里为止，一个空链表建立完成
while( n-- ) //循环n次
p->next=new PN;// * malloc(sizeof(PN));//动态分配新的节点，并接在链表末尾（尾插法）
p=p->next;
// printf("c e:"); //给新的节点，添加数据
scanf("%d%d" , &p->c, &p->e);
p->next=NULL; //将表尾的指针域置为空
return head; //返回头结点地址
void printPoly( PN *head) //这个函数用来输入链表信息
PN *p=head->next; //节点指针p用来遍历链表,p先指向表头
while(p) //当p=NULL时（已经到表尾），结束循环
printf(" (%d,%d) ", p->c, p->e); //显示当前节点的数据
p=p->next; //将p指向移到下一个节点
printf("\n"); //输出一个回车
void freePoly( PN *head) //这个函数用来销毁链表
PN *p; //用来释放节点（动态内存块）
while( head ) //当head=NULL时（已经到表尾），结束循环
p=head; //让p指向head所指的节点
head=head->next; //将head指向移到下一个节点
delete(p); //释放p所指的节点（动态内存块）
PN *polyAdd(PN *ha, PN *hb) //这个函数用来将两个多项式相加
int c, e; //c是多项式的系数，e是多项式的指数
PN *pa=ha->next, *pb=hb->next, //pa,pb用来遍历通过参数传进来的两个链表（参数是两个链表的头结点指针），暂且称它们为链表a,b
*hc, *pc; //hc是两个链表对应节点相加后的新链表的头结点，pc用来遍历新链表,此链表称它为c
hc=pc=new PN;
while( pa || pb ) //当两个链表都遍历完毕，则循环停止
if( pa && (pb==NULL || pa->e < pb->e)) //取指数较小的一项链入链表或者链表b已经遍历完毕时，执行该if中的内容
c=pa->c;
e=pa->e;
pa=pa->next;
else if( pb && (pa==NULL || pa->e > pb->e)) //取指数较小的一项链入链表或者链表a已经遍历完毕时，执行该if中的内容
c=pb->c;
e=pb->e;
pb=pb->next;
else //指数相等的时候，执行
c=pa->c+pb->c;
e=pa->e;
pa=pa->next;
pb=pb->next;
if( c ) //将两个链表相加后的每个项 都放入新链表中
pc->next=new PN;
pc=pc->next;
pc->c=c;
pc->e=e;
pc->next=NULL;
return hc; //将新链表的头结点指针返回
PN *mulxmul(PN *ha, PN *hb) //这个函数将a表中每个项都掉用一次onexmul函数，最终实现多项式a与b的相乘
PN *t, *hc, *pa=ha->next;
PN *onexmul( PN *pa , PN *hb); //函数声明，因为接下来就要用到它
PN *polyAdd(PN *ha, PN *hb); //函数声明，因为接下来就要用到它
t=new PN; t->next=NULL; //存放最终结果的链表，t是表头,此表暂称为t表
while( pa ) //遍历a链表
hc=onexmul( pa, hb ); //将a表中pa所指的项与b表中所有的项相乘（即多项式a中的某一项与多项式b相乘）
t=polyAdd( t, hc ); //将每次相乘的结果相加
freePoly( hc ); //将调用onexmul函数产生的中间链表销毁，因为该链表的项，已经放到t链表中
pa=pa->next;
return t; //将t表的头结点指针返回
PN *onexmul ( PN *pa, PN *hb ) //这个函数用来将a表中pa所指的项与b表中所有的项相乘（即多项式a中的某一项与多项式b相乘）
PN *hc, *pc, *pb=hb->next; //hc是新链表的头结点，pc用来遍历新链表
hc=pc=new PN; //让hc,pc都指向头结点
while( pb ) //遍历b链表
pc->next=new PN; //建立新链表的节点
pc=pc->next;
pc->c=pa->c * pb->c; //给新节点赋值，系数等于系数相乘
pc->e=pa->e + pb->e; //指数等于指数相加
pb=pb->next;
pc->next=NULL;
return hc; //将新链表的头结点指针返回
int main()
PN *ha, *hb, *hc;
freopen("poly.in" , "r" , stdin); //只读模式打开poly.in
freopen("poly.txt", "w", stdout); //只写模式打开poly.txt
ha=createPoly(); //建立新链表，ha为头结点指针(多项式a)
printPoly(ha); //输出ha为头结点指针的链表信息
hb=createPoly(); //建立新链表，hb为头结点指针(多项式b)
printPoly(hb); //输出hb为头结点指针的链表信息
hc=polyAdd(ha, hb); //多项式a与多项式b相加，结果放在hc为头结点指针的链表中
printPoly(hc); //输出相加后的链表信息
freePoly(hc); //销毁该链表
hc=mulxmul(ha,hb); //多项式a与多项式b相乘，结果放在hc为头结点指针的链表中
printPoly(hc); //输出相乘后的链表信息
freePoly(ha); //销毁该链表
freePoly(hb); //销毁该链表
freePoly(hc); //销毁该链表
return 0;
OK,花了不少时间帮你写了下注释，应该比较完整了吧，原理和数学模型完全一样的，应该能看懂，流程图，相信看懂了程序，画起来不难，自己尝试下吧。 参考技术A 数据结构实验时候做的，细微地方和你的要求不一样，不过大体如此。。
#include<iostream>
#define MaxExp 1000
#define Max 100
using namespace std;
typedef struct Node
int coef; //系数
int exp; //指数
struct Node *link;//指向下一个节点的指针
LinkList;
////////////////////////////////////////////////////////
//建立循环链表
void CreateLinkList(LinkList *&L,int Coef[],int Exp[],int n)
L=(LinkList *)malloc(sizeof(LinkList));//
L->link=L;
LinkList *p,*s;
p=L; int i; //L指向头结点
for(i=0;i<n;i++)
s=(LinkList*)malloc(sizeof(LinkList)); //创建新结点
s->coef=Coef[i];s->exp=Exp[i];
s->link=L;
p->link=s;
p=s;
////////////////////////////////////////////////////////////
/*返回X的值*/
int Calc(LinkList *L)
LinkList *p;
p=L->link;
int q=0;
while(p!=L)
if(p->exp==1)q+=p->coef;//查找指数为1的项，并返回系数的和
p=p->link;
return q;
//////////////////////////////////////////////////////////
/*多项式相乘的算法*/
LinkList* Add(LinkList *L1,LinkList *L2)
/*两多项式相加*/
LinkList *p,*q,*r,*L3,*s;
L3=(LinkList *)malloc(sizeof(LinkList));//创建新链表的头结点
L3->link=L3;
p=L1->link;q=L2->link;r=L3->link;
int sum;
while(p!=L1&&q!=L2)
if(p->exp==q->exp)
//若指数相等，系数相加，链入链表
sum=p->coef+q->coef;
if(sum!=0)
s=(LinkList*)malloc(sizeof(LinkList));
s->coef=sum;
s->exp=p->exp;
r->link=s;
r=s;
p=p->link;
q=q->link;
else
//若指数不等，取指数较小的一项链入链表
if(p->exp>q->exp)
s=(LinkList*)malloc(sizeof(LinkList));
s->coef=q->coef;
s->exp=q->exp;
r->link=s;
r=s;
q=q->link;
else
s=(LinkList*)malloc(sizeof(LinkList));
s->coef=p->coef;
s->exp=p->exp;
r->link=s;
r=s;
p=p->link;
while(p!=L1)
//链入表1的剩余部分
s=(LinkList*)malloc(sizeof(LinkList));
s->coef=p->coef;
s->exp=p->exp;
r->link=s;
r=s;
p=p->link;
while(q!=L2)
//链入表2的剩余部分
s=(LinkList*)malloc(sizeof(LinkList));
s->coef=q->coef;
s->exp=q->exp;
r->link=s;
r=s;
q=q->link;
r->link=L3;//构成循环链表
return L3;
LinkList* Alone(const LinkList *L,int a,int b)
// 用一个多项式的其中一项乘以另一个多项式，返回新多项式的表头指针
//a为该项的系数，b为该项的指数
LinkList *p,*r,*q;
LinkList *L1;
L1=(LinkList*)malloc(sizeof(LinkList));//创建新链表，使原多项式不改变
L1->link=L1;
p=L->link;
r=L1->link;
while(p!=L)
//将改变后的各项系数及指数存入新链表中
q=(LinkList*)malloc(sizeof(LinkList));
q->exp=p->exp+b;
q->coef=p->coef*a;
q->link=L1;
r->link=q;
r=q;
p=p->link;
return L1;
LinkList* Mulpty(LinkList *a,LinkList *b)
//多项式相乘，利用相加运算，分解多项式
LinkList *p,*q;
p=a->link;
q=b->link;
LinkList *newl;
newl=(LinkList*)malloc(sizeof(LinkList));
newl->link=newl;
while(p!=a)
newl=Add(newl,Alone(b,p->coef,p->exp));
p=p->link;
return newl;
//////////////////////////////////////////////////////////////////////
void output(LinkList *a)
//输出多项式的信息（合并同类项）
int A[MaxExp]=0;
LinkList *p=a->link;
int t=0,i;
while(p!=a) //合并同类项按指数大小从小到大依次输出
if(p->exp>t)t=p->exp;
A[p->exp]+=p->coef;p=p->link;
cout<<"各项信息："<<endl;
for(i=0;i<=MaxExp;i++)
if(A[i]!=0)cout<<'('<<A[i]<<','<<i<<')';
cout<<endl;
///////////////////////////////////////////////////////////////////////
int main()
LinkList *a;
LinkList *b;
int CoefA[Max],ExpA[Max];
int CoefB[Max],ExpB[Max];
int na,nb,i;
cout<<"请输入多项式A的项数："<<endl;
cin>>na;
cout<<"输入各项的系数及指数："<<endl;
for(i=0;i<na;i++)
cin>>CoefA[i]>>ExpA[i];
CreateLinkList(a,CoefA,ExpA,na);
cout<<"请输入多项式B的项数："<<endl;
cin>>nb;
cout<<"输入各项的系数及指数："<<endl;
for(i=0;i<nb;i++)
cin>>CoefB[i]>>ExpB[i];
CreateLinkList(b,CoefB,ExpB,nb);
LinkList *c;
cout<<"A中X的值:"<<Calc(a)<<endl;
cout<<"B中X的值:"<<Calc(b)<<endl;
cout<<"多项式A+B:"<<endl;
output(Add(a,b));
c=Mulpty(a,b);
cout<<"***********************************"<<endl;
cout<<"多项式A*B:"<<endl;
output(c);
cout<<"************************************"<<endl;
cout<<"多项式A:"<<endl; //输出原来的多项式，并未改变
output(a);
cout<<"多项式B:"<<endl;
output(b);
system("pause");
return 0;
五、输入输出示例
/*
输入示例：
4
1 0
2 3
5 4
6 2
5
1 1
2 2
2 3
4 6
6 5
输出示例：
A中X的值:0
B中X的值:1
多项式A+B:
各项信息：
(1,0)(1,1)(8,2)(4,3)(5,4)(6,5)(4,6)
***********************************
多项式A*B:
各项信息：
(1,1)(2,2)(8,3)(14,4)(27,5)(18,6)(46,7)(36,8)(38,9)(20,10)
***********************************
多项式A:
各项信息：
(1,0)(6,2)(2,3)(5,4)
多项式B:
各项信息：
(1,1)(2,2)(2,3)(6,5)(4,6)
请按任意键继续. . . 参考技术B 你的程序时正确的？还是还要帮你改错？
第二章：5.线性表应用---一元多项式的表示及相加
前言：
学习了线性表的 顺序结构 和链式结构，那么这种学习有什么用？
本节将会学习如何用线性表来实现 一元多项式的表示及相加。
目录：
1.一元多项式
正文：
一元多项式：
数学上，一个一元多项式可写成 按幂升序排列的形式：
Pn(x)= P0 + P1x1 + P2x2 + .... + Pnxn
它由 n+1 个系数唯一确定，因此在计算机里可以用线性表 P 来表示：
P= （P0，P1， P2 ， .... Pn）；
其中每一项的指数 隐藏在Pi 的序号中
一元多项式的相加（采用 顺序存储结构）：
设m<n ,两个多项式相加的结果为：Rn(x) = Pn(x) + Qm(x)
此运算可以用相性表R 来表示：
R= （P0 + Q0，P1+ Q1， P2 + Q2， .... + Pm+ Qm，Pm+1 ,.... Pn）；
如果你已经掌握了 线性表的顺序存储，那么你会发现，显然R P Q 采用顺序存储结构，使得多项式的相加算法 十分简单清晰，很容易实现。
一元多项式的表示相加（采用 链式存储结构）：
依然采用顺序结构来表示 一元多项式，那么对于如下多项式：
S(x)= 1 + 3x1000 + 2x20000
顺序存储结构会开辟 20001 个长度的存储空间，但是此多项式只有3项，于是造成了对内存空间的极大浪费。
改进：使用链式存储结构来表示 一元多项式，由于链式存储 数据元素在物理位置上不是相邻的，此时无法通过位序来确定 多项式中系数对应的指数，那么此时 链表只存储一元多项式的非零项，每个结点存储两个数据域：（项:pi ,指数:ei） 一个指针域：next。
这种形式下，最坏的存储情况是 多项式没有非零项，即 n+1 个项数，耗费存储空间为 采用顺序结构耗费存储空间 的2倍，但是对比 S(X)类型多项式的存在，一元多项式采用链表的形式将大大节省存储空间。
存储结构图示：
用C语言表示的存储结构：
typedef struct Polynomial{
float coef; //系数
int expn; //指数
struct LNode *next; //结点的指针域
}Polynomial,*LinkList;
代码实现：
#include<stdio.h>
#include<stdlib.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
//Status是函数的类型，其值是函数结果状态码
typedef int Status;
typedef struct Polynomial{
float coef; //系数
int expn; //指数
struct Polynomial *next; //结点的指针域
}Polynomial,*LinkList;
//创建具有m个项的一元多形式
Status CreatPolyn(LinkList &L,int m){
Polynomial * q=L; //q指向头结点（最后一个结点）
float coef;
int expn;
for(int i=0;i<m;i++){
printf("%s","请输入系数：");
scanf("%f",&coef);
printf("%s","请输入指数：");
scanf("%d",&expn);
Polynomial * Polyn=(LinkList)malloc(sizeof(Polynomial));
if(!Polyn) return ERROR;
Polyn->coef=coef;
Polyn->expn=expn;
q->next=Polyn; //追加结点
q=Polyn; //指向最后一个结点
}
q->next=NULL;
return OK;
}
//多项式Pa 和 Pb相加，将结果保存在Pa 链中。
void AddPolyn(LinkList &La,LinkList &Lb){
Polynomial * qa=La;
Polynomial * qb=Lb;
while(qa->next&&qb->next){
//1.如果当前 qa 的指数 大于 qb 的指数。那么把 qb 所指结点插入到qa 所指结点之后,
if((qa->next->expn)>(qb->next->expn)){
Polynomial * temp=qb->next;
qb->next=qb->next->next; //从 qb 中删除当前结点
temp->next=qa->next; //在 qa 当前元素前 插入 qb中删除的结点
qa->next=temp;
}
//2.如果当前 qa 的指数 小于 qb 的指数。那么只需后移 qa指针即可。
if((qa->next->expn)<(qb->next->expn)){
qa=qa->next;
}
//3.如果当前 qa 的指数 等于 qb 的指数。那么让对应系数相加。
if((qa->next->expn)==(qb->next->expn)){
float temp=(qa->next->coef)+(qb->next->coef);
//分别从qa 中删除当前结点
if(temp==0){
qa->next=qa->next->next;
}
//修改qa当前结点 的系数，后移指针。
if(temp!=0){
qa->next->coef=temp;
qa=qa->next;
}
qb=qb->next;
}
}
}
void PrintAllValues(LinkList &L){
Polynomial * q=L; //q指向头结点
while(q->next){
printf("系数：%f",q->next->coef);
printf("指数：%d\\n",q->next->expn);
q=q->next;
}
}
void main(){
Polynomial * Pa=(LinkList)malloc(sizeof(Polynomial));
Pa->next=NULL;
printf("%s\\n","Pa：");
CreatPolyn(Pa,4);
PrintAllValues(Pa);
Polynomial * Pb=(LinkList)malloc(sizeof(Polynomial));
Pb->next=NULL;
printf("\\n%s\\n","Pb:");
CreatPolyn(Pb,3);
PrintAllValues(Pb);
AddPolyn(Pa,Pb);
printf("\\n%s\\n","Pa+Pb:");
PrintAllValues(Pa);
}
运行结果：
以上是关于线性表及其应用（多项式相加、相乘）----根据程序画出流程图及对每句程序加注释(c语言）的主要内容，如果未能解决你的问题，请参考以下文章