1. 程式人生 > >多項式的加減法以及乘法的C語言實現

多項式的加減法以及乘法的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;
		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 );

}