多项式基本运算的实现

最新推荐文章于 2022-05-04 21:45:36 发布
最新推荐文章于 2022-05-04 21:45:36 发布
阅读量356 收藏 5
点赞数
分类专栏： c++ 文章标签： 1024程序员节 数据结构 单链表 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47182486/article/details/109258139
版权

多项式的基本运算（链表实现）

程序具体说明：
使用链表实现两个多项式的基本操作。
初级要求：实现加法、减法和微分操作。
高级要求：实现乘法和除法操作。（除法操作中，当不能除尽时还要求列出余式。）

节点要包括：系数，指数，下一节点的指针
链表中，各结点按指数升幂或降幂排列，生成的结果多项式仍使用原多项式所占用的存储空间：两个同类项相加或相减时，如果系数不为0，则修改该结点的系数值，而指数值不变，将该结点链入结果多项式中，而另一项则释放空间；如果系数为0，则这两项占用的空间均需释放。不同类项则直接放入结果多项式中。

输入数据格式：
使用文件保存初始的多项式数据，文件名为inputfile.txt，文件中应含有表示两个多项式的初始数据。文件中的数据格式为：
(a,n)…(a,n)(0,0)
(a,n)…(a,n)(0,0)
AND/SUB/DIFF/MUL/DIV(#,#)
其中，a是系数，n是指数，两数之间使用逗号分隔，并用括号括起来。其后以(0,0)作为一个多项式输入的结束。以字符串AND表示加法操作，以字符串SUB表示减法操作，以字符串DIFF表示微分操作，以字符串MUL表示乘法操作，以字符串DIV表示除法操作，以(#,#)作为全部数据输入的结束标志。

输出数据格式：
输出结果也保存在文件中，文件名为outputfile.txt，文件中应含有结果多项式的值，以多项式的形式输出结果，例如如下所示的多项式：
2x3 –5x2 + x1 +9
在输出文件中表示为：2x3 –5x2 + x1 +9

测试示例一：
(5,100)(9,31)(-7,2)(1,1)(10,0)(0,0)
(-60,81)(-9,31)(5,2)(1,1)(0,0)
AND(#,#)
测试示例二：
(5,100)(9,31)(-7,2)(1,1)(10,0)(0,0)
(-60,81)(-9,31)(5,2)(1,1)(0,0)
SUB(#,#)
测试示例三：
(5,100)(9,31)(-7,2)(1,1)(10,0)(0,0)
(-60,81)(-9,31)(5,2)(1,1)(0,0)
MUL(#,#)

代码:

#include<iostream>
#include<fstream>
#include<string>
using namespace std;
class Node {
public:
	int xishu,zhishu;
	Node*next;
	int tag = 0;
};
class List {
	Node*head;
	int count = 0;
	Node*cur;
	int now_index = 0;
public:
	List() { head = new Node; head->next = NULL; cur = head; }
	void insert( Node *);
	void remove(int i);
	void traverse();
	Node* gethead() { return head; }
};
void List::traverse()
{

	Node*cur1 = head;
	while (cur1->next)
	{
		cout << cur1->next->xishu << ' ' << cur1->next->zhishu<<' ';
		cur1 = cur1->next;
	}
	cout << endl;
}
void List::insert(Node *n)
{
	Node*tmp = new Node;//插入时，新生成一个节点存入插入节点所有信息，防止插入节点导致链表断裂
	tmp->tag = n->tag;
	tmp->xishu = n->xishu;
	tmp->zhishu = n->zhishu;
	cur = head;
	while(cur->next)
	{
		cur = cur->next;
	}
	tmp->next = cur->next;
	cur->next = tmp;
	cur = tmp;
	count++;
}
void List::remove(int i)
{
	cur = head;
	now_index = 0;
	while (now_index < i - 1)
	{
		now_index++;
		cur = cur->next;
		now_index++;

	}
	cur->next = cur->next->next;
	count--;
}


//---新函数
void swap(int&a, int&b)
{
	int tmp = a;
	a = b;
	b = tmp;
}
void Sort(List &l1)//针对加法，减法，微分进行处理
{
	Node*n1 = l1.gethead();
	Node*n2 = n1->next;
	while (n2)//将系数为0的部分删除
	{

		if (n2->xishu == 0)
		{
			n2 = n2->next;
			Node*tmp = n1->next;
			n1->next = n1->next->next;
			delete tmp;
		}
		else {
			n2 = n2->next;
			n1 = n1->next;
		}
	}
	n1 = l1.gethead();
	n2 = n1->next;
	while (n1&&n1->next)//按照指数进行排序
	{

		while (n2&&n2->next)
		{
			if (n1->next->zhishu < n2->next->zhishu)
			{
				swap(n1->next->xishu, n2->next->xishu);
				swap(n1->next->zhishu, n2->next->zhishu);
			}
			n2 = n2->next;
		}
		n1 = n1->next;
		n2 = n1->next;
	}
}
void Sort2(List&l1)//对乘除后的链表进行处理
{
	Node*n1 = l1.gethead();
	Node*n2 = n1->next;

	while (n1&&n1->next)//按照指数进行排序
	{

		while (n2&&n2->next)
		{
			if (n1->next->zhishu < n2->next->zhishu)
			{
				swap(n1->next->xishu, n2->next->xishu);
				swap(n1->next->zhishu, n2->next->zhishu);
			}
			if (n1->next->zhishu == n2->next->zhishu)//如果有指数相同的，则相加，并且将一项释放掉
			{
				n1->next->xishu += n2->next->xishu;
				Node*tmp = n2->next;
				n2->next = n2->next->next;
				delete tmp;
			}
			n2 = n2->next;
		}
		n1 = n1->next;
		n2 = n1->next;
	}

	n1 = l1.gethead();
	n2 = n1->next;
	while (n2)//将系数为0的部分删除
	{

		if (n2->xishu == 0)
		{
			n2 = n2->next;
			Node*tmp = n1->next;
			n1->next = n1->next->next;
			delete tmp;
		}
		else {
			n2 = n2->next;
			n1 = n1->next;
		}
	}


}
void div(List &l1, List &l2,List&l3)//l1 l2存放被除数和除数，l3存放商，l1也存放最后的余数
{
	Sort2(l1);//预先对l1 l2进行排序
	Sort2(l2);
	Node*n1 = l1.gethead();
	Node*n2 = l2.gethead();
	Node*n3;
	if (n1->next->zhishu < n2->next->zhishu)//如果被除数的指数小于除数，则商为0，l1自身为余数
	{
		n3 = new Node;
		n3->zhishu = 0;
		n3->xishu = 0;
		l3.insert(n3);
		return;
	}
	else//如果l1指数大于l2，则不断进行比较，直到小于
	{
		while (l1.gethead()->next&&l1.gethead()->next->zhishu >= l2.gethead()->next->zhishu)//当l1的指数大于l2，且l1中未被整除
		{
			n3 = new Node;
			int zhishu, xishu;
			zhishu = l1.gethead()->next->zhishu - l2.gethead()->next->zhishu;//求出商的指数和系数
			xishu = l1.gethead()->next->xishu / l2.gethead()->next->xishu;
			n3->zhishu = zhishu;
			n3->xishu = xishu;
			l3.insert(n3);
			delete n3;//释放内存

			n2 = l2.gethead();
			while (n2->next)//将l2中各项乘以当前算的商，放入l1中进行减法
			{
				Node*tmp = new Node;
				tmp->xishu = -n2->next->xishu * xishu;
				tmp->zhishu = n2->next->zhishu + zhishu;
				l1.insert(tmp);
				delete tmp;
				n2 = n2->next;

			}

			Sort2(l1);//对l1中进行去重排序
		}
	}
}
void add(List &l1, List &l2)//将结果全部存入l1中
{
	Node*n1 = l1.gethead();
	Node*n2 = l2.gethead();


	//将l2中的节点插入l1中
	while (n2&&n2->next)
	{
		l1.insert(n2->next);
		Node*tmp = n2->next;//释放内存
		n2->next = n2->next->next;
		delete tmp;
	}

	Sort2(l1);
}
void sub(List &l1, List &l2)
{
	Node*n1 = l1.gethead();
	Node*n2 = l2.gethead();


	//将l2中的节点插入l1中
	while (n2&&n2->next)
	{
		n2->next->xishu *=-1;//系数为负

		l1.insert(n2->next);
		Node*tmp = n2->next;
		n2->next = n2->next->next;
		delete tmp;
	}

	Sort2(l1);

}
void diff(List &l1)
{
	Node*n1 = l1.gethead();
	while (n1->next)
	{
		n1->next->xishu *= n1->next->zhishu;
		n1->next->zhishu--;
		n1 = n1->next;
	}
	Sort2(l1);
}
void mul(List &l1, List &l2)
{
	Node*n1 = l1.gethead();
	Node*n2 = l2.gethead();
	while (n1->next&&n1->next->tag==0)//将两个表达式相乘，生成的项放入l1的末尾，用tag来区分新生成的和旧的
	{

		while (n2->next)
		{
			Node*n3 = new Node;
			
			n3->tag = 1;
			n3->xishu = n1->next->xishu*n2->next->xishu;
			n3->zhishu = n1->next->zhishu + n2->next->zhishu;

			l1.insert(n3);
			delete n3;//释放内存
			n2 = n2->next;
		}
		n1 = n1->next;
		n2 = l2.gethead();
	}
	
	n2 = l2.gethead();
	while (n2->next)//所有结果全部保存l1中，则将l2中数据释放
	{

		Node*tmp=n2->next;
		n2->next = n2->next->next;
		delete tmp;

	}

	n1 = l1.gethead();
	while (n1->next&&n1->next->tag==0)//将l1前面自身的数据删掉，只留下结果
	{
			Node*tmp = n1->next;
			n1->next = n1->next->next;
			delete tmp;
	}

	Sort2(l1);

}
int main()
{
	List l1, l2,l3,l4;
	ifstream if1("inputfile.txt");
	ofstream of1("outputfile.txt");

	char*s1, *s2, *s3;
	s1 = new char[100];
	s2 = new char[100];
	s3 = new char[100];
	if1.getline(s1, 100);//将多项式以及命令读入三个数组中
	if1.getline(s2, 100);
	if1.getline(s3, 100);
	int i, j;
	for (i = 0; i < strlen(s1); i++)//将数组中的多项式放入链表中
	{
		int a1, a2;
		if (isdigit(s1[i])||s1[i]=='-')
		{
			string s_1;
			while (isdigit(s1[i])||s1[i]=='-')
			{
				s_1+=s1[i++];
			}
			 a1 = stoi(s_1);
		}
		if (s1[i] == ',')
		{
			i++;
			string s_2;
			while (isdigit(s1[i])||s1[i]=='-')
			{
				s_2 += s1[i++];
			}
			 a2 = stoi(s_2);
			 if (a1 == 0 && a2 == 0)
				 break;
			 Node*n1 = new Node;
			 n1->xishu = a1;
			 n1->zhishu = a2;
			 l1.insert(n1);

		}

	}
	for (i = 0; i < strlen(s2); i++)
	{
		int a1, a2;
		if (isdigit(s2[i]) || s2[i] == '-')
		{
			string s_1;
			while (isdigit(s2[i]) || s2[i] == '-')
			{
				s_1 += s2[i++];
			}
			a1 = stoi(s_1);
		}
		if (s2[i] == ',')
		{
			i++;
			string s_2;
			while (isdigit(s2[i]) || s2[i] == '-')
			{
				s_2 += s2[i++];
			}
			a2 = stoi(s_2);
			if (a1 == 0 && a2 == 0)
				break;
			Node*n1 = new Node;
			n1->xishu = a1;
			n1->zhishu = a2;
			l2.insert(n1);

		}

	}
	if (s3[0] == 'A')
	{
		 add(l1, l2);

	}
	if (s3[0] == 'S')
	{
		sub(l1, l2);

	}
	if (s3[0] == 'D'&&s3[1]=='I'&&s3[2]=='F')
	{
		 diff(l1);
		 diff(l2);

	}
	if(s3[0]=='M')
	{ 
		 mul(l1, l2);

	}
	if (s3[0] == 'D'&&s3[1] == 'I'&&s3[2] == 'V')
	{
		div(l1, l2, l3);

	}

	if (s3[0] == 'D'&&s3[1] == 'I'&&s3[2] == 'V')//如果进行除的运算
	{
		of1 << "商为：";
		Node*tmp = l3.gethead();
		while (tmp->next)
		{
			if (tmp->next->xishu > 0 && tmp != l3.gethead())
				of1 << '+';
			if (tmp->next->zhishu != 0)
				of1 << tmp->next->xishu << 'x' << tmp->next->zhishu;
			if (tmp->next->zhishu == 0)
				of1 << tmp->next->xishu;

			tmp = tmp->next;
		}
		of1 << endl << "余数为：";
		Node*n1 = new Node;
		n1 = l1.gethead();
		if (n1->next == NULL)//如果可以被整除
		{
			of1 << 0;
		}
		while (n1->next)
		{

			if (n1->next->xishu > 0 && n1 != l1.gethead())
				of1 << '+';
			if (n1->next->zhishu != 0)
				of1 << n1->next->xishu << 'x' << n1->next->zhishu;
			if (n1->next->zhishu == 0)
				of1 << n1->next->xishu;
			n1 = n1->next;
		}
		return 0;
	}
	Node*n1 = new Node;
	n1 = l1.gethead();
	if (s3[0] == 'D'&&s3[1] == 'I'&&s3[2] == 'F')
	{
		of1 << "第一个式子：";
	}
	while (n1->next)
	{

		if (n1->next->xishu > 0 && n1 != l1.gethead())
			of1 << '+';
		if(n1->next->zhishu!=0)
			of1 << n1->next->xishu << 'x' << n1->next->zhishu;
		if (n1->next->zhishu == 0)
			of1 << n1->next->xishu;
		n1 = n1->next;
	}
	if (s3[0] == 'D'&&s3[1] == 'I'&&s3[2] == 'F')//如果是微分的话，则将两个式子分别微分并存入文本
	{
		of1 << endl<<"第二个式子：";
		Node*n2 = new Node;
		n2 = l2.gethead();
		while (n2->next)
		{

			if (n2->next->xishu > 0 && n2 != l2.gethead())
				of1 << '+';
			if (n2->next->zhishu != 0)
				of1 << n2->next->xishu << 'x' << n2->next->zhishu;
			if (n2->next->zhishu == 0)
				of1 << n2->next->xishu;
			n2 = n2->next;
		}

	}
	
}
正在吃饭的派大星
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多项式类的 C++ 实现
07-26
文件构造了一个较完整的多项式类，可以实现多项式的常用运算： 1、可通过　Poly P 声明一个多项式 P； 2、可通过　P.read(string P_str) 直接从 手写习惯的多项式字符串 读入多项式； 3、可通过 P.newTerm(double Coef, int Exp) 增添多项式的项，如果含有同类项，则合并； 4、可直接通过 P　=　Q 给多项式 P 赋值； 5、可直接通过 cout << P 以手写习惯输出多项式； ６、可通过　P.clear() 清除一个多项式； ７、可直接通过 +、-、*、／、% 进行多项式间的运算； ８、可通过 gcd(Poly P, Poly Q)、lcm(Poly P, Poly Q) 求两个多项式的最大公因式、最小公倍式； ９、可以获取多项式的各种信息： 　　９.1、可通过 P.deg() 获取多项式的次数； 　　９.2、可通过 P.mainCoef() 获取多项式的主系数； 　　９.3、可通过 P.coef(int n) 获取多项式　P　的　n 次项系数； 　　９.4、可通过 P.eval(double x)、P.eval(Complex x) 获取多项式　P 在给定值　x 处的取值；(其中 Complex 类已经构造好，可直接使用) 　　９.5、可通过 P.com(Q) 计算多项式 P 与 Q 的复合； 　　９.6、可通过 P.diff() 计算多项式　P 的导多项式； １０、可通过 P.roots() 求任意次多项式的所有根(包括复根)，其返回值类型为vector　。
多项式的实现
endwall的专栏
03-17 278
<br />多项式的实现是ADT的一个很重要的内容，相信有的公司面试的时候也会叫你当场写一个，下面就讲讲如果用ADT来实现多项式。<br />有两种实现，一种是用数组，还有一个就是用链表作为基本的数据结构。
多项式加法的实现
熊孩纸_的博客
11-05 555
//采用不带头结点的单向链表，按照指数递减的顺序排列各项 //思路：俩个指针P1P2分别指向这两个多项式的第一个结点，不断循环 #include<stdio.h> #include<stdlib.h>struct PolyNode { int coef;//系数 int expon;//指数 struct PolyNode *link;//指向下一节点的指针 }; typed
多项式的加法实现
JZJZ73的博客
02-20 503
//多项式的加法实现 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; typedef struct _poly { int coef; int expo; struct _poly *next; }Poly; typedef struct _polist { Poly *head; Poly *tail; }PolyList; ...
利用单链表实现多项式基本运算(C++模板实现）
08-10
本主题聚焦于如何使用C++模板实现单链表，并基于此实现多项式的加、减、乘等基本运算。下面将详细介绍这两个知识点。 **1. C++模板** C++模板是一种泛型编程工具，它允许我们编写可以处理不同数据类型的代码。模板...
链表实现多项式的运算
04-05
本项目涉及的主题是“链表实现多项式的运算”，它巧妙地利用链表的数据结构来表示和操作数学中的多项式。在此，我们将深入探讨链表如何用于表示多项式以及如何进行多项式的加法、减法和乘法运算。 首先，我们要理解...
用单链表实现多项式的运算
10-31
本话题我们将深入探讨如何利用单链表来实现多项式的运算，这是计算机科学中的一种典型应用，尤其在数值计算、数学软件以及计算机图形学等领域有着重要用途。我们将使用C语言进行编程实现。 首先，我们需要理解什么...
jsq.rar_多项式运算
09-24
通过以上步骤，我们可以编写一个完整的C语言程序，实现一元多项式的加、减、乘、求值等基本运算。在实际应用中，可能还需要考虑到多项式排序、比较、优化存储空间等因素，以提高算法效率和程序的实用性。
用链表实现多项式运算
12-04
本项目“用链表实现多项式运算”聚焦于利用链表来表示和操作多项式，涵盖了多项式的基本运算：加法、减法、乘法以及求导。下面将详细讨论这些知识点。 首先，链表是一种非连续存储结构，由一系列节点组成，每个节点...
拟合多项式函数
01-05
levenberg_marquardt算法拟合多项式和对数函数 python写的
两个多项式的基本操作
09-07
用链表实现加法、减法和微分操作，乘法和除法操作。 链表中，各结点按指数升幂或降幂排列，生成的结果多项式仍使用原多项式所占用的存储空间：两个同类项相加或相减时，如果系数不为0，则修改该结点的系数值，而指数值不变，将该结点链入结果多项式中，而另一项则释放空间；如果系数为0，则这两项占用的空间均需释放。不同类项则直接放入结果多项式中。
多项式基本操作的实现
weixin_30265103的博客
11-10 164
2018-11-10-15:03:10 1 /********************************************* 2 完成多项式的输入输出，基本加减乘除法操作的实现。 3 main函数操作： 4 1.输入第一个多项式的项数。 5 2.依次输入m项多项式的系数和指数。 6 ...
利用线性表实现多项式的算术运算
xyy_ywqs的博客
06-12 636
#include <iostream> #include <string> using namespace std; class Term { public: Term(int c, int e); Term(int c, int e, Term* nxt); Term* InsertAfter(int c, int e);//在this指针指示的结点后抓人新结点 int coef; int exp; Term* link; private: friend ostrea
【Python】任意边界条件生成多项式基函数的算法（一维）
qq_50920297的博客
05-04 1633
Python由任意边界条件生成近似解 取近似解的思路是，先确定一组线性无关的基函数，再线性叠加基函数，即可获得近似解。 工程领域常用的傅里叶展开，就是选取一组线性无关的三角函数作为基函数，线性叠加基函数后，就获得了原函数的近似解 常用的近似解是取多项式作基函数，由泰勒展开可知，所取多项式的项数越高，则近似解会越逼近原函数，但有得必有舍，因为所取多项式的系数均为未知数，若...
【深度学习学习笔记】2.线性回归之二：不同基函数的实现
cazenove的博客
07-28 1837
实现“多项式基函数”以及“高斯基函数” 其中以及训练集的x的范围在0-25之间 import numpy as np def identity_basis(x): # 将形状从（N，）转换成（N，1） ret = np.expand_dims(x, axis=1) return ret def multinomial_basis(x, feature_num=10): x = np.expand_dims(x, axis=1) # shape(N, 1) f
c语言实现多项式的基本运算
q1430186623的博客
09-22 9698
多项式是数学中常用的一种表达式，现在我们给出用c语言编程实现多项式的计算，并且多项式的计算是链表的典型应用，通过编程实现多项式，也为我们巩固一下链表的知识以及它的生活应用。 下面给出代码 #include <stdio.h> #include <stdlib.h> #include <math.h> typedef struct node { float coef; //系数域 int exp; //指数域 struct node *next; //指针域
【数据结构】用链表实现多项式运算
热门推荐
_Previous的博客
08-08 2万+
一元多项式的运算包括加法减法和乘法，而多项式的加法和乘法都可以依靠多项式的加法来实现，所以本文仅仅讲解如何用链表实现一元多项式的加法。 数学上的一元多项式的表示是p(x) = p0 + p1 * x + p2 * x^2 + p3 * x^3 + … + pn * x^n; 用链表来表示就是p = (p0, p1, p2, … , pn); 所谓的多项式相加就是同类项的合并，也就是两条链表的
实现多项式的基本运算
nightowl小天地
04-17 483
#include&lt;iostream&gt; #include&lt;stdlib.h&gt; using namespace std; class LinkNode { public: int data; int exp; LinkNode *link; LinkNode() {}// LinkNode...
一元多项式的加减求导运算算法(数据结构算法) (2).docx
最新发布
10-30
"该文档详细介绍了如何设计和实现一元多项式的加减及求导运算算法，主要针对数据结构和算法的学习。文档中提供了一系列的测试数据，用于检验算法的正确性。" 在数据结构和算法领域，一元多项式运算是一种常见的问题...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值