一元多项式的加减法 C++实现

最新推荐文章于 2022-05-21 16:23:30 发布
最新推荐文章于 2022-05-21 16:23:30 发布
阅读量3.8k 收藏 9
点赞数 5
分类专栏： C++、算法与数据结构 文章标签： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liu798675179/article/details/73187496
版权

一元多项式的加减法

描述：如题，使用正则表达式匹配多项式，数据结构为链表。

注：编译器需兼容C++11

源代码：

Unary_Polynomial.h

#pragma once

#include <algorithm>
#include <iostream>
#include <regex>
#include <list>

struct item {
	friend item operator+(item l, item r) { return item(l.coefficient + r.coefficient, l.power); }
	friend item operator-(item l, item r) { return item(l.coefficient - r.coefficient, l.power); }
	friend bool operator==(item l, item r) { return l.coefficient == r.coefficient && l.power == r.power; }

	item() = default;
	item(const int &co, const int &po) : coefficient(co), power(po) {}
	~item() = default;

	int coefficient = 0;
	int power = 0;
};

class Unary_Polynomial {
	friend Unary_Polynomial operator+(Unary_Polynomial l, Unary_Polynomial r);
	friend Unary_Polynomial operator-(Unary_Polynomial l, Unary_Polynomial r);
	friend bool operator==(Unary_Polynomial l, Unary_Polynomial r);
	friend bool operator!=(Unary_Polynomial l, Unary_Polynomial r);
public:
	Unary_Polynomial() = default;
	~Unary_Polynomial() = default;

	void Input(const std::string &express);
	void Insert(const int &co, const int &po);
	void Print();
	void Clear();

private:
	std::list<item> unary_poly;
};

inline void Unary_Polynomial::Input(const std::string &express) {
	std::regex pat_regex("\\+?(\\-?[[:digit:]]+)x\\^(\\-?[[:digit:]]+)|\\+?(\\-?x)\\^(\\-?[[:digit:]]+)|\\+?(\\-?[[:digit:]]+)x|\\+?(\\-?[[:digit:]]+)|\\+?(\\-?x)");

	for (std::sregex_iterator it(express.begin(), express.end(), pat_regex), end_it; it != end_it; ++it) {
		//std::cout << it->str(0) << std::endl;
		//std::cout << " 1: " << it->str(1) << " 2: " << it->str(2) << " 3: " << it->str(3) << " 4: " << it->str(4) << " 5: " << it->str(5) << " 6: " << it->str(6) << " 7: " << it->str(7) << std::endl;

		if(it->str(1) != "" && it->str(2) != "") {
			auto co = stoi(it->str(1));
			auto po = stoi(it->str(2));
			Insert(co, po);
		}
		if(it->str(4) != "") {
			auto co = 1;
			if(it->str(3) == "-x") {
				co = -1;
			}
			auto po = stoi(it->str(4));
			Insert(co, po);
		}
		if(it->str(5) != "") {
			auto co = stoi(it->str(5));
			auto po = 1;
			Insert(co, po);
		}
		if(it->str(6) != "") {
			auto co = stoi(it->str(6));
			auto po = 0;
			Insert(co, po);
		}
		if (it->str(7) != "") {
			auto co = 1;
			if (it->str(7) == "-x") {
				co = -1;
			}
			auto po = 1;
			Insert(co, po);
		}
	}

	unary_poly.sort([](const item &i, const item &j) {return i.power < j.power; });

	auto temp_count = std::count_if(unary_poly.begin(), unary_poly.end(), [](const item &i) {return i.coefficient == 0; });
	if(temp_count == unary_poly.size()) {
		unary_poly.clear();
	}
}

inline void Unary_Polynomial::Insert(const int& co, const int& po) {
	auto find_it = std::find_if(unary_poly.begin(), unary_poly.end(), [&](const item &j) {return po == j.power; });
	if (find_it != unary_poly.end()) {
		find_it->coefficient += co;
	}
	else {
		item temp_item(co, po);
		unary_poly.push_back(temp_item);
	}
}

inline void Unary_Polynomial::Print() {
	if (!unary_poly.empty()) {
		for (auto i = unary_poly.begin(); i != unary_poly.end(); ++i) {
			if (i->coefficient > 0 && i != unary_poly.begin()) {
				std::cout << "+";
			}
			if(i->coefficient != 0 && i->power == 0) {
				std::cout << i->coefficient;
			}
			if (i->power != 0 && i->power != 1 && i->coefficient != 0 && i->coefficient != 1 && i->coefficient != -1) {
				std::cout << i->coefficient << "x^" << i->power;
			}
			if (i->power != 0 && i->power != 1 && i->coefficient != 0 && (i->coefficient == 1 || i->coefficient == -1)) {
				if (i->coefficient == -1) {
					std::cout << "-";
				}
				std::cout << "x^" << i->power;
			}
			if (i->power == 1 && i->coefficient != 0 && i->coefficient != 1 && i->coefficient != -1) {
				std::cout << i->coefficient << "x";
			}
			if (i->power == 1 && i->coefficient != 0 && (i->coefficient == 1 || i->coefficient == -1)) {
				if(i->coefficient == -1) {
					std::cout << "-";
				}
				std::cout << "x";
			}
		}
	}
	else {
		std::cout << 0;
	}

	std::cout << std::endl << std::endl;
}

