两个多项式相加（顺序表&&链表）

于 2023-10-11 00:49:31 发布
阅读量768 收藏 5
点赞数 8
分类专栏： 数据结构学习记录 文章标签： 链表 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73441691/article/details/133758963
版权

编写一个程序，分别采用顺序表和带头结点的单链表存储一元多项式，并实现两个多项式相加运算，要求：
（1）创建存储多项式的有序表（按无序输入）ha和hb；
（2）求ha和hb相加产生多项式hc。
（3）输出多项式ha、hb和hc；

顺序表完成：

思路及解法：

先定义一个结构体变量Polynomial表示一个项，存放指数和系数，再定义一个顺序表SqList，里面有一个Polynomial的指针和一个表示表长的数据。

输入多项式的函数（利用随机存取的特点，先输入全部项，再排序）：

//输入系数指数的函数 (无序输入，输入后要有序)
void CreatePloyn(SqList &L,int n)
{
	cout<<"输入"<<n<<"对系数和指数。\n";
	Polynomial a[MAXSIZE];
	L.length=n;
	for(int i=0;i<n;i++)
	{
		cin>>a[i].coef>>a[i].expn;
	}
	int i,j,k;
	//按照指数排序
	for(i=0;i<n-1;i++)
	{
		k=i;
		for(j=i+1;j<n;j++)
		    if(a[j].expn<a[k].expn)
		        k=j;
		Polynomial t=a[k];
		a[k]=a[i];
		a[i]=t;
	}
//	//test 
//	i=0;
//	while(i<L.length)
//	{
//		if(i!=0&&a[i].coef>0) cout<<"+";
//		cout<<a[i].coef<<"X^"<<a[i].expn;
//		i++;
//	}
//	cout<<endl;
//	//
	//直接赋值即可
	for(i=0;i<n;i++)
	{
		L.elem[i]=a[i];
	}
}

相加的函数：和线性表合并一样的思路，只不过要注意当指向相同系数互为相反数时，两个节点直接跳过。

void Add(SqList L1,SqList L2,SqList &L3)
{
	int i,j,k;
	i=j=k=0;
	while(i<L1.length&&j<L2.length)
	{
		if(L1.elem[i].expn<L2.elem[j].expn)
		{
			L3.elem[k].coef=L1.elem[i].coef;
			L3.elem[k].expn=L1.elem[i].expn;
			i++;
			k++;
		}
		else if(L1.elem[i].expn>L2.elem[j].expn)
		{
			L3.elem[k].coef=L2.elem[j].coef;
			L3.elem[k].expn=L2.elem[j].expn;
			j++;
			k++;
		}
		else
		{//指数相等时 
			if(L1.elem[i].coef+L2.elem[j].coef!=0)
			{//系数相加为零时
				L3.elem[k].coef=L1.elem[i].coef+L2.elem[j].coef;
			    L3.elem[k].expn=L1.elem[i].expn;
			    k++;
			}
			i++,j++;
		}
	}
	//剩余项直接赋值
	while(i<L1.length)
	{
		L3.elem[k]=L1.elem[i];
		i++;
		k++;
	}
	while(j<L2.length)
	{
		L3.elem[k]=L2.elem[j];
		j++;
		k++;
	}
	L3.length=k;
}

打印函数：第二项开始，系数大于零时要加'+'

//打印多项式 
void Show_Polyn(SqList L)
{
	int i=0;
	while(i<L.length)
	{
		if(i!=0&&L.elem[i].coef>0) cout<<"+";
		cout<<L.elem[i].coef<<"X^"<<L.elem[i].expn;
		i++;
	}
	cout<<endl;
}

完整代码：

