C语言实现一元多项式加法运算（链表）

C语言实现一元多项式加法运算（链表）

完成如下操作：
①输入并建立一元稀疏多项式；（输入格式自定）
例如：4 - 12x³ + 123x⁵ - 80x¹⁰
②输出所建立的一元多项式；（输出格式自定）
例如：12 - 3x + x³ + 230x¹²
③ 实现两个多项式相加运算并输出；.
④ 实现两个多项式相减运算并输出；

实验要求：
程序运行后显示一个文本方式的用户界面
··························································
一元多项式加法
0：退出
1：输入并建立多项式
2：输出多项式
3：将两个多项式相加并输出
4：将两个多项式相减并输出
·························································
详细思路见代码注释

#include <stdio.h>
#include <stdlib.h>

typedef struct Node {
	int coef;//系数
	int expn;//指数
	struct Node *next;
} LNode; //LNode为创建的多项式链表类型

struct elem {
	int coef;
	int expn;
} List[100],change;   //List[]构建链表,change用来交换List[]中的某两项

LNode* create(int n);
LNode* add(LNode *p1,LNode *p2); //相加
LNode* sub(LNode *p1,LNode *p2); //相减
void print(LNode *p1);


int main() {
	while(1) {
		int choose;
		int z=2;
		LNode *head2[2];     //head2[]为两多项式的头结点
		int n,i,j;
		int k=1;
		printf("\n\n");//与上次的输出结果保持间隔，便于美观
		printf("	______________________________________________\n");//菜单输出
		printf("	|                     MENU                    |\n");
		printf("	|             1.输入并建立多项式              |\n");
		printf("	|             2.输出多项式                    |\n");
		printf("	|             3.将两个多项式相加运算并输出    |\n");
		printf("	|             4.将两个多项式相减运算并输出    |\n");
		printf("	|             0.  quit                        |\n");
		printf("	|_____________________________________________|\n");
		printf("Please choose your function: ");
		scanf("%d",&choose);
		switch(choose) {
			case 0:
				exit(0);
				break;
			case 1:
				while(z) {
					printf("请输入该多项式的项数\n");
					scanf("%d",&n);
					printf("请输入各项的系数与指数\n");
					i=1;
					for(i=1; i<=n; i++)
						scanf("%d%d",&List[i].coef,&List[i].expn);
					i=1;
					j=1;
					for(i; i<n; i++)
						for(j=i+1; j<=n; j++) {
							if(List[j].expn < List[i].expn) {  //将输入的指数按升序排列 ，排序算法
								change.coef = List[i].coef;
								change.expn = List[i].expn;
								List[i].coef = List[j].coef;
								List[i].expn = List[j].expn;
								List[j].coef = change.coef;
								List[j].expn = change.expn;
							}
						}
					head2[k] = create(n);
					k++;
					z--;
				}
				break;
			case 2:
				print(head2[1]);
				printf("\n");
				print(head2[2]);
				printf("\n");
				break;
			case 3:
				LNode *pp;
				pp=add(head2[1],head2[2]);
				printf("结果为：\n");
				print(pp);
				system("pause");
				break;
			case 4:
				LNode* ppp;
				ppp=sub(head2[1],head2[2]);
				printf("结果为：\n");
				print(ppp);
				system("pause");
				break;
		}
	}
	return 0;
}

//创建链表
LNode* create(int n) {
	LNode *head;
	LNode *s,*L;              //*s表示新创建的空表，*L表示当前的链表，用来连接两空表
	L=s=NULL;
	head=(LNode *)malloc(sizeof(LNode));
	head->next = 0;                 //定义空链表
	L =  (LNode *)malloc(sizeof(LNode));
	n--;
	L->coef = List[1].coef;          //复制
	L->expn = List[1].expn;
	head->next = L;
	int i = 2;
	while(n) {
		s=(LNode *)malloc(sizeof(LNode));
		L->next=s;
		s->coef=List[i].coef;
		s->expn=List[i].expn;
		L=s;
		n--;
		i++;
	}
	L->next=0;
	return head;
}

