多项式及其运算(用单链表表示)

#ifndef POLYNOMAL_H

#define POLYNOMAL_H

 

#include <iostream>

#include <cmath>

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指针指示的项(即调用此函数的对象)后面插入一个新的项

     template<class T>

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

};

 

class Polynomal

{

public:

     Polynomal()   //构建空链表

     {

         first = new Term(0,-1);

     }

     Polynomal(Polynomal& R);

     int maxOrder();    //计算最大阶数

     Term* GetHead()const   //取得多项式单链表的表头指针

     {

         return first;

     }

private:

     Term *first;

     friend ostream& operator<<(ostream&,const Polynomal&);

     friend istream& operator>>(istream&,Polynomal&);

     friend Polynomal operator+(Polynomal&,Polynomal&);

     friend Polynomal operator*(Polynomal&,Polynomal&);

};

 

Term* Term::InsertAfter(float c, int e)

{

     link = new Term(c,e,link);  //创建一个新结点，自动链接

     return link;  //插入到this结点后面

}

 

ostream& operator<<(ostream& out,const Term& x)

{

     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;

}

 

Polynomal::Polynomal(Polynomal& R)

{

     first = new Term(0,-1);

     Term *destptr = first,*srcptr = R.GetHead()->link;

     while (srcptr != NULL)

     {

         //在destptr所指结点后插入新结点，再让destptr指到这个新结点

         destptr->InsertAfter(srcptr->coef,srcptr->exp);

         srcptr = srcptr->link;

         destptr = destptr->link;

     }

}

 

//计算最大阶数，当多项式按升序排列时，最后一项中是指数最大者

int Polynomal::maxOrder()

{

     Term *current = first;

     while (current->link != NULL)

         current = current->link;

     return current->exp;

}

 

//从输入流in输入各项，用尾插法建立一个多项式

istream& operator>>(istream& in,Polynomal& x)

{

     Term *rear = x.GetHead();   //rear是尾指针

     float c; //c是系数

     int e;   //e是指数

     while (1)

     {

         cout<<"Input a term(coef,exp):"<<endl;

         in>>c>>e;

         if(e<0)

              break;

         rear = rear->InsertAfter(c,e);   //连接到rear所指结点后

     }

     return in;

}

 

//输出带附加头结点的多项式链表x

ostream& operator<<(ostream& out,Polynomal& 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;

}

 

Polynomal operator+(Polynomal& A,Polynomal& B)

{

     Term *pa,*pb,*pc,*p;   //pc为结果多项式的尾指针,p指示剩余链的地址

     float temp;

     Polynomal C;

     pc = C.first;

     pa = A.GetHead()->link; //pa和pb定位于A与B的第一个结点，是两链的检测指针

     pb = B.GetHead()->link;

     while (pa != NULL && pb != NULL)

     {

         if (pa->exp == pb->exp) //对应项指数相等

         {

              temp = pa->coef + pb->coef; //系数相加

              if(fabs(temp) > 1e-6)  //相加后系数不为

                   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 //pb系数小

         {

              pc = pc->InsertAfter(pb->coef,pb->exp);

              pb = pb->link;

         }

     }

     if(pa != NULL)

         p = pa;

     else

         p = pb;

     while (p != NULL)

     {

         pc = pc->InsertAfter(p->coef,p->exp);

         p = p->link;

     }

     return C;

}

 

Polynomal operator*(Polynomal& A,Polynomal& B)

{

     Term *pa,*pb,*pc;

     int AL,BL,i,k,maxExp;

     Polynomal 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; //多项式A的检测指针

         while (pa != NULL)

         {

              pb = B.GetHead()->link; //多项式B的检测指针

              while (pb != NULL)

              {

                   k = pa->exp + pb->exp; //乘积的指数

                   result[k] = result[k] + pa->coef*pb->coef;

                   pb = pb->link;

              }

              pa = pa->link;

         }

         for(i=0;i<=maxExp;++i)

              if(fabs(result[i]) > 1e-1)

                   pc = pc->InsertAfter(result[i],i);

         delete []result;

     }

     pc->link = NULL;

     return C;

}

 

#endif