#include<iostream>
#define MAXSIZE 250
using namespace std;
//定义多项式类型 
typedef struct{
	float coef;
	int expn;
}Polynomial;
typedef struct{
	Polynomial *elem;
	int length;
}SqList;
int InitList(SqList &L)
{
	L.elem=new Polynomial[MAXSIZE];
	if(!L.elem) return 0;
	L.length=0;
	return 1;
}
//输入系数指数的函数 (无序输入，输入后要有序)
void CreatePloyn(SqList &L,int n)
{
	cout<<"输入"<<n<<"对系数和指数。\n";
	Polynomial a[MAXSIZE];
	L.length=n;
	for(int i=0;i<n;i++)
	{
		cin>>a[i].coef>>a[i].expn;
	}
	int i,j,k;
	//按照指数排序
	for(i=0;i<n-1;i++)
	{
		k=i;
		for(j=i+1;j<n;j++)
		    if(a[j].expn<a[k].expn)
		        k=j;
		Polynomial t=a[k];
		a[k]=a[i];
		a[i]=t;
	}
//	//test 
//	i=0;
//	while(i<L.length)
//	{
//		if(i!=0&&a[i].coef>0) cout<<"+";
//		cout<<a[i].coef<<"X^"<<a[i].expn;
//		i++;
//	}
//	cout<<endl;
//	//
	//直接赋值即可
	for(i=0;i<n;i++)
	{
		L.elem[i]=a[i];
	}
}
void Add(SqList L1,SqList L2,SqList &L3)
{
	int i,j,k;
	i=j=k=0;
	while(i<L1.length&&j<L2.length)
	{
		if(L1.elem[i].expn<L2.elem[j].expn)
		{
			L3.elem[k].coef=L1.elem[i].coef;
			L3.elem[k].expn=L1.elem[i].expn;
			i++;
			k++;
		}
		else if(L1.elem[i].expn>L2.elem[j].expn)
		{
			L3.elem[k].coef=L2.elem[j].coef;
			L3.elem[k].expn=L2.elem[j].expn;
			j++;
			k++;
		}
		else
		{//系数相等时 
			if(L1.elem[i].coef+L2.elem[j].coef!=0)
			{
				L3.elem[k].coef=L1.elem[i].coef+L2.elem[j].coef;
			    L3.elem[k].expn=L1.elem[i].expn;
			    k++;
			}
			i++,j++;
		}
	}
	//剩余项直接赋值
	while(i<L1.length)
	{
		L3.elem[k]=L1.elem[i];
		i++;
		k++;
	}
	while(j<L2.length)
	{
		L3.elem[k]=L2.elem[j];
		j++;
		k++;
	}
	L3.length=k;
}
//打印多项式 
void Show_Polyn(SqList L)
{
	int i=0;
	while(i<L.length)
	{
		if(i!=0&&L.elem[i].coef>0) cout<<"+";
		cout<<L.elem[i].coef<<"X^"<<L.elem[i].expn;
		i++;
	}
	cout<<endl;
}
int main()
{
	SqList L1,L2,L3;
	int n;
	//初始化 
	InitList(L1);
	InitList(L2);
	InitList(L3);
	//输入 
	cout<<"第一个多项式的项数：";
	cin>>n;
	CreatePloyn(L1,n);
	cout<<"第二个多项式的项数：";
	cin>>n;
	CreatePloyn(L2,n);
	//相加打印
//	//test
//	cout<<"第一个多项式：\n";
//	Show_Polyn(L1);
//	cout<<"第二个多项式：\n";
//	Show_Polyn(L2);
	Add(L1,L2,L3); 
	cout<<"第一个多项式：\n";
	Show_Polyn(L1);
	cout<<"第二个多项式：\n";
	Show_Polyn(L2);
	cout<<"相加：\n";
	Show_Polyn(L3);
	
}

链表完成

节点定义：

//定义多项式节点 
typedef struct PNode{
	int expn;
	float coef;
	struct PNode *next;
}PNode,*Polynomial;

输入函数：

没有顺序表那种随机存取的特点，无序输入链表每一个节点时都要插入第一个小于（指系数小于）输入节点的节点，相等时系数加入即可。

void CreatePolyn(Polynomial &p,int n)
{
	Polynomial prev,q,s;
	p=new PNode;
	p->next=NULL;
	for(int i=0;i<n;i++)
	{
		s=new PNode;
		s->next=NULL;
		cout<<"输入多项式的第"<<i+1<<"项的系数和指数：";
		cin>>s->coef>>s->expn;
		prev=p;
		q=p->next;
		while(q&&q->expn<s->expn){
			prev=q;
			q=q->next;
		}
		if(q==NULL){//新节点是最大的
			s->next=q;
			prev->next=s;
		}else if(q->expn==s->expn){//有指数相等的节点
			float sum=q->coef+s->coef;
			if(sum==0){
				prev->next=q->next;
				delete q;
				delete s;
			}else{
				q->coef+=s->coef;
				delete s;
			}
		}else{
			s->next=q;
			prev->next=s;
		}
	}
}