//进行加法运算
LNode* add(LNode *p1,LNode *p2) { //将多项式p1与p2相加，结果存在第三个链表中（第三个链表由该函数创建）

	p1=p1->next;
	p2=p2->next;
	LNode *head;
	LNode *L,*s;
	head=(LNode *)malloc(sizeof(LNode));
	head->next=NULL;
	L=head;
	while(p1&&p2) {          //遍历两表，根据情况判断表的长短是否相同，是否缺项多项，建立一个新的链表来存取内容
		if(p1->expn > p2->expn) { //比较指数大小，将指数和系数较小的存入新表
			s=(LNode *)malloc(sizeof(LNode));
			L->next=s;
			s->coef=p2->coef;
			s->expn=p2->expn;
			L=s;
			p2=p2->next;
		}
		if(p1->expn < p2->expn) { //比较指数大小，将指数和系数较小的存入新表
			s=(LNode *)malloc(sizeof(LNode));
			L->next=s;
			s->coef=p1->coef;
			s->expn=p1->expn;
			L=s;
			p1=p1->next;
		}
		if(p1->expn == p2->expn) { //相等可以直接相加
			s=(LNode *)malloc(sizeof(LNode));
			L->next=s;
			s->coef=p1->coef + p2->coef;
			s->expn=p1->expn;
			L=s;
			p1=p1->next;
			p2=p2->next;
		}
	}
	while(p1) { //p1有剩余
		s=(LNode *)malloc(sizeof(LNode));
		L->next=s;
		s->coef=p1->coef;
		s->expn=p1->expn;
		L=s;
		p1=p1->next;
	}
	while(p2) { //p2有剩余
		s=(LNode *)malloc(sizeof(LNode));
		L->next=s;
		s->coef=p2->coef;
		s->expn=p2->expn;
		L=s;
		p2=p2->next;
	}
	L->next=NULL;
	return head;
}

//进行减法运算
//减法运算时要将第二个表的多出来的部分按照相反数输出
LNode* sub(LNode *p1,LNode *p2) { //将多项式p1与p2相加，结果存在第三个链表中（第三个链表由该函数创建）
	p1=p1->next;
	p2=p2->next;
	LNode *head;
	LNode *L,*s;
	head = (LNode *)malloc(sizeof(LNode));
	head->next = NULL;
	L = head;
	while(p1&&p2) {          //遍历两表，根据情况判断表的长短是否相同，是否缺项多项，建立一个新的链表来存取内容
		if(p1->expn > p2->expn) { //比较指数大小，将指数和系数较小的存入新表
			s=(LNode *)malloc(sizeof(LNode));
			L->next = s;
			s->coef = p2->coef;
			s->expn = p2->expn;
			L = s;
			p2 = p2->next;
		}
		if(p1->expn < p2->expn) { //比较指数大小，将指数和系数较小的存入新表
			s=(LNode *)malloc(sizeof(LNode));
			L->next = s;
			s->coef = p1->coef;
			s->expn = p1->expn;
			L = s;
			p1 = p1->next;
		}
		if(p1->expn == p2->expn) { //相等可以直接相加
			s = (LNode *)malloc(sizeof(LNode));
			L->next = s;
			s->coef = p1->coef - p2->coef;
			s->expn = p1->expn;
			L = s;
			p1 = p1->next;
			p2 = p2->next;
		}
	}
	while(p1) { //p1有剩余
		s=(LNode *)malloc(sizeof(LNode));
		L->next=s;
		s->coef=p1->coef;
		s->expn=p1->expn;
		L=s;
		p1=p1->next;
	}
	while(p2) { //p2有剩余
		s=(LNode *)malloc(sizeof(LNode));
		L->next=s;
		s->coef= -p2->coef;
		s->expn=p2->expn;
		L=s;
		p2=p2->next;
	}
	L->next=NULL;
	return head;
}

//输出结果
void print(LNode *p1) {   //输出表
	p1=p1->next;
	while(p1) {
		printf("+ %d X`%d  ",p1->coef,p1->expn);
		p1=p1->next;
	}
}

发现有如下bug，
**1：**上述程序只能讲系数赋值为整形变量，改进后可将系数赋值为浮点型
**2：**上述程序无法处理 0 个项数的情况，改进后可将某一多项式设置为 0
**3：**上述程序的结果显示为系数为 0 也会显示出指数，改进后结果为0 的只显示一个 0

下面是改进程序

#include <stdio.h>
#include <stdlib.h>

typedef struct Node
{
	float coef;//系数 
	int expn;//指数
	struct Node *next;
}LNode;  //LNode为创建的多项式链表类型

struct elem
{
	float coef;
	int expn;
}List[100],change;    //List[]构建链表,change用来交换List[]中的某两项