inline void Unary_Polynomial::Clear() {
	unary_poly.clear();
}


inline Unary_Polynomial operator+(Unary_Polynomial l, Unary_Polynomial r) {
	Unary_Polynomial temp_UP;
	item temp_item;

	for(auto &i : l.unary_poly) {
		auto find_it = std::find_if(r.unary_poly.begin(), r.unary_poly.end(), [&](const item &j) {return i.power == j.power; });
		if(find_it != r.unary_poly.end()) {
			temp_item = i + *find_it;

			r.unary_poly.erase(find_it); //erase r which with the same power of l
		}
		else {
			temp_item = i;
		}

		temp_UP.unary_poly.push_back(temp_item);
	}

	for(auto &i : r.unary_poly) {
		temp_item = i;
		temp_UP.unary_poly.push_back(temp_item);
	}

	temp_UP.unary_poly.sort([](const item &i, const item &j) {return i.power < j.power; });

	return temp_UP;
}

inline Unary_Polynomial operator-(Unary_Polynomial l, Unary_Polynomial r) {
	Unary_Polynomial temp_UP;
	item temp_item;

	if (r != l) {
		for (auto &i : l.unary_poly) {
			auto find_it = std::find_if(r.unary_poly.begin(), r.unary_poly.end(), [&](const item &j) {return i.power == j.power; });
			if (find_it != r.unary_poly.end()) {
				temp_item = i - *find_it;

				r.unary_poly.erase(find_it); //erase r which with the same power of l
			}
			else {
				temp_item = i;
			}

			temp_UP.unary_poly.push_back(temp_item);
		}

		for (auto &i : r.unary_poly) {
			temp_item.coefficient = -i.coefficient;
			temp_item.power = i.power;
			temp_UP.unary_poly.push_back(temp_item);
		}

		temp_UP.unary_poly.sort([](const item &i, const item &j) {return i.power < j.power; });
	}

	return temp_UP;
}

inline bool operator==(Unary_Polynomial l, Unary_Polynomial r) {
	if(l.unary_poly.size() == r.unary_poly.size()) {
		for(auto i_l = l.unary_poly.begin(), i_r = r.unary_poly.begin(); i_l != l.unary_poly.end(); ++i_l, ++i_r) {
			if(*i_l == *i_r) {
				return true;
			}
		}
	}
	
	return false;
}

inline bool operator!=(Unary_Polynomial l, Unary_Polynomial r){
	return !(l == r);
}

Test.cpp

#include "Unary_Polynomial.h"

using namespace std;

int main() {
	Unary_Polynomial a, b;
	string express, express1;

	while (cin >> express >> express1) {
		a.Input(express);
		b.Input(express1);

		auto c = a + b;
		auto d = a - b;

		cout << endl << "a + b:" << endl;
		c.Print();
		cout << "a - b:" << endl;
		d.Print();

		a.Clear();
		b.Clear();
		c.Clear();
		d.Clear();
	}

	return 0;
}

示例：
示例

