# 多项式的加减法以及乘法的C语言实现

//polyn.h
#include< stdlib.h >
#include< string.h >

typedef struct term{
int coef;
int	expn;
}ElemType;

typedef struct node{
ElemType	data;
struct	node *next;
}Node;

//创建一个含有m项的多项式，需要输入m次参数，每次输入两个参数：系数和指数，且每次输入的指数不能相同
void CreatPolyn( Node *P, int m )
{
int i;
Node *current;
Node *pre;

printf( "create a new polynomial:\n" );
P->next = NULL;
pre = P;

for( i = 0; i < m; i++ ){
current = ( Node * )malloc( sizeof( Node ) );
current->next = NULL;
scanf( "%d,%d",&( current->data.coef ),&( current->data.expn) );
if( i == 0 )
P->next = current;

else
pre->next = current;
if( pre->data.expn == current->data.expn){
printf( "ERROR:the expn of two elements couldn't be the same\n");
exit( EXIT_FAILURE );
}
pre = current;

}
}

//计算多项式的长度，即项数
int PolynLength( Node * P )
{
int count = 0 ;
Node *current;

current = P->next;
while( current != NULL ){
current = current->next;
count++;
}
return count;
}

//冒泡法将多项式按升序排列，即幂次小的在前，幂次大的在后
void Increase( Node *P1)
{
Node	*current;
Node	*nex;
Node	*pre;
int count = PolynLength( P1 );
int i,j;

for( i = 1; i < count; i++ ){
current = P1->next;
pre = P1->next;
for( j = 0; j < count - i; j++ ){
nex = current->next;
if( current->data.expn > nex->data.expn ){
current->next = nex->next;
nex->next= current;
if( current ==  P1->next ){
P1->next = nex;
pre = P1->next;
}
else{
pre->next = nex;
pre = pre->next;
}

}
else{
pre = current;
current = nex;
}
}
}
}

//将两个多项式相加，且相加后P1指向相加结果的头结点，释放P2
void AddPolyn( Node *P1, Node *P2 )
{

Node *current1;
Node *current2;
Node *pre;

Increase( P1 );
Increase( P2 );

current1 = P1->next;
current2 = P2->next;
pre = P1;

while( current1 && current2 ){         //当两个多项式都没有达到末尾时
if( current1->data.expn < current2->data.expn ){  //如果current1对应的指数小于current2对应的指数时
if( current1 == P1->next && current2 == P2->next ){ //如果是第一个多项式的第一项的指数小于第二个多项式的第一项的指数
P1->next = current1;							   //则current1也是相加后的多项式的第一项
}
else{													//否则将current1添加到相加后的多项式的最后一项
pre->next = current1;
}
pre = current1;                 //pre指向相加后的多项式的最后一项
current1 = current1->next;      //第一个多项式的current1指向当前项的后一项
}
else if( current1->data.expn == current2->data.expn ){  //如果current1对应的指数等于current2对应的指数时
current1->data.coef += current2->data.coef;  //将两个多项式的系数相加赋给第一个多项式的对应项的系数
if( current1 == P1->next && current2 == P2->next ){  //如果是第一个多项式的第一项的指数等于第二个多项式的第一项的指数
P1->next = current1;			//则current1也是相加后的多项式的第一项
}
else{
pre->next = current1;			//否则将current1添加到相加后的多项式的最后一项
}
pre = current1;						//pre指向相加后的多项式的最后一项
current1 = current1->next;			//第一个多项式的current1指向当前项的后一项
current2 = current2->next;			//第二个多项式的current2指向当前项的后一项
}
else{									//如果current1对应的指数大于current2对应的指数时
if( current2 == P2->next && current1 == P1->next){ //如果是第一个多项式的第一项的指数大于第二个多项式的第一项的指数
P1->next = current2;							//则current2也是相加后的多项式的第一项
}
else{												//否则将current2添加到相加后的多项式的最后一项
pre->next = current2;
}
pre = current2;										//pre指向相加后的多项式的最后一项
current2 = current2->next;							//第二个多项式的current2指向当前项的后一项
}
}

if( current1 )					//如果第一个多项式的元素有剩余，则将第一个多项式剩余的元素连接在相加后的多项式链表的末尾
pre->next = current1;
else							//否则将第二个多项式剩余的元素连接在相加后的多项式链表的末尾
pre->next = current2;
P2->next = NULL;             //释放P2

}

//将两个多项式相减，且相减后P1指向相减结果的头结点，释放P2
void MultiplyPolyn( Node *P1, Node *P2 )
{

Node *current1;
Node *current2;
Node *temp;
Node *current;
Node *pre;

current1 = P1->next;
current2 = P2->next;

temp = ( Node *)malloc( sizeof( Node ) );
temp->next = NULL;

//1、用多项式1的第一个结点current1与多项式二的各个节点依次相乘，结果存放在以P1指向的结点为头结点的链表中，current1指向下一个结点
//2、用多项式1的current1与多项式二的各个节点依次相乘，结果存放在以temp指向的结点为头结点的链表中，current1指向下一个结点
//3、将以上两个链表相加
//4、循环重复步骤2和3直至current1指向下一个结点为空
for( ; current1 != NULL; current1 = current1->next ){
for( current2 = P2->next; current2 != NULL; current2 = current2->next ){
current = ( Node *)malloc( sizeof( Node ) );					//创建一个新的多项式结点
current->data.coef = current1->data.coef * current2->data.coef; //给该结点赋值，
current->data.expn = current1->data.expn + current2->data.expn;
current->next = NULL;
if( current2 == P2->next ){
if( current1 == P1->next ){
pre = P1;
P1->next = current;
}
else{
pre = temp;
temp->next = current;
}
}
else{
pre->next = current;
}
pre = current;
}
if( temp->next != NULL );
}
//	free( temp );
temp->next = NULL;
P2->next = NULL;
}

