单链表的应用：多项式及其运算（代码来自课本）

#ifndef POLYNOMAL_H
#define POLYNOMAL_H
#include
using namespace std;
//多项式结点的定义
struct Term {
float coef;//系数
int exp;//指数
Term* link;//链指针
Term(float c, int e, Term* next = NULL)//初始化
{
coef = c;
exp = e;
link = next;
}
Term* InsertAfter(float c, int e);//在当前由this指针指示的项后面插入一个新项

friend ostream& operator<<(ostream&, const Term&);
};

//多项式类的定义
class Polynomial
{
public:
Polynomial()//构造函数，建立空链表
{
first = new Term(0, -1);//头指针为link=next(默认)=NULL
}
Polynomial(Polynomial& R);//复制构造函数
int maxOrder();//计算最大阶数
Term* getHead()const { return first; }//取得多项式单链表的表头指针
friend ostream& operator<<(ostream&out,const Term& x)//输出运算符重载函数的第一个形参必须是ostream或istream类型，而成员函数的第一个形参是默认的（即this指针）
{ //Term的友元函数：输出一个项x的内容到输出流out中。
if (x.coef == 0.0)
return out;
out << x.coef;
switch (x.exp)
{
case 0:break;
case 1:out << “X”; break;
default:out << “X^” << x.exp;
break;
}
return out;
}
private:
Term * first;//头指针getHead()获得
friend ostream& operator<<(ostream&, const Polynomial&);
friend istream& operator>>(istream&, Polynomial&);
friend Polynomial operator +(Polynomial&, Polynomial&);
friend Polynomial operator *(Polynomial&, Polynomial&);
};

//在当前由this指针指示的项后面插入一个新项
Term* Term::InsertAfter(float c, int e)
{
link= new Term(c, e, link);//创建一个新结点，自动链接
return link;//插入到this当前结点后面
}

//复制构造函数：用已有多项式对象R初始化当前多项式对象R。
Polynomial::Polynomial(Polynomial &R)
{
first = new Term(0, -1);//用结点类构造函数初始化头指针NULL，建立一个空链表
Term *destptr = first, srcptr = R.getHead()->link;
while (srcptr != NULL)
{
destptr->InsertAfter(srcptr->coef, srcptr->exp);
//在destptr所指结点后插入新结点，再让destptr指到这个新结点
srcptr = srcptr->link;
destptr = destptr->link;
}
}
//计算最大阶数，当多项式按升序排列时，最后一项中是指数最大者
int Polynomial::maxOrder()
{
Term current = first;
while (current->link != NULL)
current = current->link;
//空表情形，current停留在first,否则current停留在表尾结点。
return current->exp;//最大指数
}

// Polynomal类的友元函数：从输入流In输入各项，用尾插法建立一个多项式。
istream& operator>>(istream& in, Polynomial& x)
{
Term* rear = x.getHead();//rear是尾指针
float c;
int e;
while (1)
{
cout << “input a term(coef,exp):” << endl;
in >> c >> e; //输入项的系数c和指数e
if (e<0) break; //用e<0控制输入结束
rear = rear->InsertAfter(c, e);//链接到rear所指结点后
}
return in;
}

//Polynomal类的友元函数：输出带附加头结点的多项式链表x.
ostream&operator<<(ostream&out, Polynomial&x)
{
Term*current = x.getHead()->link;
cout << “the polynomal is:” << endl;
bool h = true;
while (current != NULL)
{
if (h == false && current->coef>0.0)
out << “+”;
h = false;
out << *current;//调用Term类的重载输出函数
current = current->link;
}
out << endl;
return out;
}

//两个多项式相加的计算
Polynomial operator+(Polynomial& A, Polynomial& B)
{
Term* pa, *pb, *pc, *p;//创建结点
float temp;
Polynomial C;
pc = C.first;//初始链表的头指针
pa = A.getHead()->link;//多项式的第一个结点即第一项
pb = B.getHead()->link;
while (pa != NULL && pb != NULL)
{
if (pa->exp == pb->exp)
{
temp = pa->coef + pb->coef;
if (fabs(temp) > 0.001)
pc = pc->InsertAfter(temp, pa->exp);
pa = pa->link; pb = pb->link;
}
else if (pa->exp < pb->exp)//pa指数小
{
pc = pc->InsertAfter(pa->coef, pa->exp);
pa = pa->link;
}
else
{
pc = pc->InsertAfter(pb->coef, pb->exp);
pb = pb->link;
}
}
if (pa != NULL)//p显示剩余链的地址
p = pa;
else p = pb;
while (p != NULL)//处理剩余链部分
{
pc = pc->InsertAfter(p->coef, p->exp);
p = p->link;
}
return C;
}

//两个多项式相乘的计算
//将一元多项式A和B相乘，乘积用带附带头结点的单链表存储，返回值为指向存储乘积多项式的
Polynomial operator *(Polynomial&A, Polynomial&B)
{
//单链表的头指针
Term *pa, pb, pc;
int AL, BL, i, k, maxExp;
Polynomial C;//结果多项式
pc = C.getHead();
AL = A.maxOrder();
BL = B.maxOrder();//两个多项式的阶数
if (AL != -1 || BL != -1)
{
maxExp = AL + BL;
float result = new float[maxExp + 1];
for (i = 0; i <= maxExp; i++) { result[i] = 0.0; }
pa = A.getHead()->link;
while (pa != NULL)
{
pb = B.getHead();
while (pb != NULL)
{
k = pa->exp + pb->exp;
result[k] = result[k] + pa->coefpb->coef;
pb = pb->link;
}
pa = pa->link;
}
for (i = 0; i <= maxExp; i++)
{
if (fabs(result[i]) > 0.001)
pc = pc->InsertAfter(result[i], i);
delete[] result;
}
}
pc->link = NULL;
return C;
}
#endif

//测试：
#include
#include"Polynomal.h"
using namespace std;
int main()
{
Polynomial A, B,C,D;
cin >> A >> B;
C = A + B;
D= A * B;
cout << C << endl;
cout << D << endl;
system(“pause”);
return 0;
}