相加函数：

链表有序后，相加函数就和两个有序链表的合并一样简单。只不过要注意指数相同系数相加为零的情况。

void AddPolyn(Polynomial &pa,Polynomial &pb,Polynomial &pc)
{
	CreatePolyn(pc,0);
	Polynomial p1,p2,p3,s,q;
	p1=pa->next;p2=pb->next;p3=pc;
	while(p1&&p2){
		if(p1->expn==p2->expn&&p1->coef+p2->coef==0){//指数相同并且相加为零
			s=p1;
			p1=p1->next;
			delete s;
			s=p2;
			p2=p2->next;
			delete s;
		}
		else if(p1->expn==p2->expn&&p1->coef+p2->coef!=0){//指数相等且系数和不为零 
			s=new PNode;
			s->coef=p1->coef+p2->coef;s->expn=p1->expn;s->next=NULL;  //复制数据域 
			p3->next=s;p3=s;                            //后插入p3中 
			p1=p1->next;
			p2=p2->next;
		}else if(p1->expn<p2->expn){
			s=new PNode;
			s->coef=p1->coef;s->expn=p1->expn;s->next=NULL;
			p3->next=s;p3=s;
			p1=p1->next;
		}else{
			s=new PNode;
			s->coef=p2->coef;s->expn=p2->expn;s->next=NULL;
			p3->next=s;p3=s;
			p2=p2->next;
		}
	}
	p3->next=p1?p1:p2;//赋值剩余项      
}

完整代码：

//稀疏多项式的运算 
#include<iostream>
using namespace std;
//定义多项式节点 
typedef struct PNode{
	int expn;
	float coef;
	struct PNode *next;
}PNode,*Polynomial;
void CreatePolyn(Polynomial &p,int n)
{
	Polynomial prev,q,s;
	p=new PNode;
	p->next=NULL;
	for(int i=0;i<n;i++)
	{
		s=new PNode;
		s->next=NULL;
		cout<<"输入多项式的第"<<i+1<<"项的系数和指数：";
		cin>>s->coef>>s->expn;
		prev=p;
		q=p->next;
		while(q&&q->expn<s->expn){
			prev=q;
			q=q->next;
		}
		if(q==NULL){
			s->next=q;
			prev->next=s;
		}else if(q->expn==s->expn){
			float sum=q->coef+s->coef;
			if(sum==0){
				prev->next=q->next;
				delete q;
				delete s;
			}else{
				q->coef+=s->coef;
				delete s;
			}
		}else{
			s->next=q;
			prev->next=s;
		}
	}
}
void AddPolyn(Polynomial &pa,Polynomial &pb,Polynomial &pc)
{
	CreatePolyn(pc,0);
	Polynomial p1,p2,p3,s,q;
	p1=pa->next;p2=pb->next;p3=pc;
	while(p1&&p2){
		if(p1->expn==p2->expn&&p1->coef+p2->coef==0){
			s=p1;
			p1=p1->next;
			delete s;
			s=p2;
			p2=p2->next;
			delete s;
		}
		else if(p1->expn==p2->expn&&p1->coef+p2->coef!=0){//指数相等且系数和为非零 
			s=new PNode;
			s->coef=p1->coef+p2->coef;s->expn=p1->expn;s->next=NULL;  //复制数据域 
			p3->next=s;p3=s;                            //后插入p3中 
			p1=p1->next;
			p2=p2->next;
		}else if(p1->expn<p2->expn){
			s=new PNode;
			s->coef=p1->coef;s->expn=p1->expn;s->next=NULL;
			p3->next=s;p3=s;
			p1=p1->next;
		}else{
			s=new PNode;
			s->coef=p2->coef;s->expn=p2->expn;s->next=NULL;
			p3->next=s;p3=s;
			p2=p2->next;
		}
	}
	p3->next=p1?p1:p2;//赋值剩余项      
}
void ShowPolyn(Polynomial &p)
{
	Polynomial pt=p->next;
	while(pt){
		if(pt!=p->next&&pt->coef>0) cout<<"+";
		cout<<pt->coef<<"X^"<<pt->expn;
		pt=pt->next;
	}
//	//test
//	pt=p;
//	while(pt){
//		cout<<"\n当前指针："<<pt<<"  next指针："<<pt->next;
//		pt=pt->next;
//	}
}
int main()
{
	Polynomial pa,pb,pc;
	int n,m;
	cout<<"第一个多项式的项数：";
	cin>>n;
	CreatePolyn(pa,n);
	ShowPolyn(pa);
	cout<<"\n第二个多项式的项数：";
	cin>>m;
	CreatePolyn(pb,m);
	ShowPolyn(pb);
	cout<<"\n相加结果为：";
	AddPolyn(pa,pb,pc);
	ShowPolyn(pc);
}

