精华内容
下载资源
问答
  • C语言链表的入门题,里面提供了两种思路供参考,用链表来实现一元多项式的加减法,并按照一定规律输出。也是练习链表和排序算法的一道小实验,初学链表的小伙伴可以参考参考噢
  • C语言实现一元多项式加法运算(链表

    千次阅读 多人点赞 2019-10-05 21:26:25
    C语言实现一元多项式加法运算(链表) 完成如下操作: ①输入并建立一元稀疏多项式;(输入格式自定) 例如:4 - 12x3 + 123x5 - 80x10 ②输出所建立的一元多项式;(输出格式自定) 例如:12 - 3x + x3 + 230x12 ③...

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

    完成如下操作
    ①输入并建立一元稀疏多项式;(输入格式自定)
    例如:4 - 12x3 + 123x5 - 80x10
    ②输出所建立的一元多项式;(输出格式自定)
    例如:12 - 3x + x3 + 230x12
    ③ 实现两个多项式相加运算并输出;.
    ④ 实现两个多项式相减运算并输出;

    实验要求
    程序运行后显示一个文本方式的用户界面
    ··························································
    一元多项式加法
    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;
    	}
    }
    

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

    展开全文
  • 主要为大家详细介绍了C语言单链表实现多项式相加,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • C语言一元多项式相加链表

    千次阅读 多人点赞 2020-10-30 21:10:52
    今天写一个关于一元多项式相加的程序,就当是在练习运用一下链表的知识。首先,我们先来分析一波,一元多项式相加,首先要用链表创建两个或多个多项式,每个节点里的数据有两个,系数和指数;其次,如果要实现乱幂...

    今天写一个关于一元多项式相加的程序,就当是在练习运用一下链表的知识。首先,我们先来分析一波,一元多项式相加,首先要用链表创建两个或多个多项式,每个节点里的数据有两个,系数和指数;其次,如果要实现乱幂输入,那么还需要一个排序函数;然后就是多项式相加求和的部分,当指数相等时其系数相加,如果不相等那么就比较大小,依次存入新的链表;最后是输出函数,这个部分也分了很多类型,比如:两式相加为常数(2,4,6)、0、系数为1不显示系数(x,x^4)、指数为1不显示指数(x,2x)等等。

    先来定义结构体变量,和单链表的定义结构体一样,不同的是此时我们的数据变成了两个:系数和指数。所以我们这样定义:

    typedef struct node{//构造结构体变量 
    	
    	int coefficient;//定义一个结构体变量“系数” 
    	
    	int exponent;//定义一个结构体变量“指数”
    	
    	node *next;
    	 
    }node;
    

    然后创建单链表来存储第一个多项式的各项式:

    node *create(){//尾插法创建单链表 
    	
    	node *head,*p,*q;
    	
    	int n;//定义一个整型数据n,用来表示输入的多项式的个数 
    	
    	int i = 0;//定义一个整型数据i=0,用来表示的输入的第几个多项式的系数或指数 
    	
    	head = (node*)malloc(sizeof(node));//给head分配内存空间 
    	
    	head->next = NULL; //先让head为空表 
    	
    	q = head;//让q等于head的头节点 
    	
    	printf("你想要输入多少个多项式的数据:");
    	
        scanf("%d",&n);
    	
    	for(i = 0;i < n;i++){
    		
    		p = (node*)malloc(sizeof(node));//给p分配内存空间 
    		
    		printf("请输入第%d项的系数:",i+1);
    		
    		scanf("%d",&p->coefficient);//输入系数 
    		
    		printf("请输入第%d项的指数:",i+1);
    		
    		scanf("%d",&p->exponent);//输入指数 
    		
    		p->next = q->next;
    		
    		q->next = p;
    		
    		q = q->next; 
    		
    	}
    	
    	return head;
    	
    }
    
    

    输出函数,注意这个函数是将两个多项式相加的和已经求出来了进行输出,是把没必要的省略(比如结果为2x^0输出为2),大家看程序就懂了,我就不废话了。

    void print(node *head){//输出单链表
    	
    	node *p;
    	
    	p = (node*)malloc(sizeof(node));
    	
    	p = head->next;
    
    	while(p->next != NULL){//如果p的后继节点不为空时执行下列语句 
    		
    		if(p->coefficient != 0 && p->exponent == 0){//系数不为0指数为0的情况(常数)
    		
    			printf("%d+",p->coefficient);//所以只输入系数
    		
    		}
           
           else if(p->coefficient == 1 && p->exponent == 1){//系数为1指数为1的情况 
    			
    			printf("x+");
    			
    		}	
    		
    		else if(p->coefficient != 0 && p->exponent == 1){//系数不为0指数为1的情况(x,2x,5x……) 
    		
    			printf("%dx+",p->coefficient);//注意前面%d后的x
    		
    		}
    		
    		else if(p->coefficient == 1 && p->exponent != 0){//系数为1指数不为0的情况(x^2,x^5……) 
    			
    			printf("x^%d+",p->exponent);
    			
    		}
    		
    		else if(p->coefficient == 0){//两个多项式相加的和为0时的情况,不输出 
    			
    			printf(""); 
    			
    		}
    		
    		else if(p->coefficient != 1 && p->exponent != 0){//系数不为1指数不为0的情况(2x^3,3x^2……) 
    			
    			printf("%dx^%d+",p->coefficient,p->exponent);
    			
    		}
    		
    		p = p->next;//让p等于它的后继结点,继续循环
    	}
    
    	if(p->exponent == 0 && p->coefficient != 0){//判断最后一个多项式的类型 (ps:因为上述循环当中我们定义p->next!=NULL时执行,那么当p为最后一个结点时,p->next已经是空了,那么这个时候就会跳出循环,最后一个结点的数据就会不运行出来,所以我们需要另写,如果不想写这么多代码的话让它在循环内输出也很简单,大家可以动脑筋想一想),下列语句同上 
    		
    			printf("%d",p->coefficient);
    		
    		}	
    
            else if(p->coefficient == 1 && p->exponent == 1){//系数为1指数为1的情况 
    			
    			printf("x+");
    			
    		}
    		
    		else if(p->exponent == 1 && p->coefficient != 0){
    		
    			printf("%dx",p->coefficient);
    		
    		}
    		
    		else if(p->coefficient == 1 && p->exponent != 0){
    			
    			printf("x^%d",p->exponent);
    			
    		}
    		
    		else if(p->coefficient == 0){
    			
    			printf("0"); //这条语句和上面不一样,因为这是最后一个多项式的输出,如果最后一个多项式的计算结果为0,那么不这样写就会输出(……+)有一个加号,不美观
    			
    		}
    		
    		else if(p->coefficient != 1 && p->exponent != 0){
    			
    			printf("%dx^%d",p->coefficient,p->exponent);
    			
    		}
    
    }
    

    然后就是排序,注意这个排序是将还未执行求和函数的两个多项式进行升幂排序,然后进行相加。(不是已经求和之后进行升幂排序)

    void paixu(node *head){//将多项式按升幂排序 
    	
    	node *p,*q;
    	
    	int temp,temp1;
    	
    	for(p=head->next;p!=NULL;p=p->next){//运用了两个for循环
    		
    		for(q=p->next;q!=NULL;q=q->next){//q为p的后继结点
    			
    			if(p->exponent > q->exponent){//如果p的指数比q的指数大,也就是前一项的指数比后一个指数大,那么交换它们的指数和系数
    			
    				temp = p->exponent;
    			
    				p->exponent = q->exponent;
    			
    				q->exponent = temp;
    			
    				temp1 = p->coefficient;
    			
    				p->coefficient = q->coefficient;
    			
    				q->coefficient = temp1;
    			
    			}
    		} 
    	}
    } 
    

    最后是多项式相加

    node *add(node *&head1,node *head2){//一元多项式相加 (将一元多项式相加的结果存放在head1中) 
    	
    	node *a,*b,*p;
    	
    	a = head1->next;
    	
    	b = head2->next;
    	
    	p = head1;
    	
    	while(a != NULL && b != NULL){
    		
    		if(a->exponent == b->exponent){
    			
    			a->coefficient = a->coefficient+b->coefficient;
    			
    			p->next = a;
    
    			p = p->next;
    			
    			a = a->next;
    			
    			b = b->next;
    			
    		}
    		
    		else if(a->exponent < b->exponent){
    			
    			p->next = a;
    			
    			p = p->next;
    			
    			a = a->next;
    			
    		}
    		
    		else{
    			
    			p->next = b;
    			
    		    p = p->next;
    		    
    		    b = b->next;
    			
    		}
    		
    	}
    	
    	if(a != NULL){//比较结束之后a或b如果有一个还未空就执行下述语句
    			
    			p->next = a;
    			
    		}
    		
    		else{
    			
    			p->next = b;
    			
    	    }
    	
    	return head1;
    	
    }
    

    最后主函数

    int main(){
    	
    	node *head1,*head2,*h;
    	
    	head1 = create();//创建第一个多项式
    	
    	head2 = create();//创建第二个多项式
    
    	paixu(head1);//将第一个多项式按升幂排序
    	
    	paixu(head2);//同上
    	
    	h = add(head1,head2);//相加
    
    	print(h);//输出
    
        return 0;
    
    }
    

    然后一个多项式相加的代码就完成了,在写博客的过程中突然发现自己相加和输出函数有一些问题,就顺便改正了,不得不说这写博客真的好处多多啊,还有就是输出函数里的分类没有完整,因为有系数为负数的情况,我懒得写了,大家有兴趣的可以写一写,不难的,就是简单的判断语句。

    哦!还缺一个头文件

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

    这就完美了。

    最后奉上一个运行结果
    在这里插入图片描述
    这是vscode的运行结果

    上述程序依次写入Dev-C++和vscode以及vs2019中都可以执行,但如果是vs2019里其scanf要改为scanf_s,因为这是vs2019的编译规则,而且还可能出现警告(取消NULL指针对P的调用),这个问题的解决大家可以看我的第一个博客里有解决方法,这里就不多说了。

    最后,就希望路过的大佬可以给一点建议,还有就是希望和我一样的编程小白可以一起努力!

    展开全文
  • C语言一元多项式相加链表)含升幂排序

    千次阅读 多人点赞 2020-11-08 12:43:57
    本周要完成一项实验内容,C语言链表实现一元多项式的加法,权当是练习一下链表的知识吧。那么首先来思考一个问题。一元多项式包含哪几个数据项,这个问题很简单吧,多项式是有什么组成的呢。毫无疑问,上过初中的都...

    [关于C语言数据结构一元多项式的加法的链表实现]本人初学者,如有错误,感谢各位大佬的指正

    本周要完成一项实验内容,C语言链表实现一元多项式的加法,权当是练习一下链表的知识吧。那么首先来思考一个问题。一元多项式包含哪几个数据项,这个问题很简单吧,多项式是有什么组成的呢。毫无疑问,上过初中的都知道由系数和指数构成,那么显然再加上一个指针域的话就是三个数据项。这个时候结构体的作用就凸显出来,定义一个结构体,包含指数系数和指针域,一个结构体表示一个多项式,为一个节点,两个及以上的节点用结构体内部包含的指针链接起来就成为了链表。那么第一步,先来定义一个结构体吧。当然,不要忘了头文件。

    #include<stdio.h>
    #include<stdlib.h> 
    
    typedef struct node
    { 
    	
    	int coef;//系数 
    	
    	int expo;//指数 
    	
    	node *next;//指针 
    	 
    }node;//取别名,node此后就代表一个完整的结构体数据 
    
    

    好了,结构体创建完之后,要怎么办呢?当然创建链表来存储多项式。代码里面有非常详细的注释,此处不再赘述。

    node *create()  //创建单链表存储多项式 
    { 
    	
    	node *head,*p,*q;//定义三个node类型的指针 
    	
    	int m;//定义一个整型数据m,用来表示输入的多项式的个数 
    	
    	head = (node*)malloc(sizeof(node));//给头指针head分配内存空间 
    	
    	head->next = NULL; //head下一个赋值为空,成为空表 
    	
    	q = head;//让q等于head的头节点 
    	
    	printf("你想要输入多项式的项数为:");
    	
        scanf("%d",&m);
    	
    	for(int i = 0;i < m;i++)
    	{
    		
    		p = (node*)malloc(sizeof(node));//给p分配内存空间 
    		
    		printf("请输入第%d项的系数:",i+1);
    		
    		scanf("%d",&p->coef);//输入系数 
    		
    		printf("请输入第%d项的指数:",i+1);
    		
    		scanf("%d",&p->expo);//输入指数 
    		
    		p->next = q->next;
    		
    		q->next = p;
    		
    		q = q->next; 
    		
    	}
    	
    	return head;
    	
    }
    

    当你成功输入一个多项式的时候你能想到还有什么问题吗,当然不会这么简单,多项式的指数系数的值的不同,我们要做不同的处理,尽可能的考虑周全,使代码更具有一般性。博主在这里定义了一个compare函数用来比较不同的系数指数的大小关系,并返回特定值,用switch case语句进行处理,下面来看代码。

    int cmpare(node *p)//比较两项的指数的大小,并返回特定的值。 
    {
    if(p->coef != 0 && p->expo == 0){return 0;}//当输入多项式为常数
    else if(p->coef == 1 && p->expo == 1){return 1;}//系数为1指数为1
    else if(p->coef != 0 && p->expo == 1){return 2;}//系数不为0指数为1
    else if(p->coef == 1 && p->expo != 0){return 3;}//系数为1指数不为0 
    else if(p->coef == 0){return 4;}//两个多项式相加的和为0时
    else if(p->coef != 1 && p->expo != 0){return 5;}//系数不为1指数不为0 
    }
    void print(node *head) //遍历打印单链表
    {
    	
    	node *p;//定义一个node类型的指针 
    	
    	p = (node*)malloc(sizeof(node));//申请空间 
    	
    	p = head->next;
    
    	while(p->next)//循环语句,如果p的后继节点不为空时开始循环 
    	{
    		switch (cmpare(p))//调用函数进行返回值的选择 
    		{
    		case 0:
    		printf("%d+",p->coef);
            case 1:
    		printf("x+");
    		break;
    		case 2:	
    		printf("%dx+",p->coef);
    		break;
    		case 3: 
    		printf("x^%d+",p->expo);
    		break;
    		case 4:
    		printf("");
    		break; 
    		case 5:
    		printf("%dx^%d+",p->coef,p->expo);
    		break;
    		
    		} 
    		p = p->next;
    		/* P从第一个多项式开始输出,此后一直循环,反复进行第一个while判断
    		直至P为最后一个多项式, p->next为空时,条件判断不成立,跳出循环,
    		执行最后一个多项式的输出 
    		*/ 
    	}
    	
    	switch (cmpare(p))//以下是最后一个个多项式的输出,代码同上 
    		{
    		case 0:
    		printf("%d",p->coef);
            case 1:
    		printf("x");
    		break;
    		case 2:	
    		printf("%dx",p->coef);
    		break;
    		case 3: 
    		printf("x^%d",p->expo);
    		break;
    		case 4:
    		printf("0");
    		break; 
    		case 5:
    		printf("%dx^%d",p->coef,p->expo);
    		break;
    		
    		} 
    } 
    

    当然,不止这一种处理方法,循环嵌套完全能实现同样的功能,读者不妨动动脑子,想想看除了这两种还能怎么处理呢。
    此外,人都喜欢有顺序的东西,排列整齐的美感总是让人欲罢不能,多项式也是一样。你写一个多项式是喜欢乱写,还是从低到高写呢。博主本人喜欢从低到高,所以加了一个排序函数,实现升幂排序,当然这不是必须的,懒得弄的也可以不写,影响不大。

    void srot(node *head)//将多项式按指数从小到大排序 
    { 
    	
    	node *p,*q;
    	
    	int temp1,temp2;//中间变量, 
    	
    	for(p=head->next;p!=NULL;p=p->next)//嵌套循环,C语言书133页,忘了就再看看 
    	{
    		
    		for(q=p->next;q!=NULL;q=q->next)
    		{
    			
    			if(p->expo > q->expo)
    			{
    			
    				temp1 = p->expo;
    			
    				p->expo = q->expo;
    			
    				q->expo = temp1;
    			
    				temp2 = p->coef;
    			
    				p->coef = q->coef;
    			
    				q->coef = temp2;
    			
    			}
    		} 
    	}
    } 
    

    最后,多项式相加,这就有点类似与前面学过的两个顺序表的并集,head1和head2相加,把2加入1里面,最后返回head1。

    node *add(node *&head1,node *head2)
    /*一元多项式相加,特别注意head1前面的地址符, 
    两个多项式相加后,存入第一个多项式head1中,所以这个地址符很重要 
    */ 
    { 
    	
    	node *Pa,*Pb,*p;
    	
    	Pa = head1->next;//以下此类代码均需要画图理解指针的指向 
    	
    	Pb = head2->next;//建议对于指针不是很熟悉的,画图看着写 
    	
    	p = head1;
    	
    	while(Pa != NULL && Pb != NULL)
    	{
    		
    		if(Pa->expo == Pb->expo)
    		{
    			
    			Pa->coef = Pa->coef+Pb->coef;
    			
    			p->next = Pa; 
    
    			p = p->next;
    			
    			Pa = Pa->next;
    			
    			Pb = Pb->next;
    			
    		}
    		
    		else if(Pa->expo < Pb->expo)
    		{
    			
    			p->next = Pa;
    			
    			p = p->next;
    			
    			Pa = Pa->next;
    			
    		}
    		
    		else
    		{
    			
    			p->next = Pb;
    			
    		    p = p->next;
    		    
    		    Pb = Pb->next;
    			
    		}
    		
    	}
    	
    	if(Pa != NULL)
    	{
    			
    		p->next = Pa;
    			
    	}
    		
    	else
    	{
    		p->next = Pb;
    			
    	}
    	
    	return head1;
    	
    }
    

    为了让你的电脑更干净,加上一个消除函数吧

    int Destoey(node *head1,node *head2,node *head3)
    {
    	head1=NULL;
    	head2=NULL;
    	head3=NULL;
    	printf("多项式销毁成功!");
    	return 0; 
     }
    

    哈哈,很简单吧,到这里一个简单的多项式相加就已经完成了,对了,还有主函数。

    int main()
    {
    	
    	node *head1,*head2,*sum;
    	
    	head1 = create();
    	printf("你输入的第一个多项式为:");
    	srot(head1); 
    	print(head1);
    	printf("\n");
    	head2 = create();//创建多项式 
        printf("你输入的第二个多项式为:");
    	srot(head2); 
    	print(head2);
    	printf("\n");
    	sum = add(head1,head2);//调用函数进行求和 
    	print(sum);//输出结果
    	printf("\n"); 
    	Destoey(head1,head2,sum);
        return 0;
    
    }
    

    博主这里其实考虑的也不是很周全,系数指数为负该怎么办呢,感兴趣的读者自己去试试吧,今天早上从温暖的被窝起来写这篇帖子,博主好困。最后,附上一个运行结果,快去试试吧。
    在这里插入图片描述
    最后,看着运行结果不知道给位读者有没有发现一个问题,相加函数好像只是把两个多项式中相同的项加了起来,却并没有把一个多项式中的相同项加起来,虽然没什么影响,但毕竟不美观。读者老爷们思考思考该怎么解决这个问题呢。(博主是初学者,代码几乎都是按照初学者最容易理解的方式来呈现,不喜勿喷)

    以上代码依次加入Dev-C++和vs2019编译器中
    均可实现,但是在vs里需要将scanf改为scanf_s,这是vs编译器的规则所定,而且还会出现警告(取消NULL指针对p的调用,可以正常运行)解决方法是在出现警告的代码段旁加入一段代码。

    if(p==NULL){
    printf("内存分配失败!");
    return 0;
    }
    
    展开全文
  • 数据结构 C语言 动态链表 议员多项式的加减法 数据结构C语言 一元多项式的加减法算法实现 代码,用vs运行,已测试成功运行,
  • 在visual c++6.0环境中 链表 动态链表 多项式相加
  • 多项式 小记 # include # include typedef struct PolyNode * Polynomial ; struct PolyNode { int coef ; int expon ; Polynomial link ; } ; int Compare ( int P1 , int P2...

    数据结构(浙大版)
    多项式
    小记

    #include<stdio.h>
    #include<stdlib.h>
    typedef struct PolyNode *Polynomial;
    struct PolyNode
    {
    	int coef;
    	int expon;
    	Polynomial link;
    };
    int Compare(int P1, int P2) {
    	if (P1 > P2) return (1);
    	else if (P1 < P2) return (-1);
    	return (0);
    }
    void Attach(int c, int e, Polynomial *pRear) {
    	Polynomial P;
    	P = (Polynomial)malloc(sizeof(struct PolyNode));
    	P->coef = c;//对新结点赋值
    	P->expon = e;
    	P->link = NULL;
    	(*pRear)->link = P;
    	*pRear = P;//修改pRear值
    }
    Polynomial ReadPoly() {
    	Polynomial P, Rear, t;
    	int N,c,e;
    	scanf_s( "%d",&N);
    	P = (Polynomial)malloc(sizeof(struct  PolyNode));/*链表头空结点*/
    	P->link = NULL;
    	Rear = P;
    	while (N--)
    	{
    		scanf_s("%d %d", &c, &e);
    		Attach(c, e, &Rear);//将当前项插入多项式尾部
    	}
    	t = P;
    	P = P->link;
    	free(t);//删除临时创建的头节点
    	return P;
    }
    Polynomial Mult(Polynomial P1, Polynomial P2) {
    	Polynomial P, Rear, t1, t2, t;
    	int c, e;
    	if (!P1 || !P2) return NULL;
    	t1 = P1; t2 = P2;
    	P = (Polynomial)malloc(sizeof(struct  PolyNode));
    	P->link = NULL;
    	Rear = P;
    	while (t2)
    	{/*先用P1的第1项乘以P2,得到P*/
    		Attach(t1->coef*t2->coef, t1->expon + t2->expon, &Rear);
    		t2 = t2->link;
    	}
    	t1 = t1->link;
    	while (t1)
    	{
    		t2 = P2; Rear = P;
    		while (t2){
    			c = t1->coef*t2->coef;
    			e=t1->expon + t2->expon;
    			while (Rear->link&&Rear->link->expon > e)
    				Rear = Rear->link;
    			if (Rear->link&&Rear->link->expon==e)
    			{
    				if (Rear->link->coef + c)
    					Rear->link->coef += c;
    				else
    				{
    					t = Rear->link;
    					Rear->link = t->link;
    					free(t);
    				}
    			}
    			else
    			{
    				t = (Polynomial)malloc(sizeof(struct  PolyNode));
    				t->coef = c; t->expon = e;
    				t->link = Rear->link;
    				Rear->link = t; Rear = Rear->link;
    			}
    			t2 = t2->link;
    			}
    		t1 = t1->link;
    	}
    	t2 = P; P = P->link; free(t2);
    	return P;
    }
    void PrintPoly(Polynomial P) {/*输出多项式*/
    	int flag = 0;/*辅助调整输出格式用*/
    	if (!P) {printf("0 0\n"); return;}
    	while (P)
    	{
    		if (!flag)
    		{
    			flag = 1;
    		}
    		else
    		{
    			printf(" ");
    		}
    		printf("%-3dX^%-2d", P->coef, P->expon);
    		P = P->link;
    	}
    	printf("\n");
    }
    Polynomial Add(Polynomial P1, Polynomial P2) {
    	Polynomial front, rear, temp;
    	int sum;
    	rear = (Polynomial)malloc(sizeof(struct PolyNode));
    	front = rear;//有front记录结果多项式链表头结点
    	while (P1&&P2)//当两个多项式都有非零项需要处理时
    		switch (Compare(P1->expon, P2->expon))
    		{
    		case 1:
    			Attach(P1->coef, P1->expon, &rear);
    			P1 = P1->link;
    			break;
    		case -1:
    			Attach(P2->coef, P2->expon, &rear);
    			P2 = P2->link;
    			break;
    		case 0:
    			sum = P1->coef + P2->coef;
    			if (sum) Attach(sum, P1->expon, &rear);
    			P1 = P1->link;
    			P2 = P2->link;
    			break;
    		}
    	/*将未处理完的另一个多项式的
    	所有节点依次复制到结果多项式中去*/
    	for (; P1; P1 = P1->link) Attach(P1->coef, P1->expon, &rear);
    	for (; P2; P2 = P2->link) Attach(P2->coef, P2->expon, &rear);
    	rear->link = NULL;
    	temp = front;
    	front = front->link;//令front指向结果多项式第一个非零项
    	free(temp);//释放临时空表头结点
    	return front;
    }
    int main()
    {
    	Polynomial P1, P2, PP, PS;
    	P1 = ReadPoly();
    	P2 = ReadPoly();
    	PP = Mult(P1, P2);
    	PrintPoly(PP);
    	PS = Add(P1, P2);
    	PrintPoly(PS);
    }
    
    展开全文
  • typedef struct Node{//系数int coef;//指数int index;struct Node *next;}Node,*pNode;pNode CreateList(int len){pNode head,tail,new;head = (pNode)malloc(sizeof(Node));tail=head;tail->...
  • 给定两个一元多项式,实现两个一元多项式相加算法。提示:用一条单链表表示一个一元多项式,每个节点包含三个域:指数域、系数域和后继结点链。 可直接运行 #include <stdio.h> #include <stdlib.h> #...
  • 一元多项式的加减 c语言链表实现

    千次阅读 2020-06-20 17:14:15
    一元多项式的加减 c语言链表实现 1.题目 实现一元多项式的加减法运算,要求多项式采用链表存储结构。 2.测试用例 (1)a(x)=3x^1000 +7x^3-2x+1 b(x)=x^99 -x^3+2x+8 加法运算结果: c(x)=9.00 +6.00x^3 +1.00x^99 +...
  • printf("两个一元多项式相加的结果为:"); PrintPolyn(AddPolyn(P1, P2)); } void CreatePolyn(Link* p, int m)//*p是双重指针,用此意在改变指针 //创建多项式(带头结点),基础:动态链表的创建 { Link r, s;...
  • 当前位置:我的异常网» C语言»用链表实现多项式相加并输出显示用链表实现多项式相加并输出显示www.myexceptions.net网友分享于:2013-02-24浏览:197次【求助】用链表实现多项式相加并输出显示< > 关于用链表...
  • C语言实现一元多项式加法运算

    千次阅读 2020-10-08 23:12:11
    说到一元多项式相加,相信很多小伙伴都不会陌生,甚至 “合并同类项” 已经要脱口而出了(因为上节课本人就是这样的哈哈~) 回到正题,一元多项式的加法运算,大概是这样的: 知道怎么操作了之后就来看看如何储存...
  • 当前位置:我的异常网» C语言»用链表实现多项式相加并输出显示用链表实现多项式相加并输出显示(2)www.myexceptions.net网友分享于:2013-02-24浏览:197次[/code](1)其中有一段多项式相加函数没有按题目要求“可以...
  • c++链表实现多项式相加

    千次阅读 多人点赞 2020-09-25 23:10:12
    链表实现多项式相加 例如,已知多项式L1L_1L1​,L2L_2L2​如下: {L1=4x5+3x4+2x2+x+6L2=6x7+5x4+3x3+7x\begin{cases} L_1=4x^5+3x^4+2x^2+x+6 \\ L_2=6x^7+5x^4+3x^3+7x\\ \end{cases}{L1​=4x5+3x4+2x2+x+6L2​=6...
  • 链表实现多项式相加C语言

    千次阅读 2020-03-11 18:09:30
    参考有浙江大学的慕课: 浙江大学慕课 ...最近看了一片介绍用链表实现排序方式比较详细的博客,可以参考。 链表排序 #include<stdio.h> #include<stdlib.h> #define LENGTH sizeof(struc...
  • 一元多项式相加可实现代码(c语言) 《数据结构》(C语言版)书上是伪代码,经过不断修改调试,写下可实现的C语言源代码。 创建文件,分为两部分:头文件(Poly.h)和源文件(Poly.c) 一、实验目的 1、了解一元多项式...
  • 所以我们做的是———–一元多项式的表示及相加,其过程其实是对线性标的操作。实验结构和链接存储结构上的运算以及熟练运用掌握的线性表的操作,实现一元n次多项式的目的是掌握线性表的基本操作,插入、删除、查找...
  • //一元多项式相加 typedef int Status; typedef struct Node{ float coef; int expn; struct Node *next; }Node,*LinkList; void CreatList(LinkList &P,int m)//按指数升序将元素依次插到第一个结点前,...
  • C语言链表实现多项式乘法与加法

    千次阅读 2018-09-09 19:49:22
    乘法的实现采样插入法,首先用第一个多项式的第一项乘这个多项式,然后其他项依次插入到多项式,这种做法的好处是直观,容易实现 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; typedef ...
  • c语言单链表实现一元多项式相加

    万次阅读 多人点赞 2018-04-20 20:03:05
    把任意给定的两个一元多项式P(x),Q(x)输入计算机,计算它们的和并输出计算结果。 一元多项式可以用单链表表示,结点结构图示如下:coef exp next;伪代码如下:1. 工作指针p、q初始化;2. while(p存在且q存在)执行...
  • printf("输出两个多项式相加后的结果多项式A:"); return 0; } ![图片说明](https://img-ask.csdn.net/upload/202002/03/1580718627_581287.png) 哪位大神能帮忙看一下代码哪里出问题了吗?运行结果不...
  • 代码比较简单,没有完全按照严蔚敏版《数据结构(C语言版)》上39页到43页上的要求,只是实现了简单功能,且此代码输入多项式时只能按升幂的顺序输入(因为没有写多项式排序的函数) 个人感觉此代码短小精悍,且易...
  • 文章目录输入输出一元多项式的规则多项式中某项的结点结构生成多项式多项式进行相加输出多项式释放空间主函数 输入输出一元多项式的规则 输入时按顺序输入一元多项式的系数、指数;输入系数和指数都为0时,表述...
  • C语言实现一元多项式的运算(相加,相减,相乘) 1.创建多项式时,无论指数项按什么顺序输入,输出均能实现以升幂顺序输出,且输入时有相同指数项时能够实现合并。 2.能够代入确切的X计算出最终多项式的值。 ...
  • 数据结构作业中用c语言链表来实现一元多项式的加减乘运算!
  • #include> #include> #... /* 单项链表的声明 */ typedef struct PolynNode{ int coef; // 系数 int expn; // 指数 struct PolynNode *next; }PolynNode*PolynList; /* 正位序 (插在表尾 )输入 n 个元素的值建立带表头
  • #include <stdio.h> #include <stdlib.h> typedef struct PolyNode *Polynomial;//存储结构为:带头节点的单链表 ...//多项式系数 int expon;//多项式指数 Polynomial next;//指向下一个节点 }; t...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 991
精华内容 396
关键字:

c语言链表一元多项式相加

c语言 订阅