精华内容
下载资源
问答
  • 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语言

    千次阅读 2020-03-11 18:09:30
    参考有浙江大学的慕课: 浙江大学慕课 ...最近看了一片介绍用链表实现排序方式比较详细的博客,可以参考。 链表排序 #include<stdio.h> #include<stdlib.h> #define LENGTH sizeof(struc...

    参考有浙江大学的慕课:
    浙江大学慕课
    基本思路(如图):
    在这里插入图片描述代码实现:
    其中排序方式使用的是冒泡排序(时间复杂度O(n^2))相对其他排序方式更容易理解,也可以使用其他排序方式。最近看了一片介绍用链表实现排序方式比较详细的博客,可以参考。
    链表排序

    #include<stdio.h>
    #include<stdlib.h>
    #define LENGTH sizeof(struct node)
    //定义一个节点
    int len;//全局变量n
    typedef struct node
    {
    	int Coffficient;
    	int Exponent;
    	struct node* next;
    }*Pnode,Node;
    //创建一个单链表(尾插法)
    Pnode Create_List()
    {
    	Node * p,* tail, *head;
    	int a,b;
    	
    	head = (Node*)malloc(LENGTH);//原型应为malloc(1*LENGTH),1省略
    	tail = head;
    	tail->next = NULL;
    	printf("请输入结点个数:");
    	scanf_s("%d", &len);
    	printf("请输入元素,系数= , 指数=:\n");
    	for (int i = 0; i < len; i++)
    	{
    		scanf_s("%d,%d", &a,&b);
    			p = (Node*)malloc(LENGTH);
    			p->Coffficient=a;
    			p->Exponent = b;
    			tail->next = p;
    			p->next = NULL;
    			tail = p;
    	}
    	return head;//f返回头结点
    }
    //按指数排序
    void Sort_Linklist1(Node* phead) {//冒泡排序
    	Node* p = phead->next;
    	Node* q;
    	int temp1,temp2, i=0;
    	for (; i < len-1; i++, p = p->next) {
    		for (q = p->next; q!= NULL; q = q->next) {
    
    			if (p->Exponent < q->Exponent) {
    				temp1 = p->Exponent;
    				p->Exponent = q->Exponent;
    				q->Exponent = temp1;
    				temp2 = p->Coffficient;
    				p->Coffficient = q->Coffficient;
    				q->Coffficient = temp2;
    			}
    		}
    	}	
    }
    //比较函数
    int compare(int Exponent1, int Exponent2) {
    	if (Exponent1 > Exponent2)
    		return 1;
    	if (Exponent1<Exponent2)
    		return -1;
    	if (Exponent1 = Exponent2)
    		return 0;
    }
    //新生成
    void Attach(int a, int b, Node** temp) {
    	Node *p;
    	p = (Node*)malloc(LENGTH);
    	p->Coffficient = a;
    	p->Exponent = b;
    	p->next = NULL;
    	(*temp)->next = p;
    	*temp = p;
    }
    Pnode Add_List(Node* p1, Node* p2) {
    	Node* front,*rear;
    	p1 = p1->next;//从头结点的下一节点开始遍历
    	p2 = p2->next;
    	int sum;
    	rear = (Node*)malloc(LENGTH);
    	front = rear;
    	while (p1 && p2) {
    		switch (compare(p1->Exponent, p2->Exponent)) {
    		case 1:
    			Attach(p1->Coffficient, p1->Exponent, &rear);
    			p1 = p1->next;
    			break;
    		case -1:
    			Attach(p2->Coffficient, p2->Exponent, &rear);
    			p2= p2->next;
    			break;
    		case 0:
    			sum = p1->Coffficient + p2->Coffficient;
    			Attach(sum, p2->Exponent, &rear);
    			p1 = p1->next;
    			p2 = p2->next;
    			break;
    		}
    	}
    	for (; p1; p1 = p1->next)//p2为空循环结束后继续遍历p1
    		Attach(p1->Coffficient, p1->Exponent, &rear);
    	for(;p2;p2=p2->next)//p1为空循环结束后继续遍历p2
    		Attach(p2->Coffficient, p2->Exponent, &rear);
    	rear->next = NULL;
    	return front;
    }
    
    //遍历链表
    void Print_List(Node* phead)
    {
    	Node* p = phead->next;//跳过头结点进行遍历
    	while (p != NULL)//尾结点为空时终止(尾结点的指针域为空)
    	{
    		printf("%dX^%d\t", p->Coffficient,p->Exponent);
    		p = p->next;
    	}printf("\n");
    }
    
    int main()
    {
    	Node* s1,*s2,*s3;
    	printf("请先创建链表\n");
    	printf("输入Polynomial1");
    	s1= Create_List();
    	printf("指数从大到小排序后:\n");
    	Sort_Linklist1(s1);
    	Print_List(s1);
    	printf("输入Polynomial2");
    	s2= Create_List();
    	Sort_Linklist1(s2);
    	printf("指数从大到小排序后:\n");
    	Print_List(s2);
    	s3=Add_List(s1, s2);
    	printf("多项式相加后:\n");
    	Print_List(s3);
    	return 0;
    }
    

    结果:
    在这里插入图片描述

    展开全文
  • 根据所学的数据结构中线性结构(线性表) 的逻辑特性和物理特性及相关算法, 应用于求解一个具体的实际问题----------两个多项式相加
  • 利用两个带头结点的单链表 La 和 Lb 分别存储两个一元多项式 A(x)和 B(x),对这两个一元 多项式求和,输出结果。 输入格式: 二行数据,每行分别先给出多项式非零项的个数,再以指数递降方式输入一个多项式非零项系 ...

     利用两个带头结点的单链表 La 和 Lb 分别存储两个一元多项式 A(x)和 B(x),对这两个一元 多项式求和,输出结果。 输入格式: 二行数据,每行分别先给出多项式非零项的个数,再以指数递降方式输入一个多项式非零项系 数和指数,数字间以空格分隔。 输出格式: 以指数递降方式输出和多项式非零项的系数和指数,数字间以空格分隔。 输入样例的两个多项式如下: A(x)=3x 4 -5x 2+6x-2 B(x)=5x20 -7x4+3x

     

    # include<iostream>
    using namespace std;
    typedef int ElemType;
    
    typedef struct LNode {
    	ElemType coefficient;
    	ElemType index;
    	struct LNode *next;
    } LNode, *LinkList;
    
    void CreatList(LinkList &L, int n) {
    	LinkList p, s;
    	int i;
    	L = (LinkList)malloc(sizeof(LNode));
    	p = L;
    	L->next = NULL;
    	for (i = 0; i < n; i++) {
    		s = (LinkList)malloc(sizeof(LNode));
    		scanf("%d", &s->coefficient);
    		scanf("%d", &s->index);
    		p->next = s;
    		p = p->next;
    	}
    	p->next = NULL;
    }
    
    void add(LinkList La, LinkList Lb, LinkList &Lc) {
    	LinkList a, b, s, p;
    	a = La->next;
    	b = Lb->next;
    	p = Lc;
    	while (a && b) {
    		if (a->index == b->index) {
    			s = (LinkList)malloc(sizeof(LNode));
    			s->coefficient = a->coefficient + b->coefficient;
    			s->index = a->index;
    			p->next = s;
    			a = a->next;
    			b = b->next;
    			p = p->next;
    		} else if (a->index > b->index) {
    			p->next = a;
    			a = a->next;
    			p = p->next;
    		} else {
    			p->next = b;
    			b = b->next;
    			p = p->next;
    		}
    	}
    	if (a) {
    		p->next = a;
    	} else {
    		p->next = b;
    	}
    }
    
    void ListPrint(LinkList L) {
    	LNode *p = L;
    	while (p->next != NULL) {
    		cout << p->next->coefficient << " " << p->next->index << " ";
    		p = p->next;
    	}
    }
    
    int main() {
    	LinkList La, Lb, Lc;
    	int m, n;
    	scanf("%d", &m);
    	CreatList(La, m);
    	scanf("%d", &n);
    	CreatList(Lb, n);
    	CreatList(Lc, 0);
    	add(La, Lb, Lc);
    	ListPrint(Lc);
    	return 0;
    }

    展开全文
  • 主要为大家详细介绍了C语言单链表实现多项式相加,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 基于C语言实现简单的一元多项式加法 本文参考自《大话数据结构》,有错漏的地方欢迎指点。 ​ 正在复习数据结构,因为还没有复习到树结构,所以这里只是用链表对一元多项式加法做简单的实现,待后面复习到树结构,...
  • C语言实现多项式相加链表

    千次阅读 2016-10-26 16:41:20
    //两个多项式进行相加操作 void add_poly(struct node *head1, int length1, struct node *head2, int length2) { struct node *p1; struct node *p2; if (length1 > length2) { p1 = head1->next; p2 = head...
  • 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->...
  • 在visual c++6.0环境中 链表 动态链表 多项式相加
  • (2) 多项式相加函数——链表的合并 (3) 多项式输出函数——链表的输出 Input 输入数据有多组,对于每组测试数据,第一行一个整数n,表示第一个多项式La的项数;接下来n行,每行表示多项式的一项,包含两个元素,表示...
  • 【数据结构】多项式乘法与加法(c语言链表实现)

    千次阅读 多人点赞 2019-07-29 17:04:49
    1.多项式表示 数据结构设计 //将struct与typedef分开定义 typedef struct PolyNode *Polynomial; //使用 typedef 给一个还未完全声明的类型 PolyNode 起了一个新别名Polynomial struct PolyNode{ int coef; //...
  • 多项式相加C语言版)

    千次阅读 2021-04-19 15:37:02
    多项式相加 【问题描述】 编写一个程序用单链表存储多项式,并实现两个一元多项式A与B相加的函数。A,B刚开始是无序的,A与B之和按降序排列。例如: 多项式A: 1.2X^0 2.5X^1 3.2X^3 -2.5X^5 多项式B: -1.2X^0 2.5X^1...
  • #include<stdio.h> #include<malloc.h> #include<string.h> #include<...void add_poly(JDpa,JDpb) /多项式相加函数 ,通过判断指数大小来推动程序进行/ { JD *p,*q,*u,*pre; i
  • C语言实现一元多项式加法运算(链表

    千次阅读 多人点赞 2019-10-05 21:26:25
    C语言实现一元多项式加法运算(链表) ...③ 实现两个多项式相加运算并输出;. ④ 实现两个多项式相减运算并输出; 实验要求: 程序运行后显示一个文本方式的用户界面 ·············...
  • 数据结构 链表 多项式相加 C语言 struct node { int coef; int expo; struct node *next; }; void input(struct node **head) void display(struct node *head) void add(struct node **head1,struct node *head2...
  • [问题描述] 设计一个算法,以实现一元稀疏多项式的加法运算。...(3)多项式a和b相加,建立多项式a+b。 实现代码: #include<iostream> using namespace std; typedef struct LNode { int ci; int .
  • void CreatPolyn(LinkList &P,int n){ //输入n项的系数和指数,建立表示一元多项式的有序链表 LinkList s,pre,q; P=new LNode; P->next=NULL; while(n--){ s=new LNode; scanf("%lf %d",&s->coef , &s->...
  • 通过C语言实现多项式相加,相乘等操作
  • 当前位置:我的异常网» C语言»用链表实现多项式相加并输出显示用链表实现多项式相加并输出显示(2)www.myexceptions.net网友分享于:2013-02-24浏览:197次[/code](1)其中有一段多项式相加函数没有按题目要求“可以...
  • 一元多项式的加减 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 +...
  • 链表实现多项式相加

    千次阅读 2018-01-29 20:15:43
    使用链表实现多项式相加,最终输出相加多项式。默认链表的指数为递增。输入时依次输入系数和指数,以0 0 作为结束标志。 比如: 多项式A:1+2*x-4*x^4 多项式B:2-2*x+5^x^4 输入: 0 1 2 1 -4 4 0 0 ...
  • 多项式相加C语言实现

    万次阅读 2017-10-31 23:06:27
    尝试用C语言来实现多项式的加减
  • POLYNOMIAL Create() { // 创建多项式 pItem head,p; double coe; int pwr,iterms,i; head = p = new item; cin >> iterms; // 读入多项式的项数 for(i = 0; i < iterms; ++i) { cin >> ...
  • 多项式 小记 # include # include typedef struct PolyNode * Polynomial ; struct PolyNode { int coef ; int expon ; Polynomial link ; } ; int Compare ( int P1 , int P2...
  • 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语言

    千次阅读 多人点赞 2018-07-08 09:26:26
    #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; typedef struct Node { int coef;//系数 int expn;//指数 struct Node *next;... //LNode为创建的多项式链表类型 struct elem { int ...
  • #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; struct node{ int exp; float coef; struct node *next;...ListNode *createpoly() //创建多项式链表 { ListNode *h=NULL, *p...
  • 一元多项式相加可实现代码(c语言) 《数据结构》(C语言版)书上是伪代码,经过不断修改调试,写下可实现的C语言源代码。 创建文件,分为两部分:头文件(Poly.h)和源文件(Poly.c) 一、实验目的 1、了解一元多项式...
  • #include#pragma warning(disable:4996)//兼容scanftypedef struct node {int coef;int expon;struct node* link;}Polynode,*Polynomial;Polynomial InsertPolyLinklist(Polynomial in,Polynomial Pread) {Pread->...

空空如也

空空如也

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

多项式相加c语言链表

c语言 订阅