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

最新推荐文章于 2021-12-27 16:47:46 发布

JessicaWind

最新推荐文章于 2021-12-27 16:47:46 发布

阅读量1w

点赞数 7

文章标签： c语言链表多项式运算

本文链接：https://blog.csdn.net/meiyubaihe/article/details/26965471

版权

//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;
		printf("please input two numbers with the follow format:int,int\n");
		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 );
			AddPolyn( P1, temp );
	}
//	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 head1;
	Node *polyn2;
	Node head2;
	Node *polyn3;
	Node head3;
	Node *polyn4;
	Node head4;
	

	polyn1 = &head1;
	polyn2 = &head2;
	polyn3 = &head3;
	polyn4 = &head4;

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


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

	//将两个多项式相加并输出结果
	printf("***************多项式相加*****************\n");
	AddPolyn( polyn1, polyn2 );
	PrintPolyn( polyn1 );
	PrintPolyn( polyn2 );
	
	//创建第三个多项式	
	CreatPolyn( polyn3, 4 );
	//创建第四个多项式
	CreatPolyn( polyn4, 4 );
	printf("***************多项式相减*****************\n");
	SubtractPolyn( polyn3, polyn4 );
	PrintPolyn( polyn3 );

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

}