LNode* create(int n);
LNode* add(LNode *p1,LNode *p2); //相加 
LNode* sub(LNode *p1,LNode *p2); //相减 
void print(LNode *p1);

int main()
{
	while(1)
	{
		int choose;
		int z=2;
		LNode *head2[2];     //head2[]为两多项式的头结点
		int n,i,j;
		int k=1; 
		printf("\n\n");//与上次的输出结果保持间隔，便于美观 
		printf("	______________________________________________\n");//菜单输出 
		printf("	|                     MENU                    |\n");
		printf("	|             1.输入并建立多项式              |\n");               
		printf("	|             2.输出多项式                    |\n");
		printf("	|             3.将两个多项式相加运算并输出    |\n");
		printf("	|             4.将两个多项式相减运算并输出    |\n");
		printf("	|             0.  quit                        |\n");
		printf("	|_____________________________________________|\n");
		printf("请选择您将要执行的程序: ");
		scanf("%d",&choose);
		switch(choose)
		{
			case 0:exit(0); break;
			case 1:
				while(z)                                        
				{
					i=1;j=1;
					printf("请输入该多项式的项数\n");//如果输入的项数为 0 呢？ 
					scanf("%d",&n);
					
					if(n>0)
					{
						printf("请输入各项的系数与指数\n");
						for(i=1;i<=n;i++)
						scanf("%f %d",&List[i].coef,&List[i].expn);
						for(i;i<n;i++)
							for(j=i+1;j<=n;j++)
							{
								if(List[j].expn < List[i].expn)    //将输入的指数按升序排列 ，排序算法 
								{
									change.coef = List[i].coef;
									change.expn = List[i].expn;
									List[i].coef = List[j].coef;
									List[i].expn = List[j].expn;
									List[j].coef = change.coef;
									List[j].expn = change.expn;
								}
							}
					    head2[k] = create(n); 
						k++;z--;
					}
					  
					if(n==0)
					{
						n=1;
						printf("请把项数与指数均设置为 0 \n");	
						for(i=1;i<=n;i++)
						scanf("%f %d",&List[i].coef,&List[i].expn);
						if(List[i-1].coef == 0 && List[i-1].expn == 0)
						{
							LNode *head;                                    
							LNode *s,*L;              //*s表示新创建的空表，*L表示当前的链表，用来连接两空表
							L=s=NULL;
							head=(LNode *)malloc(sizeof(LNode));
							head->next = 0;                 //定义空链表 
							L =  (LNode *)malloc(sizeof(LNode));
							n--;                                            
							L->coef = List[1].coef;          //复制
							L->expn = List[1].expn;
							head->next = L;
							int i = 2;             
							while(n)
							{
								s=(LNode *)malloc(sizeof(LNode));
								L->next=s;
								s->coef=List[i].coef;
								s->expn=List[i].expn;
								L=s;
								n--;
								i++;
							}
							L->next=0;
							
							k++;
							z--;
						}
						else
						{
							printf("输入错误，请重新启动程序\n");
							exit(0);
						}
					}
					
					if(n<0)
					{
						printf("输入错误，请重新启动程序\n");
						exit(0);
					}
				}		
				break;
			case 2:
				print(head2[1]);
				printf("\n");
				print(head2[2]); 
				printf("\n");
				break;
			case 3:
				LNode *pp;
				pp=add(head2[1],head2[2]);
				printf("结果为：\n");
				print(pp);
				system("pause");
				break; 
			case 4:
				LNode* ppp;
				ppp=sub(head2[1],head2[2]);
				printf("结果为：\n");
				print(ppp);
				system("pause");
				break;
		}
	 } 
	return 0;
 } 
 
//创建链表 
 LNode* create(int n)       
{
	LNode *head;                                    
	LNode *s,*L;              //*s表示新创建的空表，*L表示当前的链表，用来连接两空表
	L=s=NULL;
	head=(LNode *)malloc(sizeof(LNode));
	head->next = 0;                 //定义空链表 
	L =  (LNode *)malloc(sizeof(LNode));
	n--;                                            
	L->coef = List[1].coef;          //复制
	L->expn = List[1].expn;
	head->next = L;
	int i = 2;             
	while(n)
	{
		s=(LNode *)malloc(sizeof(LNode));
		L->next=s;
		s->coef=List[i].coef;
		s->expn=List[i].expn;
		L=s;
		n--;
		i++;
	}
	L->next=0;
	return head;
}