_MICHAEL_LIU_
关注
专栏目录
一元多项式相加的算法和C++实现
lfeng_coding的博客
08-13 1万+
利用顺序表的链式存储实现一元多项式的加法
C++ 数据结构 一元多项式 加减乘法 链表结构实现
最新发布
weixin_59629651的博客
11-02 1520
链表实现多项式，数据结构C++
一元多项式相加（c++）
08-05
题目说明： 编写一元多项式加法运算程序。要求用线性链表存储一元多项式（参照课本）。该程序有以下几个功能： 1. 多项式求和 输入：输入三个多项式，建立三个多项式链表Pa、Pb、Pc （提示：调用CreatePolyn(polynomial &P,int m)。 输出：显示三个输入多项式Pa、Pb、Pc、和多项式Pa+Pb、多项式Pa+Pb+Pc （提示：调用AddPolyn(polynomial &Pa, polynomial Pb), 调用PrintPolyn(polynomial P))。 0. 退出 输入： 根据所选功能的不同，输入格式要求如下所示（第一个数据是功能选择编号，参见测试用例）： 1 多项式A包含的项数，以指数递增的顺序输入多项式A各项的系数（整数）、指数（整数） 多项式B包含的项数，以指数递增的顺序输入多项式B各项的系数（整数）、指数（整数） 多项式C包含的项数，以指数递增的顺序输入多项式C各项的系数（整数）、指数（整数） 0 －－－操作终止，退出。 输出： 对应一组输入，输出一次操作的结果（参见测试用例）。 1 多项式输出格式：以指数递增的顺序输出: ,,,参见测试用例。零多项式的输出格式为 0 无输出
基于C++的一元多项式的计算
qq_38474673的博客
07-01 1435
1 问题描述将多个多项式输入并存储在内存中，然后对多项式进行加、减运算并输出结果。2 数据结构描述一元多项式的表示方式：如 f=6x^5-7x^4+3 表示为 f=6,5 -7,4 3,0每个多项式用单链表来存储： typedef struct PolyNode { float coef; // 系数 int exp...
[源码和文档分享]基于C++的一元多项式的计算
12-07 188
1 问题描述 将多个多项式输入并存储在内存中，然后对多项式进行加、减运算并输出结果。 2 数据结构描述 一元多项式的表示方式：如 f=6x^5-7x^4+3 表示为 f=6,5 -7,4 3,0 每个多项式用单链表来存储： typedef struct PolyNode { float coef; // 系数 int...
一元多项式运算c++版
07-20
数据结构中经典题目，一元多项式的计算，运用c++实现一元多项式计算。
C语言：一元多项式加减法运算（链表 附答案）.docx
10-26
《C语言实现一元多项式加减法运算的链表方法》 在计算机科学中，数据结构和算法是解决问题的基础工具。本篇文章将探讨如何使用C语言通过链表实现一元多项式的加减法运算。这是一道适合初学者的链表实践题目，通过这...
数据结构--一元多项式加减法
03-19
本文将深入探讨一元多项式加减法这一数据结构问题，以及如何使用C++通过链表实现。链表是一种线性数据结构，其中每个元素（节点）包含数据以及指向下一个节点的指针，这使得链表非常适合表示多项式，因为多项式的项...
一元多项式加减乘运算-数据结构-课程设计
01-20
在这个课程设计中，我们将使用链表数据结构来表示一元多项式，并实现加、减、乘运算。 首先，定义一个名为`Polyn.h`的头文件，其中包含了一元多项式节点`PolyNode`的结构体定义和多项式链表指针`PLinkList`。`...
C++链表实现一元多项式（加法、减法、乘法）
weixin_43200943的博客
05-21 1346
C++链表实现一元多项式（加法、减法、乘法）
一元多项式（C++）
11-01
一元多项式#include typedef struct { int xi;//系数 int zhi;//指数 }ElemType; typedef struct LNode { ElemType data; //结点的数据部分 struct LNode *next; } LinkList; //初始化链表 void InitList(LinkList *&L) { L=new LinkList; L->next=NULL; }
C++实现多项式加法
11-12
C++实现多项式加法，可重复运行，有界面……
一元多项式_C++源代码
12-10
用链表表示一元多项式，先做链表的快排，然后做加减乘除运算，最后得到结果的一元多项式
一元多项式的加减 C++ 数据结构
01-09
课程设计 数据结构的 C++版本 希望有同学可以用用 混点分啊 谢谢啦
（C++）多项式加减法（一元）
coderge's CSDN Blog.
08-14 1272
（easy）一元多项式表示 #include&lt;iostream&gt; #include&lt;cmath&gt; using namespace std; struct node{ int coef; //系数 int expo; //指数 node *next; }; int main() { cout&lt;&lt;"几项呀...
C++完成多项式的加减法
苟且偷生的博客
05-09 1535
欢迎使用Markdown编辑器写博客本Markdown编辑器使用StackEdit修改而来，用它写博客，将会带来全新的体验哦： Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列图和流程图 离线写博客 导入导出Markdown文件 丰富的快捷键 快捷键 加粗 Ctrl + B 斜体 Ctrl + I 引用 Ctrl
【C++】C++多项式相加减，系数相加减
telescope_U的博客
02-05 910
注：此处指的多项式相加减是指系数的相加减。 代码： #include <iostream> #include<stack> #include<string.h> #include<string> using namespace std; /*********************************************第一项式*************************************/ struct Data//节点数据 {
一元多项式的加减法（C++版）
weixin_30562507的博客
03-28 364
#include<iostream>#include<stdlib.h> #include<ctype.h> using namespace std;typedef struct Lnode { float coef; //系数 int exp; //指数 struct Lnode...
C++实现一元稀疏多项式加减法
"本文介绍了一种使用C++实现的一元稀疏多项式数据结构，主要涉及链表的操作，包括多项式的加减法。" 在计算机科学中，数据结构是存储和组织数据的重要方式，以便于高效地访问和操作。本示例中，我们关注的是一种...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值