//将两个多项式相乘，且相乘后P1指向相乘结果的头结点，释放P2
void SubtractPolyn( Node *P1, Node *P2 )
{

Node *current1;
Node *current2;
Node *pre;

Increase( P1 );
Increase( P2 );

current1 = P1->next;
current2 = P2->next;
pre = P1;

while( current1 && current2 ){     //当两个多项式的current都非空时
if( current1->data.expn < current2->data.expn ){		//如果第一个多项式的指数小于第二个多项式的指数
if( current1 == P1->next && current2 == P2->next){ //如果是第一个多项式的第一项的指数小于第二个多项式的第一项的指数
P1->next = current1;							//则current1即为相减后的多项式的第一项
}
else{
pre->next = current1;							//否则将current1添加到相减后的多项式的最后一项
}
pre = current1;										//pre指向相减后的多项式的最后一项
current1 = current1->next;							//第一个多项式的current1指向当前项的后一项
}
else if( current1->data.expn == current2->data.expn ){   //如果第一个多项式的指数等于第二个多项式的指数
current1->data.coef -= current2->data.coef;			//用第一个多项式的系数减去第二个多项式的系数结果赋给第一个多项式的对应项的系数
if( current1 == P1->next && current2 == P2->next ){	//如果两个多项式的第一项的指数相等
P1->next = current1;							//则current1即为相减后的多项式的第一项
}
else{												//否则将current1添加到相减后的多项式的最后一项
pre->next = current1;
}
pre = current1;										//pre指向相减后的多项式的最后一项
current1 = current1->next;					//第一个多项式的current1指向当前项的后一项
current2 = current2->next;					//第二个多项式的current2指向当前项的后一项
}
else{
current2->data.coef = -current2->data.coef;   //如果第一个多项式的指数大于第二个多项式的指数
if( current2 == P2->next && current1 == P1->next ){	 //若第二个多项式的第一项的指数小于第一个多项式的第一项的指数
P1->next = current2;					        //则current2即为相减后的多项式的第一项
}
else{												//否则将current1添加到相减后的多项式的最后一项
pre->next = current2;
}
pre = current2;									//pre指向相减后的多项式的最后一项
current2 = current2->next;				//第二个多项式的current2指向当前项的后一项
}
}

if( current1 )
pre->next = current1;
else{
while( current2 ){
current2->data.coef = -current2->data.coef;
pre->next = current2;
current2 = current2->next;
}
}
P2->next = NULL;
}

//打印多项式的参数
void PrintPolyn( Node *P )
{
Node *current;
current = P->next;
while( current != NULL ){
printf( "%5d,%5d\n", current->data.coef,current->data.expn );
current = current->next;
}

}
<pre name="code" class="cpp">#include< stdio.h >
#include "polyn.h"

void main()
{
Node *polyn1;
Node *polyn2;
Node *polyn3;
Node *polyn4;

//创建第一个多项式
CreatPolyn( polyn1, 4 );

//创建第二个多项式
CreatPolyn( polyn2, 4 );

//将两个多项式相加并输出结果
printf("***************多项式相加*****************\n");
PrintPolyn( polyn1 );
PrintPolyn( polyn2 );

//创建第三个多项式
CreatPolyn( polyn3, 4 );
//创建第四个多项式
CreatPolyn( polyn4, 4 );
printf("***************多项式相减*****************\n");
SubtractPolyn( polyn3, polyn4 );
PrintPolyn( polyn3 );

//将两个多项式相乘
printf("***************多项式相乘*****************\n");
MultiplyPolyn( polyn1, polyn3 );
PrintPolyn( polyn1 );

} 

• 本文已收录于以下专栏：

## 简单的多项式乘法实现程序 C语言

• 2010年02月09日 19:55
• 4KB
• 下载

## 多项式乘法（C语言）

• 2009年06月14日 21:40
• 21KB
• 下载

## 链表实现多项式加法和乘法（C语言实现）

#include#include#includetypedef struct list{    int xishu;    int power;    struct list *next;}list;...
• nanshao3618
• 2010年12月03日 16:32
• 1892

## PAT 3-04 一元多项式的乘法与加法运算（C语言实现）

• wutongyu0113
• 2014年10月03日 15:14
• 1565

## c语言实现多项式乘法

• 2011年12月13日 19:38
• 257KB
• 下载

## 多项式求值的几个简单算法（C语言）

• liyuanbhu
• 2017年03月12日 22:10
• 2418

## 一元多项式的相乘（C链表实现）.

• 2011年07月25日 11:52
• 153KB
• 下载

## 华为面试题：一元多项式的化简 C语言实现源码

• hepfei90
• 2015年03月04日 09:12
• 2144

## 一元多项式相加(C语言实现)

poly.h#ifndef _POLY_H_ #define _POLY_H_#include #include #include//结点结构 typedef struct Polynode { ...
• ColdCoding
• 2016年01月18日 15:01
• 5526

## 多项式的c语言算法实现（包含加、减、乘。除法还未写好）

#include#include#includetypedef struct node{  float exof;//系数  int expn;//指数}DataNode;typedef struct...
• bzqcool
• 2009年10月13日 17:16
• 993

举报原因： 您举报文章：多项式的加减法以及乘法的C语言实现 色情 政治 抄袭 广告 招聘 骂人 其他 (最多只允许输入30个字)