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

    2021-01-01 07:39:17
    编写一元多项式加法运算程序。要求用线性链表存储一元多项式。该程序有以下几个功能: 1. 多项式求和 输入:输入三个多项式,建立三个多项式链表Pa、Pb、Pc (提示:调用CreatePolyn(polynomial &P,int m)。 输出:...
  • 多项式加法运算

    2020-08-16 16:54:22
    2.4 多项式加法运算 struct PolyNode{ int coef;/*系数*/ int expon;/*指数*/ struct PolyNode *link;/*指向下一结点的指针*/ }; typedef struct PolyNode *Polynomial; Polynomial P1,P2; Polynomial PolyAdd...

    2.4 多项式加法运算

    struct PolyNode{
    	int coef;/*系数*/
    	int expon;/*指数*/
    	struct PolyNode *link;/*指向下一结点的指针*/
    };
    typedef struct PolyNode *Polynomial;
    Polynomial P1,P2;
    
    Polynomial PolyAdd(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,P2->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;
    }
    
    void Attach(int c,int e,Polynomial *pRear)
    {
    	Polynomial P;
    	
    	P = (Polynomial)malloc(sizeof(struct Polynomial));/*申请新结点*/
    	P->coef = c;/*对新结点赋值*/
    	P->expon = e;
    	P->link = NULL;
    	/*将P指向的新结点插入到当前多项式结尾的后面*/
    	(*pRear)->link = P;
    	*pRear = P; 	
    }
    
    展开全文
  • 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,使用其他编译器的小伙伴们记得修改相关函数嗷~

    展开全文
  • 多项式加法运算(链表实现)

    千次阅读 多人点赞 2021-04-24 13:09:04
    文章目录创建结点类型打印多项式尾插选择排序多项式相加代码总览 + 结果展示 创建结点类型 我们用链表存储一个多项式,那么该链表的每一个结点就代表多项式的某一项。所以我们的每一个结点必须包含三个信息:多项式...

    创建结点类型

    我们用链表存储一个多项式,那么该链表的每一个结点就代表多项式的某一项。所以我们的每一个结点必须包含三个信息:多项式的系数、多项式的指数以及指向下一个结点的指针。

    typedef int SLTDataType;//指数、系数类型
    
    typedef struct SListNode
    {
    	SLTDataType coef;//系数
    	SLTDataType expon;//指数
    	struct SListNode* next;//用于存放下一个结点的地址
    }SListNode;
    

    打印多项式

    传入一个指向多项式链表的指针,遍历该链表依次打印链表内容。(一次打印一个结点)

    //打印多项式
    void SListPrint(SListNode* head)
    {
    	SListNode* cur = head;
    	if (cur)
    	{
    		printf("%dx^%d", cur->coef, cur->expon);//打印第一项
    		cur = cur->next;
    	}
    	while (cur)
    	{
    		printf("%+dx^%d", cur->coef, cur->expon);
    		cur = cur->next;
    	}
    	printf("\n");
    }
    

    注:需将第一项拿出来单独打印,因为我们不希望第一项系数的正号被打印出来(若第一项系数为正)。

    尾插

    将一个项尾插到一个多项式的后面。我们需要申请一个新结点,将要求的系数和指数赋值给这个新结点,并将新结点的指针域置空,然后尾插到目标多项式的后面。

    //创建一个新结点,返回新结点地址
    SListNode* BuySLTNode(SLTDataType coef, SLTDataType expon)
    {
    	SListNode* node = (SListNode*)malloc(sizeof(SListNode));//向新结点申请空间
    	if (node == NULL)
    	{
    		printf("malloc fail\n");
    		exit(-1);
    	}
    	node->coef = coef;//系数赋值
    	node->expon = expon;//指数赋值
    	node->next = NULL;//将新结点的指针域置空
    	return node;//返回新结点地址
    }
    //尾插
    void SListPushBack(SListNode** pHead, SLTDataType coef, SLTDataType expon)
    {
    	SListNode* newnode = BuySLTNode(coef, expon);//申请一个新结点
    	if (*pHead == NULL)//判断是否为空表
    	{
    		*pHead = newnode;//头指针直接指向新结点
    	}
    	else
    	{
    		SListNode* tail = *pHead;//接收头指针
    		while (tail->next != NULL)//若某结点的指针域为NULL,说明它是最后一个结点
    		{
    			tail = tail->next;指针指向下一个结点
    		}
    		tail->next = newnode;//让最后一个结点的指针域指向新结点
    	}
    }
    

    注:若原多项式为空,即链表为空,直接让原链表指针指向新申请的结点即可。

    插入排序

    输入的多项式可能并不是有序的,这时我们需要将多项式按指数降序排列(或按指数升序排列),以简化后续多项式的相加操作,这里我们选用插入排序算法。

    //插入排序
    SListNode* InsertSortList(SListNode* head)
    {
    	if (head == NULL || head->next == NULL)//若链表为空或链表只有一个结点,则不需排序
    		return head;
    
    	SListNode* sortHead = head;//记录排序后链表的第一个结点
    	SListNode* cur = head->next;//从待排链表的第二个结点开始排序
    	sortHead->next = NULL;//默认链表的第一个结点有序,设置其指针域为空
    	while (cur)
    	{
    		SListNode* next = cur->next;//记录当前正在排序的结点的下一个结点
    		SListNode* c = sortHead;//记录当前遍历到的有序链表的结点位置
    		SListNode* p = NULL;//记录c的前一个结点位置
    		while (c)
    		{
    			if (cur->expon > c->expon)//待插入结点的指数大于当前遍历到的有序链表的结点的指数
    			{
    				break;
    			}
    			else//待插入结点与有序链表中的下一个结点比较
    			{
    				p = c;
    				c = c->next;
    			}
    		}
    		if (p == NULL)//将待插入结点插入到有序链表的第一个位置
    		{
    			cur->next = sortHead;
    			sortHead = cur;
    		}
    		else//将待插入结点插入到p和c之间
    		{
    			cur->next = c;
    			p->next = cur;
    		}
    		cur = next;//插入下一个待插入结点
    	}
    	return sortHead;//返回排列好的链表
    }
    

    多项式相加

    从两个待相加的多项式的表头开始,比较两个结点的指数大小,若相同,则将两个结点的系数相加得到新的系数,申请一个新结点(结点的系数为新得到的系数,指数与这两个结点的指数相同)尾插到新链表的后面即可。若两个结点的指数不相同,则申请一个新结点(新结点的系数和指数与两个结点中指数较大的结点相同)尾插到新链表后面即可。

    //比较两个结点的指数大小
    int Compare(SLTDataType e1, SLTDataType e2)
    {
    	if (e1 > e2)
    		return 1;
    	else if (e1 < e2)
    		return -1;
    	else
    		return 0;
    }
    //多项式相加
    SListNode* PolyAdd(SListNode* P1, SListNode* P2)
    {
    	SListNode* front = NULL;//相加后的链表的头指针
    	while (P1&&P2)
    	{
    		switch (Compare(P1->expon, P2->expon))//比较指数
    		{
    		case 1:
    			SListPushBack(&front, P1->coef, P1->expon);
    			P1 = P1->next;
    			break;
    		case -1:
    			SListPushBack(&front, P2->coef, P2->expon);
    			P2 = P2->next;
    			break;
    		case 0:
    			SLTDataType sum = P1->coef + P2->coef;
    			if (sum)
    				SListPushBack(&front, sum, P1->expon);
    			P1 = P1->next;
    			P2 = P2->next;
    			break;
    		}
    	}
    	while (P1)//将P1剩余项尾插到链表后面
    	{
    		SListPushBack(&front, P1->coef, P1->expon);
    		P1 = P1->next;
    	}
    	while (P2)//将P2剩余项尾插到链表后面
    	{
    		SListPushBack(&front, P2->coef, P2->expon);
    		P2 = P2->next;
    	}
    	return front;//返回新链表
    }
    

    可以对照下图进行逻辑分析:
    在这里插入图片描述
    注:当两个指数相同的结点的系数相加为0时,不必申请新结点插入新链表。

    代码总览 + 结果展示

    #include <stdio.h>
    #include <stdlib.h>
    #include <assert.h>
    
    typedef int SLTDataType;//指数、系数类型
    
    typedef struct SListNode
    {
    	SLTDataType coef;//系数
    	SLTDataType expon;//指数
    	struct SListNode* next;//用于存放下一个结点的地址
    }SListNode;
    
    //打印多项式
    void SListPrint(SListNode* head)
    {
    	SListNode* cur = head;
    	if (cur)
    	{
    		printf("%dx^%d", cur->coef, cur->expon);//打印第一项
    		cur = cur->next;
    	}
    	while (cur)
    	{
    		printf("%+dx^%d", cur->coef, cur->expon);
    		cur = cur->next;
    	}
    	printf("\n");
    }
    //创建一个新结点,返回新结点地址
    SListNode* BuySLTNode(SLTDataType coef, SLTDataType expon)
    {
    	SListNode* node = (SListNode*)malloc(sizeof(SListNode));//向新结点申请空间
    	if (node == NULL)
    	{
    		printf("malloc fail\n");
    		exit(-1);
    	}
    	node->coef = coef;//系数赋值
    	node->expon = expon;//指数赋值
    	node->next = NULL;//将新结点的指针域置空
    	return node;//返回新结点地址
    }
    //尾插
    void SListPushBack(SListNode** pHead, SLTDataType coef, SLTDataType expon)
    {
    	SListNode* newnode = BuySLTNode(coef, expon);//申请一个新结点
    	if (*pHead == NULL)//判断是否为空表
    	{
    		*pHead = newnode;//头指针直接指向新结点
    	}
    	else
    	{
    		SListNode* tail = *pHead;//接收头指针
    		while (tail->next != NULL)//若某结点的指针域为NULL,说明它是最后一个结点
    		{
    			tail = tail->next;指针指向下一个结点
    		}
    		tail->next = newnode;//让最后一个结点的指针域指向新结点
    	}
    }
    //选择排序
    SListNode* InsertSortList(SListNode* head)
    {
    	if (head == NULL || head->next == NULL)//若链表为空或链表只有一个结点,则不需排序
    		return head;
    
    	SListNode* sortHead = head;//记录排序后链表的第一个结点
    	SListNode* cur = head->next;//从待排链表的第二个结点开始排序
    	sortHead->next = NULL;//默认链表的第一个结点有序,设置其指针域为空
    	while (cur)
    	{
    		SListNode* next = cur->next;//记录当前正在排序的结点的下一个结点
    		SListNode* c = sortHead;//记录当前遍历到的有序链表的结点位置
    		SListNode* p = NULL;//记录c的前一个结点位置
    		while (c)
    		{
    			if (cur->expon > c->expon)//待插入结点的指数大于当前遍历到的有序链表的结点的指数
    			{
    				break;
    			}
    			else//待插入结点与有序链表中的下一个结点比较
    			{
    				p = c;
    				c = c->next;
    			}
    		}
    		if (p == NULL)//将待插入结点插入到有序链表的第一个位置
    		{
    			cur->next = sortHead;
    			sortHead = cur;
    		}
    		else//将待插入结点插入到p和c之间
    		{
    			cur->next = c;
    			p->next = cur;
    		}
    		cur = next;//插入下一个待插入结点
    	}
    	return sortHead;//返回排列好的链表
    }
    //比较两个结点的指数大小
    int Compare(SLTDataType e1, SLTDataType e2)
    {
    	if (e1 > e2)
    		return 1;
    	else if (e1 < e2)
    		return -1;
    	else
    		return 0;
    }
    //多项式相加
    SListNode* PolyAdd(SListNode* P1, SListNode* P2)
    {
    	SListNode* front = NULL;//相加后的链表的头指针
    	while (P1&&P2)
    	{
    		switch (Compare(P1->expon, P2->expon))//比较指数
    		{
    		case 1:
    			SListPushBack(&front, P1->coef, P1->expon);
    			P1 = P1->next;
    			break;
    		case -1:
    			SListPushBack(&front, P2->coef, P2->expon);
    			P2 = P2->next;
    			break;
    		case 0:
    			SLTDataType sum = P1->coef + P2->coef;
    			if (sum)
    				SListPushBack(&front, sum, P1->expon);
    			P1 = P1->next;
    			P2 = P2->next;
    			break;
    		}
    	}
    	while (P1)//将P1剩余项尾插到链表后面
    	{
    		SListPushBack(&front, P1->coef, P1->expon);
    		P1 = P1->next;
    	}
    	while (P2)//将P2剩余项尾插到链表后面
    	{
    		SListPushBack(&front, P2->coef, P2->expon);
    		P2 = P2->next;
    	}
    	return front;//返回新链表
    }
    
    int main()
    {
    	SListNode* P1 = NULL;//存放第一个表达式数据的链表
    	SListNode* P2 = NULL;//存放第二个表达式数据的链表
    	SLTDataType coef, expon;
    	//1.输入两个多项式
    	int count = 0;
    	printf("请输入第一个多项式的项数:>");
    	scanf("%d", &count);
    	printf("请输入第一个多项式:>");
    	int i = 0;
    	for (i = 0; i < count; i++)
    	{
    		scanf("%dx^%d", &coef, &expon);
    		SListPushBack(&P1, coef, expon);
    	}
    	printf("请输入第二个多项式的项数:>");
    	scanf("%d", &count);
    	printf("请输入第二个多项式:>");
    	for (i = 0; i < count; i++)
    	{
    		scanf("%dx^%d", &coef, &expon);
    		SListPushBack(&P2, coef, expon);
    	}
    	//2.分别将两个多项式按指数降序排列
    	SListNode* SortP1 = InsertSortList(P1);//按指数排序第一个多项式
    	SListNode* SortP2 = InsertSortList(P2);//按指数排序第二个多项式
    	printf("第一个多项式按指数降序排列为:>");
    	SListPrint(SortP1);
    	printf("第二个多项式按指数降序排列为:>");
    	SListPrint(SortP2);
    	//3.将两个多项式相加
    	SListNode* PolyAddHead = PolyAdd(SortP1, SortP2);//将两个多项式相加
    	printf("将两个多项式相加之后的结果为:>");
    	SListPrint(PolyAddHead);
    	return 0;
    }
    

    在这里插入图片描述
    注意:多项式输入时,每一项的输入格式需相同,均为:系数x^指数。

    展开全文
  • 二、多项式加法运算 2.1 算法思路 一、引言 主要思路:相同指数的项系数相加,其余部分进行拷贝。 二、多项式加法运算 采用不带头结点的单向链表,按照指数递减的顺序排列各项。 /* c语言实现 */ strct ...

    一、引言

    watermark

    主要思路:相同指数的项系数相加,其余部分进行拷贝。

    二、多项式加法运算

    采用不带头结点的单向链表,按照指数递减的顺序排列各项。

    watermark

    /* c语言实现 */
    
    strct PolyNode{
      int coef;  // 系数
      int expon;  // 指数
      struct PolyNode *link; // 指向下一个结点的指针
    };
    typedef struct PolyNode *Polynomial;
    Polynomial P1, P2;

    2.1 算法思路

    两个指针P1和P2分别指向这两个多项式第一个结点,不断循环:

    • P1->expon == P2->expon:系数相加,若结果不为0,则作为结果多项式对应项的系数。同时,P1和P2都分别指向下一项;
    • P1->expon > P2->expon:将P1的当前项存入结果多项式,并使P1指向下一项;

    • P1->expon < P2->expon:将P2的当前项存入结果多项式,并使P2指向下一项;

    当某一多项式处理完时,将另一个多项式的所有结点依次复制到结果多项式中去。

    0204-01.gif

    watermark

    /* c语言实现 */
    
    Polynomial PolyAdd(Polynomial P1, Polynomian 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)){
            case1: // P1中的数据项指数较大
                Attach(P1->coef, P1->expon, &rear);
                P1 = P1->link;
                break;
            case-1: // P2中的数据项指数较大
                Attach(P2->coef, P2->expon, &rear);
                P2 = P2->link;
                break;
                case 0: // 两项数据项指数相等
                sum = P1->coef + P2->coef;
                if (sum) Attach(sum, P1->expon, &rear); // 判断系数和是否为0
                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;
    }
    /* c语言实现 */
    
    void Attach(int c, int e, Polynomial *pRear)
    {
      /* 由于在本函数中需要改变当前结果表达式尾项指针的值,
      所以由函数传递进来的是结点指针的地址,*pRear指向尾项 */
      Polynomial P;
      
      P = (Polynomial)malloc(siezeof(struct PolyNode)); // 申请新结点
      P->coef = c; // 对新结点赋值
      P->expon = e;
      P-Llink = NULL;
      // 将P指向的新结点插入到当前结果表达式尾项的后面
      (*pRear)->link=P;
       *pRear = P; // 修改pRear值
    }
    def adds(l1, l2):  # l1,l2为链表,且不为空
        p1 = l1.head
        p2 = l2.head
        addRes = []
        while (p1 is not None) and (p2 is not None):  # 当p1和p2都部位空时,进行运算
            tmp1_exp = p1.get_data()[1]  # 获取p1指针处节点的指数
            tmp2_exp = p2.get_data()[1]  # 获取p2指针处节点的指数
    
            # 当指数相同时,系数相加,指数不变
            if tmp1_exp == tmp2_exp:
                addRes.append([p1.get_data()[0] + p2.get_data()[0], p1.get_data()[1]])
                p1 = p1.next  # 指针指向下一个节点
                p2 = p2.next
    
            # 当指数不相同时,选择较大的指数项存到结果中
            if tmp1_exp > tmp2_exp:
                addRes.append([p1.get_data()[0], p1.get_data()[1]])
                p1 = p1.next
            if tmp1_exp < tmp2_exp:
                addRes.append([p2.get_data()[0], p2.get_data()[1]])
                p2 = p2.next
    
        # 对于链表中剩余的节点添加到结果中
        while p1 is not None:
            addRes.append([p1.get_data()[0], p1.get_data()[1]])
            p1 = p1.next
        while p2 is not None:
            addRes.append([p2.get_data()[0], p2.get_data()[1]])
            p2 = p2.next
    
        # 此时的addRes结果
        # addRes [[5, 20], [-4, 4], [-5, 2], [9, 1], [-2, 0]]
        # 列表中每一项代表一各指数项,其中第一个元素代表系数,第二个元素代表指数。如[5,20]:5x^20
    
        # 以下是对addRes进行变形处理
        res1 = []
        for item in addRes:
            if item[0] != 0:  # 如果指数为0,即存在抵消情况,此时不应该输出
                res1.append(item[0])
                res1.append(item[1])
        if len(res1) == 0:  # 如果结果为0,需要输出:0  0
            return [0, 0]
    
        # 此时的输出结果变为
        # [5,20,-4,4,-5,2,9,1,-2,0]
        return res1

    转载于:https://www.cnblogs.com/nickchen121/p/11446745.html

    展开全文
  • 数据结构讲义之多项式加法运算
  • 一元多项式加法运算的实现 编程实现一元多项式的加法运算。(要求用链表实现) 输入 第一个一元多项式A; 第二个一元多项式B。 以(0,0)作为输入结束。 输出 多项式A和多项式B的和。 样例输入 5,3 7,8 9...
  • C语言实现一元多项式加法运算(链表)

    千次阅读 多人点赞 2019-10-05 21:26:25
    C语言实现一元多项式加法运算(链表) 完成如下操作: ①输入并建立一元稀疏多项式;(输入格式自定) 例如:4 - 12x3 + 123x5 - 80x10 ②输出所建立的一元多项式;(输出格式自定) 例如:12 - 3x + x3 + 230x12 ③...
  • 数据结构—一元多项式加法运算 采用不带头结点的单向链表,按照指数递减的顺序排列各项。 定义结点: struct PolyNode{ int coef;//系数 int expon;//指数 struct PolyNode *link;//指向下一个结点的指针 }; ...
  • 一元多项式加法运算的实现

    千次阅读 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^...
  • #include "iostream" #include "stdio.h" using namespace std; typedef int ElemType; typedef struct Node { ElemType i; // 指数 ElemType c; // 系数 Node *next;...amp...
  • 一元多项式加法运算,数据结构链表实现,代码加实验报告
  • C语言链表应用:一元多项式加法运算 首先科普一下线性表的相关知识。线性表,即由n个性质相同的数据元素组成的有序序列。线性表是最基础的线性结构,也是最基本的数据结构形式。因此学好线性表,也是学习其余数据...
  • 多项式加法 运算 算法思路 : 两个指针P1 和P2 分别指向这两个多项式第一个结点 , 不断 循环: P1-&amp;gt;zhi==P2-&amp;gt;zhi: 系数相加,若结果不为0,则作为结果多项式对应项 的系数。同时,P1和...
  • 数据结构—— 一元多项式加法运算

    万次阅读 多人点赞 2019-09-24 12:01:56
    设Pn(x)和Qn(x)分别为两个一元多项式,请求出两个一元多项式加法运算的结果,要求元素按照多项式的次数递减的次序排列。 1.问题分析 需求:实现两个一元多项式加法运算。 实现功能:①通过键盘接收输入的整数...
  • struct PNode *addPoly(PNode *L1,PNode *L2) //实现多项式加法运算 { int sum; struct PNode *p1,*p2,*p3,*r; p3=p1; p1=p1->next; p2=p2->next; while(p1&&p2) { if(p1->expn==p2->expn) {...
  • 一元多项式加法运算的实现 swustoj

    千次阅读 2018-04-20 19:36:25
    一元多项式加法运算的实现 10000(ms) 10000(kb) 2093 / 5095编程实现一元多项式的加法运算。(要求用链表实现)输入第一个一元多项式A; 第二个一元多项式B。 以(0,0)作为输入结束。输出多项式A和多项式B的...
  • Polynomial PolyAdd(Polynomial P1,Polynomial P2)//多项式加法链表实现 { Polynomial front,rear,temp; int sum; rear=(Polynomial)malloc(sizeof(struct PolyNode)); front=rear;//由front记录结果多项式链...
  • /*多项式加法运算使用链表实现*/#includeusing namespacestd;//使用不带头结点的单向链表,按照指数递减的顺序排列typedef structPolyNode{int coef; //系数int expon; //指数PolyNode *link; //指向下一个节点的...
  • #include&lt;stdio.h&gt; #include&lt;string.h&gt; int main() { int x,z; while(scanf("%d,%d",&amp;x,&amp;z)) { int a[1005]={0}; a[z]=x;...%d,...
  •  当某一多项式处理完时,将另一个多项式的所有结点依次复制到结果多项式中去。 Polynomial PolyAdd(Polynomial P1,Polynomial P2) { Polynomial front,rear,temp; int sum; rear = (Polynomial)malloc( ...
  • 请使用单链表实现两个多项式加法运算,其中多项式的项按指数从高到低排列。例如3x^2-x+2输入形式为32-1120。 测试样例: 样例1: 输入样例: 342312(第一个多项式) -23425160(第二个多项式) 输出样例...
  • C语言链表的入门题,里面提供了两种思路供参考,用链表来实现一元多项式的加减法,并按照一定规律输出。也是练习链表和排序算法的一道小实验,初学链表的小伙伴可以参考参考噢
  • 请使用顺序表实现两个多项式加法运算,其中多项式的项按指数从高到低排列。例如3x^2-x+2输入形式为32-1120。 测试样例: 样例1: 输入样例: 342312(第一个多项式) -23425160(第二个多项式) 输出样例: ...
  • 编程实现一元多项式加法运算。(要求用链表实现) 输入 第一行为一元多项式A, 以 0,0 作为输入结束; 第二行为一元多项式B, 以 0,0 作为输入结束。 输出 多项式A和多项式B的和。 样例输入 5,3 7,8 9,15 0,0 2,0 ...
  • 算法思路:两个指针P1和P2分别指向这两个多项式第一个结点,不断循环: P1->expon==P2->expon: 系数相加,若结果不为0,则作为结果多项式对应项的系数。同时,P1和P2都分别指向下一项; P1->expon>P2->expon: 将P1...
  • 加法 // 3.写乘法 // 4.输入结果 #include<stdio.h> struct Poly* ReadPoly(struct Poly *p,int &n ); void OutputPoly(struct Poly *p,int len); struct Poly* PolyAdd(struct ...
  • 完成多项式加法运算

    2019-03-08 10:40:05
    输出:两个多项式之和,由空格隔开的一组整数表示即可。 样例: 输入:3 3 5 -2 1 4 0 4 2 3 -1 2 1 1 3 0 输出:3 5 2 3 -1 2 -1 1 7 0 #include &lt;cstdio&gt; const int max_n = 111...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,014
精华内容 3,605
关键字:

多项式的加法运算