多项式类的复杂实现

#include<iostream>
#include <cstdlib>
#include <cmath>
using namespace std;

class CPolynominal

{
public:

struct Node
{
    double coef;
    int exp;
    Node * next;
    Node(double  a,int b,Node* c=NULL):coef(a),exp(b),next(c){};
};
CPolynominal(){ head=new Node(0,0,NULL); }
CPolynominal(const CPolynominal &rhs);//复制构造函数
CPolynominal(double a[],int b[],int n);
~CPolynominal();
Node* get(int exp);
void sortnode();
void insertnode(double coef,int exp);
void removenode(int exp);
void modifynode(double newcoef,int exp);
double atnode(int exp);

//赋值运算符重载
CPolynominal& operator = (const CPolynominal &rhs);
CPolynominal& operator +=(const CPolynominal &rhs);
CPolynominal& operator -=(const CPolynominal &rhs);
CPolynominal& operator *=(const CPolynominal &rhs);

friend CPolynominal operator +(const CPolynominal &rhs,const CPolynominal &lhs);//重载+运算符
friend CPolynominal operator -(const CPolynominal &rhs,const CPolynominal &lhs);//重载-运算符
friend CPolynominal operator *(const CPolynominal &rhs,const CPolynominal &lhs);//重载*运算符

double ans(double x);
void   display()const;

private:
  Node* head;
};
/*****************************/

ostream& operator<<(ostream& os, const CPolynominal& rhs);
/*********************************/

void CPolynominal::display()const
{
    Node* p=head->next;
    while(p)
    {
        cout<<p->coef<<"x"<<"^"<<p->exp<<" ";
            p=p->next;
    }
   cout<<endl;
}
void CPolynominal:: sortnode()//可能有问题
{
    Node* q,*p,*m;
    //q=head->next;
    p=head->next;
    head->next=NULL;

       while(p)
   {
               q=p;
               p=p->next;
               m=head;
            while((m->next!=NULL)&&(q->exp<m->next->exp))
                 {
                     m=m->next;

                 }
                 if((m->next!=NULL)&&(q->exp==m->next->exp))
                 {
                     m->next->coef+=q->coef;
                     continue;
                 }

               q->next=m->next;
               m->next=q;

    }


}





double CPolynominal::ans(double x)
{
    Node*q=head->next;
    double sum=0.0;
    while(q)
    {
        sum+=q->coef*pow(x,q->exp);
        q=q->next;
    }

    return sum;
}
/******************************************/
CPolynominal:: ~CPolynominal()
{
    Node*q,*p;
    p=head->next;
    while(p)
    {
        q=p->next;
        if(p) delete p;
        p=q;
    }

}
CPolynominal:: CPolynominal(const CPolynominal &rhs)
{
    head=new Node(0,0,NULL);
    Node*q=head;
    for(Node*pt=rhs.head->next;pt;pt=pt->next)
    {
        q->next=new Node(pt->coef,pt->exp,NULL);
        q=q->next;
    }

}
/*******************************************************/
 CPolynominal:: CPolynominal (double a[],int b[],int n)
{
    head=new Node(0,0,NULL);
    Node* q=head;
    for(int i=0;i<n;i++)
    {
        q->next=new Node(a[i],b[i],NULL);
        q=q->next;
    }

}

 CPolynominal:: Node* CPolynominal::get(int exp)
{
    Node*q=head->next;
    while(q)
    {
        if(q->exp==exp)
        {
            return q;
        }
        q=q->next;
    }
    return q;
    //cout<<"ERROR"<<endl;


}
/***********************************/
void CPolynominal:: insertnode(double coef,int exp)
{
    Node*p=head;
    Node*q=p->next;
    Node*r=new Node(coef,exp,NULL);
   if(q==NULL)
     head->next=r;
   else
    {while(q)
     {
        if(exp>q->exp)
        {
            p->next=r;
            r->next=q;
            break;
        }
        if(exp==q->exp)
        {
            q->coef+=coef;
            break;
        }
        p=q;
        q=q->next;
     }
    }
}
void CPolynominal:: removenode(int exp)
{   Node*p=head;
    Node*q=p->next;
    int flag=1;
    while(q)
    {
        if(q->exp==exp)
        {
        p->next=q->next;
        delete q;
        flag=0;
        break;
        }
        p=q;
        q=q->next;
    }
    if(flag==1)
        cout<<"FIND ERROE"<<endl;

}
void CPolynominal:: modifynode(double newcoef,int exp)
{
    Node*q=head->next;
    int flag=1;
    while(q)
    {
        if(q->exp==exp)
        {
            q->coef=newcoef;
            flag=0;
            break;
        }
        q=q->next;
    }
    if(flag==1)
        cout<<"FIND ERROE"<<endl;

}
double CPolynominal:: atnode(int exp)
{
    Node*q=head->next;

    while(q)
    {
        if(q->exp==exp)
        {
            return q->coef;
        }
        q=q->next;

    }
    cout<<"FIND ERROR"<<endl;
}

