单链表之一元多项式求和C++实现

单链表之一元多项式求和

一元多项式求和单链表实现伪代码

1、工作指针 pre、p、qre、q 初始化
2、while（p 存在且 q 存在）执行下列三种情况之一：
　　2.1、若 p->exp < q->exp：指针 p 后移；
　　2.2、若 p->exp > q->exp，则
　　　　2.2.1、将结点 q 插到结点 p 之前
　　　　2.2.2、指针 p 指向他原指结点的下一个结点；
　　2.3、若 p->exp == q->exp，则
　　　　2.3.1、p->coef = p->coef + q->coef
　　　　2.3.2、若 p->coef == 0,则执行下列操作，否则指针 p 后移，
　　　　　　2.3.2.1、删除结点 p
　　　　　　2.3.2.2、使指针 p 指向它原指结点的下一个结点
　　　　2.3.3、删除结点 q
　　　　2.3.4、使指针 q 指向它原指结点的下一个结点
3、如果 q 不为空，将结点 q 链接在第一个单链表的后面。
一、一元多项式求和单链表实现头文件：PolynomialOfOneIndeterminateAdd.h

//一元多项式求和头文件
#include<iostream>
using namespace std;
template<class DataType>
//定义单链表结点
struct Node
{
　　//数据域：非零项的系数和指数
　　DataType coef, exp;
　　//指针域
　　Node<DataType> *next;
};
//定义存放一元多项式的类
template<class DataType>
class Linklist
{
private:
　　Node<DataType> *first;
　　//一元多项式的项数
　　int size;
public:
　　//构造函数
　　Linklist();
　　//初始化一元多项式
　　void Init();
　　//输出一元多项式
　　void Print();
　　//定义一元多项式的的加法操作
　　Linklist<DataType> operator+(Linklist &p2);
};

//构造函数
template<class DataType>
Linklist<DataType>::Linklist()
{
　　first = new Node<DataType>;
　　first = NULL;
　　size = 0;
}

//实现一元多项式单链表的初始化
template<class DataType>
void Linklist<DataType>::Init()
{
　　cout << "多项式的元素个数为:";
　　cin >> size;
　　DataType x, y;
　　cout << "请输入第1项的系数:";
　　cin >> x;
　　cout << "请输入第1项的指数:";
　　cin >> y;
　　Node<DataType> *m;
　　m = new Node<DataType>;
　　m->coef = x;
　　m->exp = y;
　　m->next = NULL;
　　first = m;
　　for (int i = 2; i <= size; i++)
　　{
　　　　cout << "请输入第" << i << "项的系数:";
　　　　cin >> x;
　　　　cout << "请输入第" << i << "项的指数:";
　　　　cin >> y;
　　　　Node<DataType> *n;
　　　　n = new Node<DataType>;
　　　　n->coef = x;
　　　　n->exp = y;
　　　　n->next = NULL;
　　　　m->next = n;
　　　　m = n;
　　}
}

//实现一元多项式单链表实的输出
template<class DataType>
void Linklist<DataType>::Print()
{
　　Node<DataType> *m = first;
　　while (m != NULL)
　　{
　　　　if (m == first)
　　　　{
　　　　　　if (m->coef != 0 && m->exp != 0)
　　　　　　{
　　　　　　　　cout << m->coef << "x^" << m->exp;
　　　　　　}
　　　　　　else if (m->coef != 0 && m->exp == 0)
　　　　　　{
　　　　　　　　cout << m->coef;
　　　　　　}
　　　　}
　　　　else
　　　　{
　　　　　　if (m->coef > 0 && m->exp != 0){
　　　　　　　　cout << "+" << m->coef << "x^" << m->exp;
　　　　　　}
　　　　　　else if (m->coef<0 && m->exp != 0)
　　　　　　{
　　　　　　　　cout << m->coef << "x^" << m->exp;
　　　　　　}
　　　　　　else if (m->coef>0 && m->exp == 0)
　　　　　　{
　　　　　　　　　cout << "+" << m->coef;
　　　　　　}
　　　　　　else if (m->coef < 0 && m->exp == 0)
　　　　　　{
　　　　　　　　cout << m->coef;
　　　　　　}
　　　　}
　　　　m = m->next;
　　}
　　cout << endl;
}

