精华内容
下载资源
问答
  • 一元多项式加法运算

    2021-01-01 07:39:17
    编写一元多项式加法运算程序。要求用线性链表存储一元多项式。该程序有以下几个功能: 1. 多项式求和 输入:输入三个多项式,建立三个多项式链表Pa、Pb、Pc (提示:调用CreatePolyn(polynomial &P,int m)。 输出:...
  • 一元多项式加法减法乘法运算的实现 1.1设计内容及要求 1)设计内容 1使用顺序存储结构实现多项式加减乘运算 例如 , 求和结果 2使用链式存储结构实现多项式加减乘运算 求和结果 2设计要求 1用C语言编程实现上述实验...
  • 1. 一元多项式加法减法乘法运算的实现 1.1 设计内容及要求 1) 设计内容 1使用顺序存储结构实现多项式加减乘运算 例如 6 5 4 2 5 4 3 2 f ( x ) 8 x 5 x 10 x 32 x x 10 , g ( x ) 7 x 10 x 20 x 10 x x 求和结果 f ...
  • 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;
    	}
    }
    

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

    展开全文
  • 一元多项式加法

    2019-11-17 16:07:33
    问题 一元多项式加法 题目描述 让我们重温小学初中时那些一元多项式的加法吧,不同的是现在使用计算机来帮我们计算了。多年前不想写作业的梦想终于快要实现了!下面就给出书上的算法。 输入 输入数据包含多组测试...

    做题时被卡了好久,终于在一个崩溃的将while(1)换成while(getline)后ac了
    实在是错得憋屈T~T所以来总结一下了

    贴上题目

    问题 一元多项式加法

    题目描述
    让我们重温小学初中时那些一元多项式的加法吧,不同的是现在使用计算机来帮我们计算了。多年前不想写作业的梦想终于快要实现了!下面就给出书上的算法。

    输入
    输入数据包含多组测试数据,每组数据包含两行一元多项式。每个多项式包含若干对整数,每对整数的第一个是系数,第二个是指数。每个多项式不超过100项,整数间用空格隔开,并且指数是递减的。

    输出
    每组测试数据输出一行结果,每个整数后面空一格。(包括行尾)

    样例输入

    3 2 4 1 7 0
    2 4 1 1
    2 3
    1 4
    3 2 4 1 7 0
    2 4 -4 1
    

    样例输出

    2 4 3 2 5 1 7 0 
    1 4 2 3 
    2 4 3 2 7 0 
    

    解题思路:读取一行后分离数到数组里,另一行也这么做
    然后一个一个逐步判断指数大小,大的输出,等于就将底数加起来输出,最终结果会遵循题目要求

    代码:

    #include <stdio.h>
    #include <iostream>
    #include <cstring>
    #include <stack>
    #include <stdlib.h>
    #include <string>
    #include <sstream>
    using  namespace  std;
    struct zht{
        int coef;
        int exp;
    };
    int  main()  {
            int temp,i,j;
            zht s1[300+50];
            zht s2[300+50];
            string tem;
            stringstream t;
            while(getline(cin,tem)){        //这TM不能放1,不然会时间超限
                    memset(s1,0,sizeof(s1)); //结构体初始化
                    memset(s2,0,sizeof(s2));          
    
                    t.clear();
                    t.str(tem);
                    i=0,j=0;
                    while(1){     //读取出来到两个数组中
                        t>>s1[i].coef>>s1[i].exp;
                        if (t.fail()) {s1[i].coef=s1[i].exp=0;break;}
                        i++;
                    }
    
                    getline(cin,tem);
                    t.clear();
                    t.str(tem);
                    while(1){     //读取出来到两个数组中
                        t >> s2[j].coef>>s2[j].exp;
                        if (t.fail()) {s2[j].coef=s2[j].exp=0;break;}      //必须要有t>>结果里面没有值得情况,fail才会等于1
                        j++;
                    }
                    s1[i].coef=s1[i].exp=s2[j].coef=s2[j].exp=0;        //最后一个结果处理
                    temp=i+j;
                    i=j=0;
                    for(temp--; temp>=0; temp--){     //一个一个得遍历,由于数列是指数递减的,所以只有三种情况,左边比右边大或者相等或者小
                        if(s1[i].exp > s2[j].exp){
                            if(s1[i].coef != 0)
                                cout<<s1[i].coef<<" "<<s1[i].exp<<" ";
                            i++;
                        }
                        else if(s1[i].exp == s2[j].exp){
                            if(s1[i].coef + s2[j].coef != 0)
                                cout<<s1[i].coef + s2[j].coef<<" "<<s1[i].exp<<" ";
                            i++,j++;
                        }
                        else{
                            if(s2[j].coef != 0)
                                cout<<s2[j].coef<<" "<<s2[j].exp<<" ";
                            j++;
                        }
                    }
                cout<<endl;
            }
            return  0;
    }
    
    
    

    要用链表解决的话基本一致,改一下存的方式和输出就可以了

    希望以后自己以后回来看时能有所收获

    展开全文
  • 数据结构——一元多项式加法,使用数据结构中的线性表实现一元多项式加法
  • 一元多项式加法的链表实现 1.要求 使用链表实现一元多项式加法 并使用已有链表返回运算结果 2.算法分析 1.幂次有序算法 //一元多项式求和 void SumList(SList* &A,SList* B) { SList *m,*n,*t; if(GetLine(A...

    一元多项式加法的链表实现

    作者:Duder

    1.要求

    使用链表实现一元多项式加法
    并使用已有链表返回运算结果

    2.算法分析

    1.幂次有序算法

    //一元多项式求和
    void SumList(SList* &A,SList* B)
    {
    	SList *m,*n,*t;
    	if(GetLine(A) > GetLine(B) )	
    		{m=A;n=B;}
    	else 
    		{m=B;n=A;}
    	//OutPut(m);OutPut(n);
    	t = m->next;
    	
    	while(m->next != NULL && n->next != NULL)
    	{
    		if(m->next->exp == n->next->exp)
    		{
    			m->next->coef = m->next->coef + n->next->coef;
    			m = m->next;n = n->next;
    		}
    		else if(m->next->exp < n->next->exp )
    		{
    			m=m->next;
    		}
    		else if(m->next->exp > n->next->exp)
    		{
    			n=n->next;
    			Insert(m,n);
    		}
    	}
    			
    	while(n != NULL)
    	{
    		m->next = n->next;
    		m = m->next;
    		n = n->next;
    	}
    	
    	A->next= t;
    }
    

    输入函数A:
    f ( x ) = 1 + 2 x 1 + 3 x 3 + 4 x 5 f(x) = 1+ 2x^1 + 3x^3 + 4x^5 f(x)=1+2x1+3x3+4x5
    输入函数B:
    f ( x ) = 2 + x 2 f(x) = 2 + x^2 f(x)=2+x2

    运行结果
    在这里插入图片描述

    2.使用指针的有序相加算法

    //一元多项式求和
    void SumList(SList* &A,SList* B)
    {
    	SList *m,*n,*t,*p;
    	if(GetLine(A) > GetLine(B) )	
    		{m=A;n=B;}
    	else 
    		{m=B;n=A;}
    	t = m->next;
    	
    	while(m->next != NULL && n->next != NULL)
    	{
    		if(m->next->exp == n->next->exp)
    		{
    			m->next->coef = m->next->coef + n->next->coef;
    			m = m->next;n = n->next;
    		}
    		else if(m->next->exp < n->next->exp )
    		{
    			m=m->next;
    		}
    		else if(m->next->exp > n->next->exp)
    		{
    			p = n->next->next;
    			n->next->next = m->next;
    			m->next = n->next;
    			n->next = p; 
    		}
    	}	
    	while(n != NULL)
    	{
    		m->next = n->next;
    		m = m->next;
    		n = n->next;
    	}
    	
    	A->next= t;
    }
    

    3.乱序幂次算法

    //冒泡排序
    void SortList(SList *head) 
    {
        SList *p,*q,*t;
        for(p=head->next; p->next!=NULL; p=p->next)
    	{
            for(q=p->next; q!=NULL; q=q->next)
            {
    			if (p->exp > q->exp)
                {
                    int t = p->coef; 
    				p->coef = q->coef; 
    				q->coef = t;
    				
                    t = p->exp;
    				p->exp = q->exp;
    				q->exp = t;
                }
                else {}
    		}
    	}
    }
    

    输入函数A:
    f ( x ) = 1 x + 2 x 2 + 3 x 3 + 4 x 4 f(x) = 1x + 2x^2 +3x^3 + 4x^4 f(x)=1x+2x2+3x3+4x4

    输入函数B:
    f ( x ) = 5 x 5 + 4 x 7 + 5 x 2 f(x) = 5x^5 + 4x^7 + 5x^2 f(x)=5x5+4x7+5x2

    在这里插入图片描述

    3.完整代码

    func.h

    #include <iostream>
    #include <stdlib.h>
    
    using namespace std;
    //#define MaxSize 20
    typedef int ElemType;
    
    //定义链表结构 
    typedef struct SList{
    	ElemType coef;
    	int exp;
    	struct SList *next;
    }SList;
    
    //链表的初始化
    void InitList(SList* &head,int n);
    
    //输出链表 
    void OutPut(SList *head);
    
    //释放链表 
    void FreeList(SList *head);
    
    //返回第n个节点的指针 
    SList* GetPoint(SList* head);
    
    //一元多项式求和
    void SumList(SList* &A, SList* B);
    
    //返回表长度 
    int GetLine(SList* head);
    
    //插入某处某数据
    void Insert(SList* &m,SList* n);
    
    void SortList(SList *head) ;
    

    func.cpp

    #include "func.h"
    //#define MaxSize 20
    //链表的初始化
    void InitList(SList* &head,int n) 
    {
    	cout<<"please input the function:"<<endl;
    	SList *node,*end;
    	head = (SList*)malloc(sizeof(SList));
    	end = head;
    	for(int i=0;i<n;i++)
    	{
    		node = (SList*)malloc(sizeof(SList));
    		cin >> node->coef;
    		cin >> node->exp;
    		end->next = node;
    		end = node;
    	}
    	end->next = NULL; 
    	cout << "The input is over"<<endl;
    }
    
    
    void OutPut(SList *head)
    {
    	SList *p;
    	p = head->next;
    	while(p != NULL)
    	{
    		cout <<p->coef<<"x^"<<p->exp<<" ";
    		p = p->next; 
    	}
    	cout<<endl;
    }
    
    void FreeList(SList *head)
    {
    	SList *p,*t=NULL;
    	p = head;
    	if(p != NULL && p->next != NULL)
    	{
    		t = p->next;
    		p->next = t->next;
    		free(t);
    		t=NULL;
    	}	
    	else
    		cout << "该链表不存在"; 
    	cout << endl;
    }
    
    
    int GetLine(SList *head)
    {
    	SList *p = head;
    	SList *q;
    	int i=0;
    	while(p->next != NULL)
    	{
    		p=p->next;
    		i++;
    	}
    	if(i == 0)	cout << "该链表不存在"<<endl; 
    	return i;
    }
    
    
    //一元多项式求和
    void SumList(SList* &A,SList* B)
    {
    	SList *m,*n,*t;
    	if(GetLine(A) > GetLine(B) )	
    		{m=A;n=B;}
    	else 
    		{m=B;n=A;}
    	//OutPut(m);OutPut(n);
    	t = m->next;
    	
    	while(m->next != NULL && n->next != NULL)
    	{
    		if(m->next->exp == n->next->exp)
    		{
    			m->next->coef = n->next->coef + n->next->coef;
    			m = m->next;n = n->next;
    		}
    		else if(m->next->exp < n->next->exp )
    		{
    			m=m->next;
    		}
    		else if(m->next->exp > n->next->exp)
    		{
    			n=n->next;
    			Insert(m,n);
    		}
    	}
    			
    	while(n != NULL)
    	{
    		m->next = n->next;
    		m = m->next;
    		n = n->next;
    	}
    	
    	A->next= t;
    }
    
    //将n指针指向的数据插入到m指针后 
    void Insert(SList* &m,SList* n)
    {
    	SList *note;
    	note = (SList*)malloc(sizeof(SList));
    	note->coef = n->coef;
    	note->exp = n->exp;
    	note->next = m->next;
    	m->next = note;
    }
    
    
    //冒泡排序 节点值交换
    void SortList(SList *head) 
    {
        SList *p,*q,*t;
        for(p=head->next; p->next!=NULL; p=p->next)
    	{
            for(q=p->next; q!=NULL; q=q->next)
            {
    			if (p->exp > q->exp)
                {
                    int t = p->coef; 
    				p->coef = q->coef; 
    				q->coef = t;
    				
                    t = p->exp;
    				p->exp = q->exp;
    				q->exp = t;
                }
                else {}
    		}
    	}
    }
    

    main.cpp

    #include <iostream>
    #include "func.h"
    int main() 
    {
    	
    	SList *A,*B;
    	//FreeList(A);FreeList(B); 
    	InitList(A,4);InitList(B,3);
    	//cout<<GetLine(A);
    	//OutPut(A);
    	SortList(A);SortList(B);
    	OutPut(A);OutPut(B);
    	SumList(A, B);
    	cout <<"求和结果:" ; 
    	OutPut(A);
    	//OutPut(B);
    	FreeList(A);FreeList(B); 
    	return 0;
    }
    
    展开全文
  • C语言实现一元多项式加法运算

    千次阅读 2020-10-08 23:12:11
    回到正题,一元多项式加法运算,大概是这样的: 知道怎么操作了之后就来看看如何储存一元多项式叭: 很明显为了方便操作,而且每一项都含有 系数(coefficient)、指数 (index),为了避免S形一元多项式带来的...

    说到一元多项式相加,相信很多小伙伴都不会陌生,甚至 “合并同类项” 已经要脱口而出了(因为上节课本人就是这样的哈哈~)
    回到正题,一元多项式的加法运算,大概是这样的:

    在这里插入图片描述
    知道怎么操作了之后就来看看如何储存一元多项式叭:
    很明显为了方便操作,而且每一项都含有 系数(coefficient)、指数 (index),为了避免S形一元多项式带来的空间浪费,我们采用链式结构储存一元多项式,本题中采用普通的单链表进行储存(不需要方便访问头尾结点时可以不用循环链表)

    话不多说,先整两个一元多项式看看↓
    老规矩,数据类型和结构体定义先给出来
    PNode、LinkList分别表示结点和链表,Datatype即int,coe为系数,ind为指数

    //重定义类型和声明函数
    typedef struct Node* PNode;
    typedef struct Node* LinkList;
    typedef int Datatype;
    struct Node
    {
    	Datatype      coe;
    	Datatype      ind;
    	struct Node* next;
    };
    PNode Add_POLYA(LinkList head1, LinkList head2);
    
    

    构建一元多项式:
    ps:当接收到的系数和指数同时为0时停止输入,即一个多项式的结束

    LinkList setnulllist_link()
    {
    	LinkList head = (LinkList)malloc(sizeof(struct Node));
    	if (head != NULL) head->next = NULL;
    	else printf("alloc failure");
    	return head;
    }
    
    void createlist_tail(struct Node* head)
    {
    	PNode p = NULL;
    	PNode q = head;
    	Datatype coe;
    	Datatype ind;
    	printf("please input coefficient and index:\n");
    	scanf_s("%d,%d", &coe, &ind);
    	while ((coe != 0) || (ind != 0))
    	{
    		p = (struct Node*)malloc(sizeof(struct Node));
    		p->coe = coe;
    		p->ind = ind;
    		p->next = NULL;
    		q->next = p;
    		q = p;
    		scanf_s("%d,%d", &coe, &ind);
    	}
    	return;
    }
    

    再来看多项式相加函数:
    ps:两个多项式的和最后储存在第一个多项式head1中,不喜欢的小伙伴也可以自行调整嗷~

    PNode Add_POLYA(LinkList head1, LinkList head2)
    {
    	PNode pre = NULL, p = NULL, qre = NULL, q = NULL;
    	pre = head1;
    	p = head1->next;
    	qre = head2;
    	q = head2->next;
    	if (qre == NULL)
    	{
    		return head1;
    	}
    	while (p != NULL)
    	{
    		if (q == NULL)
    		{
    			return head1;
    		}
    		//两个项指数相等时
    		if (p->ind == q->ind)
    		{
    			p->coe = q->coe + p->coe;
    			//两项和为0时
    			if (p->coe == 0)
    			{
    				pre->next = p->next;
    				free(p);
    				p = pre->next;
    				qre->next = q->next;
    				free(q);
    				q = qre->next;
    			}
    			else {
    				pre = p;
    				p = p->next;
    				qre->next = q->next;
    				free(q);
    				q = qre->next;
    			}
    		}
    		//多项式1的项的指数大于多项式2的项时
    		else if (p->ind > q->ind)
    		{
    			qre->next = q->next;
    			q->next = p;
    			pre->next = q;
    			pre = q;
    			q = qre->next;
    		}
    		//多项式2的项指数大小在多项式1的项与下一项中间时
    		else if (q->ind > p->ind && q->ind < (p->next)->ind)
    		{
    			qre->next = q->next;
    			pre = p;
    			p = p->next;
    			q->next = p;
    			pre->next = q;
    			pre = q;
    			q = qre->next;
    		}
    		else if (q->ind > p->ind && q->ind >= (p->next)->ind)
    		{
    			pre = p;
    			p = p->next;
    		}
    	}
    
    	return head1;
    }
    

    需要注意的就是两个项的指数大小问题(注意看上方的注释嗷~)
    最后来看整体代码与运行结果:

    //链式存储实现多项式加法
    #include<stdio.h>
    #include<stdlib.h> 
    
    //重定义类型和声明函数
    typedef struct Node* PNode;
    typedef struct Node* LinkList;
    typedef int Datatype;
    struct Node
    {
    	Datatype      coe;
    	Datatype      ind;
    	struct Node* next;
    };
    PNode Add_POLYA(LinkList head1, LinkList head2);
    
    LinkList setnulllist_link()
    {
    	LinkList head = (LinkList)malloc(sizeof(struct Node));
    	if (head != NULL) head->next = NULL;
    	else printf("alloc failure");
    	return head;
    }
    
    void createlist_tail(struct Node* head)
    {
    	PNode p = NULL;
    	PNode q = head;
    	Datatype coe;
    	Datatype ind;
    	printf("please input coefficient and index:\n");
    	scanf_s("%d,%d", &coe, &ind);
    	while ((coe != 0) || (ind != 0))
    	{
    		p = (struct Node*)malloc(sizeof(struct Node));
    		p->coe = coe;
    		p->ind = ind;
    		p->next = NULL;
    		q->next = p;
    		q = p;
    		scanf_s("%d,%d", &coe, &ind);
    	}
    	return;
    }
    
    void print(LinkList head)
    {
    	PNode  p = head->next;
    	while (p != NULL)
    	{
    		if (p->next != NULL) {
    			printf("%d,%d ", p->coe, p->ind);
    		}
    		else {
    			printf("%d,%d ", p->coe, p->ind);
    		}
    		p = p->next;
    	}
    	return;
    }
    
    void destorylist_link(LinkList head)
    {
    	PNode  pre = head;
    	PNode p = pre->next;
    	while (p)
    	{
    		free(pre);
    		pre = p;
    		p = pre->next;
    	}
    	free(pre);
    	return;
    }
    
    int main()
    {
    	LinkList head1 = NULL, head2 = NULL;
    	head1 = setnulllist_link();
    	head2 = setnulllist_link();
    	createlist_tail(head1);
    	createlist_tail(head2);
    	Add_POLYA(head1, head2);
    	print(head1);
    	destorylist_link(head1);
    	system("pause");
    	return 0;
    }
    
    PNode Add_POLYA(LinkList head1, LinkList head2)
    {
    	PNode pre = NULL, p = NULL, qre = NULL, q = NULL;
    	pre = head1;
    	p = head1->next;
    	qre = head2;
    	q = head2->next;
    	if (qre == NULL)
    	{
    		return head1;
    	}
    	while (p != NULL)
    	{
    		if (q == NULL)
    		{
    			return head1;
    		}
    		//两项和为0时
    		if (p->ind == q->ind)
    		{
    			p->coe = q->coe + p->coe;
    			if (p->coe == 0)
    			{
    				pre->next = p->next;
    				free(p);
    				p = pre->next;
    				qre->next = q->next;
    				free(q);
    				q = qre->next;
    			}
    			else {
    				pre = p;
    				p = p->next;
    				qre->next = q->next;
    				free(q);
    				q = qre->next;
    			}
    		}
    		//多项式1的项的指数大于多项式2的项时
    		else if (p->ind > q->ind)
    		{
    			qre->next = q->next;
    			q->next = p;
    			pre->next = q;
    			pre = q;
    			q = qre->next;
    		}
    		//多项式2的项指数大小在多项式1的项与下一项中间时
    		else if (q->ind > p->ind && q->ind < (p->next)->ind)
    		{
    			qre->next = q->next;
    			pre = p;
    			p = p->next;
    			q->next = p;
    			pre->next = q;
    			pre = q;
    			q = qre->next;
    		}
    		else if (q->ind > p->ind && q->ind >= (p->next)->ind)
    		{
    			pre = p;
    			p = p->next;
    		}
    	}
    
    	return head1;
    }
    

    运行结果:

    在这里插入图片描述
    当然可能有小伙伴觉得这样不好看,这哪里是一个真正的一元多项式啊!
    没办法,为了过平台上的测试,呜呜~

    大家如果想要美观的话可以自行修改代码中的 print 函数嗷,我就不改啦
    最后说一下,要是copy本篇代码来过实验的话,记得查看print 函数哈,不然有可能会出现格式错误的问题。

    编译器:visual studio 2019,使用其他编译器的小伙伴们记得修改相关函数嗷~

    展开全文
  • 算法:一元多项式加法

    千次阅读 2020-06-14 22:24:55
    让我们重温小学初中时那些一元多项式加法吧,不同的是现在使用计算机来帮我们计算了。多年前不想写作业的梦想终于快要实现了!下面就给出书上的算法。 输入 输入数据包含多组测试数据,每组数据包含两行一元...
  • 编程实现一元多项式加法运算。(要求用链表实现) 输入 第一行为一元多项式A, 以 0,0 作为输入结束; 第二行为一元多项式B, 以 0,0 作为输入结束。 输出 多项式A和多项式B的和。 样例输入 5,3 7,8 9,15 0,0 2,0 ...
  • 数据结构课程设计一元多项式加法减法乘法运算的实现 1.一元多项式加法减法乘法运算的实现 1.1设计内容及要求 1)设计内容 1使用顺序存储结构实现多项式加减乘运算 例如 , 求和结果 2使用链式存储结构实现多项式加减乘...
  • 算法与数据结构实验,一元多项式加法,升序排列,相加为0,也可以,没bug
  • 在网上把关于这题的做法浏览了个遍,看来看去与书上的伪代码总有出入 我这次写的是完全参考书上写的...2)关于一元多项式的格式打印我没写,大家可以参考这篇 https://blog.csdn.net/qq_38265137/article/detail.
  • 数据结构-一元多项式加法

    千次阅读 2018-12-03 19:12:32
    7-17 一元多项式加法 (20 分) 设计程序求两个一元多项式的和。 输入格式: 输入分2行,每行分别先给出多项式非零项的个数,再以指数递降方式输入一个多项式非零项系数和指数。数字间以空格分隔。 输出格式: ...
  • 开始 在用单链表实现的过程中,遇到过许多问题,尤其是关于指针这方面,更是出了很多问题,希望大家引以为戒。 不多说了,直接上代码。 代码 节点类 public class Node1 { private int coefficient;...
  • 一元多项式加法和乘法,单链表实现。c++
  • 一元多项式加法运算的实现

    千次阅读 2018-04-13 12:26:15
    编程实现一元多项式加法运算。(要求用链表实现)输入第一个一元多项式A; 第二个一元多项式B。 以(0,0)作为输入结束。输出多项式A和多项式B的和。样例输入5,3 7,8 9,15 0,0 2,0 6,3 -7,8 0,0样例输出2x^0+11x^...
  • java实现一元多项式加法

    千次阅读 2018-03-15 17:19:51
    思路:多项式结点类描述:(Node结点,Linklist类的描述在创建单链表的文章已经实现)public class PolynNode { public double coef; //系数 public int expn; //指数 public PolynNode(double coef,int expn){ /...
  • 数据结构——一元多项式加法、减法、乘法运算的实现,可以直接使用
  • 使用链表来实现单元多项式加法、减法、乘法。其中,加法是其它运算的基础,减法:poly1-poly2=poly1+(-poly2),乘法:poly1*poly2,可用poly1乘以poly2的每一项,相加其乘积结果。
  • 一元多项式加法运算的实现 编程实现一元多项式的加法运算。(要求用链表实现) 输入 第一个一元多项式A; 第二个一元多项式B。 以(0,0)作为输入结束。 输出 多项式A和多项式B的和。 样例输入 5,3 7,8 9...
  • 设计一个一元稀疏多项式简单计算器。其基本功能包括: (1) 输入并建立多项式; (2) 输出多项式,输出形式为整数序列:n,c1,e1,c2,e2,......,cn,en,其中 n 是 多项式的项数,ci,ei分别是第 i 项的系数和...
  • 能够实现一元多项式的输入和输出 能够进行一元多项式相加 能够进行一元多项式相减 能够计算一元多项式在x处的值 能够计算一元多项式的导数(选作) 能够进行一元多项式相乘 编写main ()函数测试算法的正确性
  • 一元多项式相加实验报告(C语言实现)
  • 数据结构—— 一元多项式加法运算

    万次阅读 多人点赞 2019-09-24 12:01:56
    设Pn(x)和Qn(x)分别为两个一元多项式,请求出两个一元多项式加法运算的结果,要求元素按照多项式的次数递减的次序排列。 1.问题分析 需求:实现两个一元多项式加法运算。 实现功能:①通过键盘接收输入的整数...
  • 完美的数据结构大作业之选。C语言+链表 实现。不用提前知道多项式项数,可以自动排序,可以合并同类项,可以进行加法、乘法运算。VS环境可运行,其他编程软件找到cpp复制粘贴即可

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,123
精华内容 1,249
关键字:

一元多项式的加法