/********************************************/
   CPolynominal  operator +(const CPolynominal &rhs,const  CPolynominal &lhs)
{
   CPolynominal rhs2(rhs);
   CPolynominal lhs2(lhs);
   CPolynominal:: Node*r,*q,*p;
    q=rhs2.head->next;p=lhs2.head->next;
    CPolynominal temp;
    r=temp.head;
    while(q&&p)
    {
           if(q->exp<p->exp)
           {r->next=p; r=p; p=p->next;}
          else if(q->exp==p->exp)
           {r->next=new CPolynominal:: Node(q->coef+p->coef,q->exp);r=r->next;p=p->next;}
          else if(q->exp>p->exp)
           {r->next=q; r=q; q=q->next;}
    }
     r->next=q?q:p;

     return temp;


}
 CPolynominal operator -(const CPolynominal &rhs,const  CPolynominal &lhs)//重载-运算符
 {
    CPolynominal temp1(lhs);
    CPolynominal temp2(rhs);
   CPolynominal:: Node* q=temp1.head->next;
   while(q)
   {
       q->coef=-q->coef;
       q=q->next;

   }

    temp2=temp2+temp1;
    return temp2;
 }
  CPolynominal operator *(const  CPolynominal &rhs,const CPolynominal &lhs)//有点问题
 {

      CPolynominal temp;
      CPolynominal:: Node *rcur,*lcur,*s;
      int e;
      double c;
      rcur=rhs.head->next;
      while (rcur)
      {
         lcur=lhs.head->next;
         while (lcur)
               {
               c=rcur->coef*lcur->coef;
               e=rcur->exp+lcur->exp;
               s=temp.get(e);//查temp中有无指数为e的项
               if (temp.head&&s)//temp中无指数为e的项
               s->coef+=c;
               else//temp中无指数为e的项
               temp.insertnode(c,e);
               lcur=lcur->next;
               }
        rcur=rcur->next;
       }
    return temp;


 }
 ostream& operator<<(ostream& os, const CPolynominal& rhs)
 {
    rhs.display();
    return os;
 }
 /*************************************/
CPolynominal& CPolynominal::operator = (const CPolynominal &rhs)
{
   Node*p=head;

  for(Node*q=rhs.head->next;q;q=q->next)
  {
      p->next=new Node(q->coef,q->exp,NULL);
      p=p->next;
  }

   return *this;
}
CPolynominal& CPolynominal:: operator +=(const CPolynominal &rhs)
{

 *this=*this+rhs;
  return *this;
}
/*CPolynominal& CPolynominal:: operator -=(const CPolynominal &rhs)
{

 *this=*this-rhs;

}*/
CPolynominal& CPolynominal:: operator *=(const CPolynominal&rhs)
{

 *this=*this*rhs;
  return *this;
}

int main()

{

    int    e1[5]={5,6,3,2,1};
    double c1[5]={1,2,3,4,5};
    int    e2[4]={6,7,8,9};
    double c2[4]={9,8,7,6};
    CPolynominal p1(c1,e1,5);
    CPolynominal p2(c2,e2,4);
    CPolynominal p3(p2);
    CPolynominal p4;
    p1.display();
    p2.display();
    p4=p1*p2;
    p1.display();
    p2.display();

    cout<<p4;
    //p1.sortnode();
    //p2.sortnode();
    //p1.sortnode();
   // p1.sortnode();
    /*p2.sortnode();
    p1.display();
    p2.display();
    CPolynominal p4=p1+p2;
    p4.display();
    p4.sortnode();
    p4.display();
    cout<<p4<<endl;*/
   // p4.display();
   /* p2.display();
    p3.display();
    p1.insertnode(7,8);
    p1.display();
    double i=p2.atnode(9);
    cout<<i<<endl;
    p3.modifynode(7,9);
    p3.display();
    CPolynominal p4;
    p4=p1;
    p4.display();*/
    return 0;


}