//进行加法运算 
LNode* add(LNode *p1,LNode *p2)   //将多项式p1与p2相加，结果存在第三个链表中（第三个链表由该函数创建）
{  
	p1=p1->next;              
	p2=p2->next;
	LNode *head;              
	LNode *L,*s;
	head=(LNode *)malloc(sizeof(LNode));
	head->next=NULL;
	L=head;
	while(p1&&p2)            //遍历两表，根据情况判断表的长短是否相同，是否缺项多项，建立一个新的链表来存取内容 
	{
		if(p1->expn > p2->expn)//比较指数大小，将指数和系数较小的存入新表 
		{
			s=(LNode *)malloc(sizeof(LNode));
			L->next=s;
			s->coef=p2->coef;
			s->expn=p2->expn;
			L=s;
			p2=p2->next;
		}
		if(p1->expn < p2->expn)//比较指数大小，将指数和系数较小的存入新表 
		{
			s=(LNode *)malloc(sizeof(LNode));
			L->next=s;
			s->coef=p1->coef;
			s->expn=p1->expn;
			L=s;
			p1=p1->next;
		}
		if(p1->expn == p2->expn)//相等可以直接相加 
		{
			s=(LNode *)malloc(sizeof(LNode));
			L->next=s;
			s->coef=p1->coef + p2->coef;
			s->expn=p1->expn;
			L=s;
			p1=p1->next;
			p2=p2->next;
		}
	}
	while(p1)//p1有剩余 
	{
		s=(LNode *)malloc(sizeof(LNode));
		L->next=s;
		s->coef=p1->coef;
		s->expn=p1->expn;
		L=s;
		p1=p1->next;
	}
	while(p2)//p2有剩余 
	{
		s=(LNode *)malloc(sizeof(LNode));
		L->next=s;
		s->coef=p2->coef;
		s->expn=p2->expn;
		L=s;
		p2=p2->next;
	}
	L->next=NULL;
	return head;
}

//进行减法运算 
//减法运算时要将第二个表的多出来的部分按照相反数输出，目前还没有更改 
LNode* sub(LNode *p1,LNode *p2)   //将多项式p1与p2相加，结果存在第三个链表中（第三个链表由该函数创建）
{  
 
	p1=p1->next;              
	p2=p2->next;
	LNode *head;              
	LNode *L,*s;
	head = (LNode *)malloc(sizeof(LNode));
	head->next = NULL;
	L = head;
	while(p1&&p2)            //遍历两表，根据情况判断表的长短是否相同，是否缺项多项，建立一个新的链表来存取内容 
	{
		if(p1->expn > p2->expn)//比较指数大小，将指数和系数较小的存入新表 
		{
			s=(LNode *)malloc(sizeof(LNode));
			L->next = s;
			s->coef = p2->coef;
			s->expn = p2->expn;
			L = s;
			p2 = p2->next;
		}
		if(p1->expn < p2->expn)//比较指数大小，将指数和系数较小的存入新表 
		{
			s=(LNode *)malloc(sizeof(LNode));
			L->next = s;
			s->coef = p1->coef;
			s->expn = p1->expn;
			L = s;
			p1 = p1->next;
		}
		if(p1->expn == p2->expn)//相等可以直接相加 
		{
			s = (LNode *)malloc(sizeof(LNode));
			L->next = s;
			s->coef = p1->coef - p2->coef;
			s->expn = p1->expn;
			L = s;
			p1 = p1->next;
			p2 = p2->next;
		}
	}
	while(p1)//p1有剩余 
	{
		    s=(LNode *)malloc(sizeof(LNode));
			L->next=s;
			s->coef=p1->coef;
			s->expn=p1->expn;
			L=s;
			p1=p1->next;
	}
	while(p2)//p2有剩余 
	{
		    s=(LNode *)malloc(sizeof(LNode));
			L->next=s;
			s->coef= -p2->coef;
			s->expn=p2->expn;
			L=s;
			p2=p2->next;
	}
	L->next=NULL;
	return head;
}

//输出结果 
void print(LNode *p1)     //输出表
{
	p1=p1->next;
	while(p1)
	{
		if(p1->coef != 0)
			printf("+ %.2f X`%d  ",p1->coef,p1->expn);
		if(p1->coef == 0)
			printf("+ 0 ");
		p1=p1->next;
	}
}

欢迎大家继续提出改进意见~