暴力递归战士
关注
  • 8
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
两个多项式相乘（链表）
qq_73218816的博客
10-25 478
链表
求两个多项式相加的和（数据结构cpp）
weixin_63732129的博客
11-21 2718
数据结构必修课之两个多项式之和。
链表实现多项式的加法(C语言)
qq_67574411的博客
08-02 1551
用链表存储一个多项式，那么该链表的每一个结点就代表多项式的某一项。所以我们的每一个结点必须包含三个信息：多项式的系数、多项式的指数以及指向下一个结点的指针。
多项式相加求和（C语言链表版）
qq_63438062的博客
04-14 1万+
多项式相加求和（C语言链表）
两个多项式的相加操作 C语言（链式存储结构）
qbyyds的博客
10-23 7017
内容: 完成两个多项式的相加操作：已知有两个多项式P(x)，Q(x)，设计算法实现P(x)+Q(x)运算。而且对加法运算不重新开辟存储空间。要求用链式存储结构。 例如：P(x)=5x^3+2x+1,Q(x)=3x^3+x^2-2x-3,其计算输出结果为：8x^3+1x^2-2. 相减操作，以上述为例，则其输出结果为：2x^3-x^2-4x-2 步骤： 1.问题分析和算法设计： 多项式加法：本题的需要求出两个多项式的和，因此需要先使用Init()来初始化一个...
多项式加法运算（链表实现）
2021dragon的博客
04-24 1万+
文章目录创建结点类型打印多项式尾插选择排序多项式相加代码总览 + 结果展示 创建结点类型 我们用链表存储一个多项式，那么该链表的每一个结点就代表多项式的某一项。所以我们的每一个结点必须包含三个信息：多项式的系数、多项式的指数以及指向下一个结点的指针。 typedef int SLTDataType;//指数、系数类型 typedef struct SListNode { SLTDataType coef;//系数 SLTDataType expon;//指数 struct SListNode* ne
多项式相加（C语言-链表版+数组版）.zip
最新发布
07-04
编写一个程序用单链表存储多项式，并实现两个一元多项式A与B相加的函数。A，B刚开始是无序的，A与B之和按降序排列。 【输入形式】 任意两个多项式A和B 【输出形式】 多项式中某一项的系数与指数，系数保留一位小数 ...
一元多项式的表示与相加，用链表解决
10-11
多项式相加涉及两个链表的合并。首先，我们遍历两个链表，如果一个链表为空，则返回另一个链表作为结果。否则，我们将两个链表的最高次项相加，然后继续遍历并处理下一项。如果两个多项式的当前项相同，我们只需将...
链表实现的多项式相加程序可实现多个多项式相加
05-19
在实现多项式相加时，我们需要考虑两个问题： 1. **相同指数的项相加**：如果当前多项式中有与新添加项指数相同的项，我们需要将这两个项的系数相加。 2. **不同指数的项排序**：链表中的项应该按照指数的非递减顺序...
cpp链表实现一元多项式表示，相加，相乘
06-18
两个多项式相加需要遍历两个链表，并将具有相同指数的项合并。如果一个多项式中没有某个指数的项，那么另一个多项式的相应项可以直接保留： ```cpp Polynomial Polynomial::add(const Polynomial& other) const { ...
多项式相加 java 链表
06-25
2. **合并链表**：由于两个链表的顺序都是从高到低，我们可以直接将它们连接起来，形成一个新的链表。这样，新的链表将包含两个多项式的全部项。 3. **相加相同指数的项**：遍历新链表，对于具有相同指数的项，我们...
【C++】数据结构实验——顺序表实现大数相加与相乘
qq_45888298的博客
09-19 3385
一、上机实验的问题和要求： 问题：大数相加与相乘 要求：采取线性表 二、程序设计的基本思想，原理和算法描述： （包括程序的结构，数据结构，输入/输出设计，符号名说明等） 首先注意到是对大数进行操作，那么就不能通过int、float等数据类型存储大数，因为可能会发生截断导致大数的数位丢失，解决办法就是使用string类型来存储大数，理论上支持最大std::string::max_size()个字节，远远超过int、float、double等类型支持的最大数字。其实个人感觉使用Pyhton来计算大数相加相乘会优
【c语言】链表实现两个多项式相加减（适合初学者）
weixin_74337975的博客
04-08 2113
在每一次迭代中，函数比较p1和p2中当前项的指数大小，如果p1当前项的指数大于p2当前项的指数，则将p1当前项添加到结果多项式中，反之则将p2当前项添加到结果多项式中。具体而言，可以从链表R的头部开始，依次比较相邻的两项，如果它们的次数相同，就将它们的系数相加，并删除其中一个项。函数返回一个新的指针，指向一个新的多项式，它是p1和p2相加的结果。这段代码实现了一个将新的项（结构体term类型）插入到单链表中的函数，其中参数head是一个指向链表头节点的指针，newterm是需要插入的新项。
数据结构与算法分析 C 语言描述第二版第三章——链表实现多项式相加
ALWAYS LEARNING
12-18 435
数据结构与算法分析 C 语言描述第二版第三章——链表实现多项式相加1. 思路2. 程序单链表双链表 要求： 多项式指数按照从大到小顺序排列，计算求和多项式后不会破坏原有输入的两个多项式 1. 思路 1）让用户输入多项式的系数和指数，将最终多项式按指数降序排序，由于输入时可能不是按照顺序，因此需要排序，这里有两种方法： a. 用单链表，先不排序，所有数据直接插入尾部，最后进行排序。 b. 用双链表，...
数据结构之多项式相加
热门推荐
weixin_43700556的博客
03-21 2万+
【问题描述】编写一个程序用单链表存储多项式，并实现两个一元多项式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 3.2X^3 2.5X^5 5.4X^10 多项式A与B之和：5.4X^10 6.4X^3 5X^1 【输入形式】任意两个多项式...
经典算法：用链表实现多项式加减
elliptical的专栏
10-15 952
用单链表实现多项式加减运算。
数据结构与算法基础-线性表习题-两个多项式相加运算（顺序表）
”好的程序员不应该花大量时间在程序调试上，bug从一开始就不该被引入“
03-01 2001
题目 编写代码，实现两个一元多项式之间的相加，相减，相乘运算 TIP：没有除法，但是在我的代码基础上很好改，加一个判断分母为0报错即可 思路 将多项式看成线性表，每一项的指数隐藏在下标中 如果多项式连续，使用数组（顺序表）是最方便的 运算时，对应位置按顺序逐个相加/相减/相乘，直到存在空表时，将非空表内剩余元素填入即可 个人代码 王老师没有演示代码，于是我自己敲了，当作练习题 #include <iostream> using namespace std; #de
两个多项式相加的程序（链表）
leafdown_的博客
10-22 6370
思路： 1、定义结构体struct，包含元素coef,exp 2、创建链表输入函数 polypointer createLink(int n); 3、创建两个多项式相加的函数 polypointer PolyAdd(polypointer a,polypointer b); 其中，PolyAdd函数调用函数 polypointer Attach(int e,int c,polypoin
数据结构实验课题2-两个多项式相加
来为您的博客
09-21 2947
[问题描述] 设计一个算法，以实现一元稀疏多项式的加法运算。 [基本要求] （1）输入并建立多项式； （2）输出多项式，输出形式为整数序列：n，c1，e1，c2，e2，……，cn，en，其中n是多项式的项数，ci和ei分别是第i项的系数和指数，序列按指数降序排列； （3）多项式a和b相加，建立多项式a+b。 [测试数据] 由学生任意指定。 [实现提示] 　　用带表头结点的单链表存储多项式。 [选作...
数据结构多项式相加 链表
08-30
对于多项式相加，我们可以遍历两个链表，将相同次数的项的系数相加，并将结果添加到新的链表中。如果一个链表已经遍历完了，那么就将另一个链表中的剩余项全部添加到新链表中。 具体的实现细节可以参考下面的示例...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值