//实现一元多项式单链表的相加
template<class DataType>
Linklist<DataType> Linklist<DataType>::operator+(Linklist &p2)
{
　　//声明工作指针
　　Node<DataType> *pre, *p, *qre, *q;
　　//初始化工作指针
　　pre = this->first;
　　p = pre->next;
　　qre = p2.first;
　　q = qre->next;
　　while (p != NULL&&q != NULL)
　　{
　　　　//p->exp < q->exp：指针 p 后移
　　　　if (p->exp < q->exp)
　　　　{
　　　　　　pre = p;
　　　　　　p = p->next;
　　　　}
　　　　//p->exp > q->exp：将结点 q 插到结点 p 之前，指针 p 指向他原指结点的下一个结点
　　　　if (p->exp > q->exp)
　　　　{
　　　　　　Node<DataType> *s;
　　　　　　s = q->next;
　　　　　　pre->next = q;
　　　　　　q->next = p;
　　　　　　q = s;
　　　　}
　　　　//p->exp == q->exp：
　　　　if (p->exp == q->exp)
　　　　{
　　　　　　//p->coef = p->coef + q->coef
　　　　　　p->coef = p->coef + q->coef;
　　　　　　if (p->coef == 0)
　　　　　　{
　　　　　　　　//使指针 p 指向它原指结点的下一个结点
　　　　　　　　pre->next = p->next;
　　　　　　　　//删除结点 p
　　　　　　　　delete p;
　　　　　　　　p = p->next;
　　　　　　}
　　　　　　else
　　　　　　{
　　　　　　　　pre = p;
　　　　　　　　p = pre->next;
　　　　　　}
　　　　　　//使指针 q 指向它原指结点的下一个结点
　　　　　　qre->next = q->next;
　　　　　　//删除结点 q
　　　　　　delete q;
　　　　　　q = qre->next;
　　　　}
　　}
　　//如果 q 不为空，将结点 q 链接在第一个单链表的后面。
　　if (q != NULL)
　　{
　　　　pre->next = q;
　　　　delete p2.first;
　　}
　　return *this;
}

二、测试一元多项式单链表实现的源程序：TestPolynomialOfOneIndeterminateAdd.cpp

#include<iostream>
//引入一元多项式之单链表实现的头文件
#include "PolynomialOfOneIndeterminateAdd.h"
using namespace std;

int main()
{
　　//声明一元多项式单链表
　　Linklist<int> p1, p2, p3;
　　cout << "请按指数由小到大的顺序定义多项式A(x):" << endl;
　　p1.Init();
　　cout << "输入的多项式A(x)为:";
　　p1.Print();
　　cout << "\n请按指数由小到大的顺序定义多项式B(x):" << endl;
　　p2.Init();
　　cout << "输入的多项式B(x)为:";
　　p2.Print();
　　//一元多项式相加
　　p3 = p1 + p2;
　　cout << "\n多项式A(x)和多项式B(x)的和为:" << endl;
　　p3.Print();
　　return 0;
}

时间： 2024-07-31 18:13:16

单链表之一元多项式求和C++实现的相关文章

线性表之单链表实现一元多项式相加

一元多项式定义: 设a0,a1,a2,-,an-1,an都是数域F中的数(注:1,2,--,n-1,n均为a的下角标),n是非负整数,那么表达式 anx^n +an-1x^(n-1)+-+a2x^2 +a1x + a0(an≠0) (1) 叫做数域F上一个文字x的多项式或一元多项式.在多项式(1)中,a0叫做零次多项式或常数项,a1x叫做一次项,一般,aix叫做i次项,ai叫做i次项的系数.一元多项式用符号f(x),g(x),-来表示. 说一下思路,利用带有两个数据元素的链表实现加法运算,数据域

【c++版数据结构】之用带头节点的单链表实现一元多项式（C语言版）

