精华内容
下载资源
问答
  • 一元多项式相加实验报告(C语言实现)
  • 南昌航空大学实验报告 课程名称 数据结构 实验名称 实验二 线性表的链式存储结构 班 级 080611 学生姓名 学号 08 指导教师评定 ... 用户可以根据自己的需求分别输入两个一元多项式 并且能够实现输入的一元多项式的 显示
  • 一元多项式相加c实现

    2013-04-18 20:26:47
    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语言版)严蔚敏版的内容,用C语言写的一元多项式的表示相加操作的实现,用vc6和其他的C语言运行软件都能运行
  • C语言一元多项式相加(链表)含升幂排序

    千次阅读 多人点赞 2020-11-08 12:43:57
    [关于C语言数据结构一元多项式的加法的链表实现]本人初学者,如有错误,感谢各位大佬的指正 本周要完成一项实验内容,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;
    }
    
    展开全文
  • 编写一元多项式加法运算程序。要求用线性链表存储一元多项式(参照课本)。该程序有以下几个功能: 1. 多项式求和 输入:输入三个多项式,建立三个多项式链表Pa、Pb、Pc (提示:调用CreatePolyn(polynomial &P,int ...
  • 一元多项式相加 成绩 10 开启时间 2021年04月25日 星期日 00:00 折扣 0.8 折扣时间 2021年05月20日 星期四 23:59 允许迟交 否 关闭时间 2021年05月30日 星期日 23:59 题目说明: 编写一元多项式加法运算程序。要求用...
  • 用线性表的存储形式实现两个一元多项式相加
  • 一元多项式运算C语言

    2010-05-23 19:02:28
    一元多项式求和实质上是合并同类项的过程,其运算规则为: (1)若两项的指数相等,则系数相加; (2)若两项的指数不等,则将两项加在结果中。
  • 数据结构 - 一元多项式相加减(C语言)

    千次阅读 多人点赞 2017-12-07 23:02:26
    通常情况下,一元多项式可写成: an(x) = a1x^e1 + a2x^e2 + a3x^e3 + ... + amx^em (数字,m为下标),其中:pi是指数为ei的项的非零系数,0 例如: An(x) = 5x^3 - 2x^12 + 13x^99。可用线性表:((5,3),(-2,12),...

    通常情况下,一元多项式可写成: an(x) = a1x^e1 + a2x^e2 + a3x^e3 + ... + amx^em (数字,m为下标),其中:pi是指数为ei的项的非零系数,0<= e1 < e2 <...< em <=n.可以用线性表表示为:((p1,e1),(p2,e2),...(pm,em)).

    例如:

    An(x) = 5x^3 - 2x^12 + 13x^99。可用线性表:((5,3),(-2,12),(13,99))表示。

    为了操作方便,采用单链表作存储结构,结点有三个域:系数,指数,指针。存储结构如下:

    typedef struct Polynomial
    {
    	float coef;		//系数.
    	int expn;		//指数:常见的次幂都是整数,所以这里不考虑小数.
    	struct Polynomial *next; 
    }Polynomial,*Polyn;
    算法实现的具体思路在这里就不敖述了,下面放代码,哪里看不懂的可以评论区评论,看到第一时间回复。完整代码如下:

    #include <stdio.h>
    #include <stdlib.h>
    
    typedef struct Polynomial
    {
    	float coef;		//系数.
    	int expn;		//指数:常见的次幂都是整数,所以这里不考虑小数.
    	struct Polynomial *next; 
    }Polynomial,*Polyn;
    
    Polyn Create_Polyn();	//尾插法建立多项式.
    
    void Print_Polyn(Polynomial *head);	//打印多项式.
    
    Polyn Add_Polyn(Polynomial *pa,Polynomial *pb);	//多项式相加. 
    
    Polyn Suberact_Polyn(Polynomial *pa,Polynomial *pb);	//多项式相减. 
     
    int main()
    {
    	Polynomial *pa,*pb,*pc,*pd;
    	
    	/*--------------------一元多项式的创建---------------------*/ 
    	printf("请输入多项式pa的各项系数和指数(输入0结束): \n");
    	pa=Create_Polyn();
    	printf("请输入多项式pb的各项系数和指数(输入0结束): \n");
    	pb=Create_Polyn();
    	
    	/*------------------一元多项式的格式输出-------------------*/
    	printf("\n多项式: pa = ");
    	Print_Polyn(pa);
    	printf("\n多项式: pb = ");
    	Print_Polyn(pb);
    	
    	/*--------------------一元多项式相加-----------------------*/
    	printf("\n多项式pa和pb的和为:pa+pb = ");
    	pc=Add_Polyn(pa,pb);
    	Print_Polyn(pc);
    	
    	/*--------------------一元多项式相减-----------------------*/
    	printf("\n多项式pa和pb的差为:pa-pb = ");
    	pd=Suberact_Polyn(pa,pb);
    	Print_Polyn(pd);
    	printf("\n");
    	
    	return 0;
    }
    
    Polyn Create_Polyn()	//尾插法建立多项式.
    {
    	Polynomial *head,*rear,*s;
    	int c,e;
    	head = (Polyn)malloc(sizeof(Polynomial));
    	rear = head;				/*rear始终指向单链表的尾部,便于尾插法建表。*/ 
    	scanf("%d,%d",&c,&e);	 	/*键入多项式的系数和指数项*/
    	while(c!=0){				/*若c=0,代表多项式输入结束*/ 
    		s = (Polyn)malloc(sizeof(Polynomial));
    		s->coef = c;
    		s->expn = e;
    		rear->next = s;		 /*尾插*/
    		rear = s;
    		scanf("%d,%d",&c,&e); 
    	} 
    	rear->next = NULL;	/*将表中最后一个结点的next置为NULL*/
    	
    	return head; 
    } 
    
    void Print_Polyn(Polynomial *head)	/*打印多项式.*/
    {
    	Polyn q=head->next;
    	int flag=1;
    	if(!q){
    		putchar('0');
    		printf("\n");
    		return;
    	}
    	while(q){
    		if(q->coef > 0 && flag!=1){		/*多项式中某一项系数大于0,输出+号*/ 
    			putchar('+');
    		}
    		if(q->coef!=1 && q->coef!=-1){		/*多项式系数不是正负1*/ 
    			printf("%g",q->coef);			/*%g表示以%f%e中较短的输出宽度输出单双精度实数*/ 
    			if(q->expn==1) putchar('X');	/*若指数为1,输出X*/ 
    			else if(q->expn) printf("X^%d",q->expn); /*指数不为1,输出x^%d格式*/ 
    		}
    		else{
    			if(q->coef==1){				/*系数为1*/ 
    				if(!q->expn) putchar('1');
    				else if(q->expn==1) putchar('X');
    				else printf("X^%d",q->expn);
    			}
    			if(q->coef==-1){			/*系数为-1*/ 
    				if(!q->expn) printf("-1");
    				else if(q->expn==1) printf("-X");
    				else printf("-X^%d",q->expn);
    			}
    		}
    		q=q->next;
    		flag++;
    	}
    	printf("\n");
    }
    
    Polyn Add_Polyn(Polynomial *pa,Polynomial *pb)	//多项式相加.
    {
    	Polyn qa=pa->next;
    	Polyn qb=pb->next;
    	Polyn headc,pc,qc;
    	pc = (Polyn)malloc(sizeof(Polynomial));		/*单链表pc用来存放pa,pb的和*/
    	pc->next = NULL;
    	headc = pc;
    	while(qa!=NULL && qb!=NULL)	/*当两个多项式均未扫描结束时*/
    	{
    		qc = (Polyn)malloc(sizeof(Polynomial));
    		if(qa->expn < qb->expn) /*pa的指数项小于pb的指数项*/
    		{
    			qc->coef = qa->coef;
    			qc->expn = qa->expn;
    			qa = qa->next;
    		}
    		else if(qa->expn == qb->expn) /*指数项相同时*/
    		{
    			qc->coef = qa->coef + qb->coef;
    			qc->expn = qa->expn;		/*当然也可以是qb->expn*/
    			qa=qa->next;
    			qb=qb->next; 
    		}
    		else{				/*pb的指数项小于pa的指数项*/ 
    			qc->coef=qb->coef;
    			qc->expn=qb->expn;
    			qb=qb->next;
    		}
    		if(qc->coef!=0){
    			qc->next = pc->next;
    			pc->next = qc;
    			pc = qc;
    		}
    		else free(qc);
    	}
    	while(qa!=NULL){ 	/*pa存在剩余项,将剩余项插入到pc当中*/ 
    		qc = (Polyn)malloc(sizeof(Polynomial));
    		qc->coef = qa->coef;
    		qc->expn = qa->expn;
    		qa = qa->next;
    		qc->next = pc->next;
    		pc->next = qc;
    		pc = qc;
    	}
    	while(qb!=NULL){	/*pb存在剩余项,将剩余项插入到pc当中*/ 
    		qc = (Polyn)malloc(sizeof(Polynomial));
    		qc->coef = qb->coef;
    		qc->expn = qb->expn;
    		qb = qb->next;
    		qc->next = pc->next;
    		pc->next = qc;
    		pc = qc;
    	}
    	return headc;
    }
    
    Polyn Suberact_Polyn(Polynomial *pa,Polynomial *pb)	//多项式相减.
    {
    	Polyn h=pb;
    	Polyn p=pb->next;
    	Polyn pd;
    	while(p){			/*pa-pb就等于pa+(-pb),所以将pb多项式的各项符号循环遍历变号*/ 
    		p->coef*=-1;
    		p=p->next;
    	}
    	
    	pd=Add_Polyn(pa,h);		/*利用已创函数Add_Polyn()执行pa+(-pb),即减法运算*/
    	 
    	for(p=h->next;p;p=p->next){	/*执行完pa+(-pb)后,循环遍历,将pb的符号全部更改为之前的状态*/ 
    		p->coef*=-1;
    	}
    	return pd;
    }
    随便输入一组数据,显示结果如下:



    谢谢浏览,如果哪里写的有问题,感谢指出。

    参考:数据结构与算法 - 王曙燕主编版。

    展开全文
  • 数据结构课程设计两个一元多项式相加C语言
  • #include> #include> #include> typedef int ElemType; /* 单项链表的声明 */ typedef struct PolynNode{ int coef; // 系数 int expn; // 指数 struct PolynNode *next; }PolynNode*PolynList;...
  • 基于c语言实现,为了使用&引用,引入了c++头文件 源代码 #include <iostream> #include <stdlib.h> typedef struct Polynode{ int coef,exp; struct Polynode *next; }Polynode,*Polylist; ...

    基于c语言实现,为了使用&引用,引入了c++头文件

    源代码

    #include <iostream>
    #include <stdlib.h>
    
    typedef struct Polynode{
    	int coef,exp;
    	struct Polynode *next;
    }Polynode,*Polylist; 
    
    Polylist Polycreate(int n);
    void AddPolyn(Polylist pa,Polylist pb,Polylist &pc);
    void PrintPolyn(Polylist L,int n);
    
    int main(int argc, char** argv) 
    {
    	int n,m; 
    	Polylist pa,pb,pc;
    	printf("请输入pa链表元素的个数:\n");
    	scanf("%d",&n);
    	printf("请输入pa链表的底数和指数:\n");
    	pa=Polycreate(n);
    	PrintPolyn(pa,n);
    	printf("请输入pb链表元素的个数:\n");
    	scanf("%d",&m);
    	printf("请输入pb链表的底数和指数:\n");
    	pb=Polycreate(m);
    	PrintPolyn(pb,m);
    	printf("两个多项式相加后的结果为:\n");
    	AddPolyn(pa,pb,pc);
    	PrintPolyn(pc,n+m); 
    	return 0;
    }
    
    void PrintPolyn(Polylist L,int n)
    {
    	Polylist p;
    	int i=0;
    	p=L->next;
    	while(p && i<n)
    	{
    		i++;
    		printf("(%d,%d)  ",p->coef,p->exp);
    		p=p->next;
    	}
    	printf("\n");
    }
    
    Polylist Polycreate(int n)
    {
    	Polylist head,rear,s;
    	int c=1,e,i=1;
    	head=(Polylist)malloc(sizeof(Polynode));
    	rear=head;
    	while(c!=0 && i<=n)
    	{
    		i++;
    		scanf("%d,%d",&c,&e);
    		s=(Polylist)malloc(sizeof(Polynode));
    		s->coef=c;
    		s->exp=e;
    		rear->next=s;
    		rear=s;
    	}
    	rear->next=NULL;
    	return head;
    }
    
    void AddPolyn(Polylist pa,Polylist pb,Polylist &pc)
    {
    	int sum=0;
    	Polylist r,Lc;
    	pc=Lc=pa;
    	pa=pa->next;
    	pb=pb->next;
    	
    	
    	while(pa!=NULL && pb!=NULL)
    	{
    		if(pa->exp<pb->exp)
    		{
    			Lc->next=pa;
    			Lc=pa;
    			pa=pa->next;
    		}
    		else if(pa->exp==pb->exp)
    		{
    			sum=pa->coef+pb->coef;
    			if(sum!=0)
    			{
    				pa->coef=sum;
    				Lc->next=pa;
    				Lc=pa;
    				pa=pa->next;
    				r=pb;
    				pb=pb->next;
    				free(r);
    			}
    			else
    			{
    				r=pa;
    				pa=pa->next;
    				free(r);
    				r=pb;
    				pb=pb->next;
    				free(r);
    			}
    		}
    		else
    		{
    			Lc->next=pb;
    			Lc=pb;
    			pb=pb->next;
    		}
    	}
    	Lc->next=pa?pa:pb;
    	
    }
    

    运行截图

    在这里插入图片描述

    展开全文
  • 用链表实现一元多项式的加法 进一步熟悉链表的相关操作
  • 一元多项式相加可实现代码(c语言) 《数据结构》(C语言版)书上是伪代码,经过不断修改调试,写下可实现的C语言源代码。 创建文件,分为两部分:头文件(Poly.h)和源文件(Poly.c) 一、实验目的 1、了解一元多项式...
  • 数据结构第二章实验一元多项式求和,c语言链式结构实现
  • 一元多项式顾名思义就是好多个式子相加减,显然想到的就是利用单链表来实现,我在此处只讨论一元多项式相加的情况,相减也是一样的做法。首先,两个一元多项式相加,可以把它转化为两个单链表的合并,这是首要,然后...
  • 数据结构 C语言 动态链表 议员多项式的加减法 数据结构C语言 一元多项式的加减法算法实现 代码,用vs运行,已测试成功运行,
  • 给定两个一元多项式,实现两个一元多项式相加算法。提示:用一条单链表表示一个一元多项式,每个节点包含三个域:指数域、系数域和后继结点链。 可直接运行 #include <stdio.h> #include <stdlib.h> #...
  • PAGE PAGE # / 6 #i nclude<stdio.h> #i nclude<stdlib.h> #i nclude<malloc.h> typedef int ElemType; /*单项链表的声明*/ typedef struct PolynNode{ int coef; // 系数 int expn; // 指数 struct PolynN ode *n ...
  • 代码比较简单,没有完全按照严蔚敏版《数据结构(C语言版)》上39页到43页上的要求,只是实现了简单功能,且此代码输入多项式时只能按升幂的顺序输入(因为没有写多项式排序的函数) 个人感觉此代码短小精悍,且易...
  • #include*单项链表的声明*/? typedef?struct?PolynNode{? ?int?coef?//?系数? ?int?expn?//?指数? ?struct?PolynNode*next? }PolynNode*PolynList?
  • 两个一元多项式相加。输入 2 个多项式,例如 A17(x)=7+3x+9x8 +5x17 和 B8(x)=8x+22x7- 9x8 ,得到 C17(x)=7+11x+22x7 +5x17。 做不出来所以希望有代码
  • 文章目录输入输出一元多项式的规则多项式中某项的结点结构生成多项式对多项式进行相加输出多项式释放空间主函数 输入输出一元多项式的规则 输入时按顺序输入一元多项式的系数、指数;输入系数和指数都为0时,表述...
  • 一元多项式相加(C语言实现)

    万次阅读 2016-01-18 15:01:26
    //对应系数相加 sum = p -> coef + q -> coef; if ( sum != 0 ) { //系数不为零,替换对应结点 p -> coef = sum ; pre -> next = p; pre = pre -> next; p = p -> next; //删除结点...
  • C语言实现一元多项式加法运算(链表)

    千次阅读 多人点赞 2019-10-05 21:26:25
    C语言实现一元多项式加法运算(链表) 完成如下操作: ①输入并建立一元稀疏多项式;(输入格式自定) 例如:4 - 12x3 + 123x5 - 80x10 ②输出所建立的一元多项式;(输出格式自定) 例如:12 - 3x + x3 + 230x12 ③...
  • 将两个一元多项式相加 问题描述:要求用链表表示一元多项式,并实现算法求两个多项式的和。 #include <iostream> using namespace std; struct polyNode { double coef; // 表示底数 int exp; // 表示...
  • C语言实现一元多项式的运算(相加,相减,相乘) 1.创建多项式时,无论指数项按什么顺序输入,输出均能实现以升幂顺序输出,且输入时有相同指数项时能够实现合并。 2.能够代入确切的X计算出最终多项式的值。 ...
  • C语言实现单链表方式的一元多项式的加法

空空如也

空空如也

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

一元多项式相加c语言

c语言 订阅