所实现的一元多项式的结构如下图所示: 若只对多项式进行"求值"等不改变多项式系数和指数的运算,采用类似顺序表的顺序存储结构即可,否则应采用链式存储结构,本文因为要进行一元多项式的加法,加法,乘法,故采用的是链式存储结构 Polynomail.h #include<stdio.h> #include<assert.h> struct Node { int coef; //系数 int expn; //指数 }; //节点结构 typedef struct Poly

数据结构实践——链表：多项式求和

本文针对数据结构基础系列网络课程(2):线性表的实践项目. [项目 - 多项式求和] 用单链表存储一元多项式,并实现两个多项式的加法. 提示: 1.存储多项式的数据结构 多项式的通式是pn(x)=anxn+an?1xn?1+...+a1x+a0.n次多项式共有n+1项.直观地,可以定义一个数组来存储这n+1个系数.以多项式p(x)=?3.4x10?9.6x8+7.2x2+x为例,存储这个多项式的数组如下图: 可以看出,这种方案适合对某些多项式的处理.但是,在处理一些次数高但项数少的多项式时,存在

一元多项式的相加（单链表的应用）

一元多项式的相加,基于单链表的结构上实现的. 单链表的结点结构定义为: typedef struct _NODE{ int coef; int exp; struct _NODE *next;}NODE: 第一个变量指的是系数,第二个变量指的是指数,x^7系数为1,指数为7 第三个变量next指针,将结点连接起来. 比如a1 = x^5+x^4+x^2+3    a2 = x^7+x^4+x+8 a1+a2 = x^7+x^5+2x^4+x^2+x+11 list.h 里面包含了一些对单链表进行

算法练习2之单链表求和

笔试题目: 1.用单向链表表示十进制整数,求两个正整数的和.如下图,1234+34=1268, 注意:单向链表的方向,不允许使用其他的数据结构. 题目分析: 题目中提到了,数据结构只能使用单链表,所以数组不在考虑范围之内. 因为将数字转为单链表以后,最高位排在表头,而我们进行整数加法的时候,是从个位开始的,与单链表的顺序相反.所以我们考虑对链表进行反转,然后再做加法. 其中反转和求和的示意图如下: 对求和以后的结果再进行反转: 下面是C++的实现 代码解读 1.节点的数据结构定义如下: //节点

数据结构 C++ 单链表 一元多项式的相加

#include <iostream> using namespace std; struct Node { double coe; //系数 int exp; //指数 Node *next; }; void CreatPoly(Node *&head, int n) // 生成带表头结点的单链表,除头结点外另生成n个结点 { head = (Node *)new Node; head->coe = 0; head->exp = 0; head->next = NU

单链表实现多项式的表示及运算

单链表实现多项式的加法运算 最近学习数据结构的线性表,有顺序存储和链表两种,多项式的表示和运算,最能巩固学习成果,现在提供详细代码,来实现多项式的加法运算. 多项式用单链表最为合适,不会造成更多的资源浪费. 如果你恰好用的这本书--数据结构(Java版)(第4版)(叶核亚),推荐你去下面这个链接下载书本源代码,将更助你学的轻松. http://download.csdn.net/detail/wang______jing/9907538 1 //单链表类,实现一些基本单链表的操作 2 publi

链表实现多项式求和求积

#include <iostream> #include <cstdio> #include<cstdlib> using namespace std; struct Node { double coef; int expn; Node *next; }; void CreatPolynomial(Node *&head, int n) // 生成带表头结点的单链表,除头结点外另生成n个结点 { head = (Node *)malloc(sizeof(Node

《数据结构》2.6单链表应用举例

1 //单链表倒置(头插法,时间复杂度O(n)) 2 /*算法思路: 3 依次取出原链表中的每个节点,每次都将其作为第一个节点插入原链表中:由于采用头插法,插入顺序与取节点 4 顺序正好相反,故可以完成倒置操作. 5 */ 6 void reverseList(LinkList h) //reverse:背面.相反.颠倒 7 { 8 LNode *p; 9 p = h->next; //*p指向第一个数据元素节点 10 h->next = NULL; //将原链表置为空表 11 while(p