以循环链表表示的多项式类

#include<iostream>
using namespace std;
//定义结点类型
struct node
{
    int exp;                                //指针为整形
    double coef;                            //系数为双精度型
    node *next;                             //指针域
};
//多项式循环链表类
class Poly
{
private:                                    //数据成员
    node *head;                             //循环链表头指针
public:                                     //成员函数
    Poly();                                 //构造函数，建立空多项式链表
    void in1_Poly();                        //由键盘输入多项式链表
    void in2_Poly(int,int [],double []);    //由数组复制多项式链表
    void del_Poly();                        //释放多项式链表
    void prt_Poly();                        //输出多项式链表
    Poly operator + (Poly &);               //多项式相加
    Poly operator * (Poly &);               //多项式相乘
};
//构造函数，建立空多项式链表
Poly::Poly()
{
    node *p;
    p=new node;                             //申请一个表头结点
    p->exp=-1;                              //指针域值为-1
    p->next=p;                              //指针域指向表头结点自身
    head=p;                                 //头指针也指向表头结点
    return;
}
//键盘输入多项式链表
void Poly::in1_Poly()
{
    node *p,*k;
    int e;
    double c;
    k=head;                                 //记住多项式链尾
    cout<<"输入：系数<空格>指数。输入指数-1 结束！"<<endl;
    cin>>c>>e;
    while (e>=0)
    {
        p=new node;                         //申请一个新结点
        p->exp=e;                           //填入指数与系数
        p->coef=c;
        p->next=head;                       //新结点链到临时多项式链尾
        k->next=p;
        k=p;                                //记住多项式链尾
        cin>>c>>e;
    }
    return;
} 
//由数组复制多项式链表
void Poly::in2_Poly(int n,int e[],double c[])
{
    int k;
    node *p;
    for (k=n-1;k>=0;k--)
    {
        p=new node;                         //申请一个新结点1
        p->coef=c[k];                       //置系数与指数域
        p->exp=e[k];
        p->next=head->next;                 //新结点链到表头
        head->next=p;
    }
    return;
}
//释放多项式链表
void Poly::del_Poly()
{
    node *p,*q;
    q=head->next;
    while (q!=head)
    {
        p=q->next;
        delete q;
        q=p;
    }
    q->next=head;
    return;
}
//输出多项式链表
void Poly::prt_Poly()
{
    node *k;
    if(head->next==head)
        cout<<"空表"<<endl;
    k=head->next;
    while (k!=head)
    {
        cout<<"("<<k->coef<<","<<k->exp<<")"<<endl;
        k=k->next;
    }
    return;
}
//多项式相加
Poly Poly::operator+(Poly &p2)
{
    Poly p;
    node *k,*q,*m,*n;
    int e;
    double c;
    k=p.head;                               //记住和多项式链尾
    m=head->next;
    n=p2.head->next;
    while ((m->exp!=-1)||(n->exp!=-1))
    {
        if (m->exp==n->exp)                 //两个链表当前结点的指数相等
        {
            c=m->coef+n->coef;              //系数相加
            e=m->exp;                       //复抄指数
            m=m->next;              
            n=n->next;
        }
        else if (m->exp>n->exp)
        {
            c=m->coef;                      //复抄链表 1 中的1系数与指数值
            e=m->exp;
            m=m->next;
        }
        else
        {
            c=n->coef;                      //复抄链表 2 中的系数与指数值
            e=n->exp;
            n=n->next;
        }
        if(c!=0)                            //相加后系数不为0
        {
            q=new node;                     //申请一个新结点
            q->exp=e;
            q->coef=c;
            q->next=p.head;
            k->next=q;
            k=q;                            //记住和多项式的链尾
        }
    }
    return(p);
}
//多项式相乘
Poly Poly::operator*(Poly &p2)
{
    Poly p,p1,p3;                           //p、p1与p3为临时多项式
    node *q,*k,*m,*n;
    m=head->next;
    while (m->exp!=-1)
    {
        p3=p;
        k=p1.head;                          //记住临时多项式p1链尾
        n=p2.head->next;
        while (n->exp!=-1)
        {
            q=new node;                     //申请一个新结点
            q->exp=m->exp+n->exp;           //置新结点指数值
            q->coef=(m->coef)*(n->coef);    //置新结点系数值
            q->next=p1.head;                //新结点链到临时多项式p1链尾
            k->next=q;
            n=n->next;
            k=q;
        }
        p=p3+p1;                            //累加
        p1.del_Poly();                      //释放临时多项式p1
        p3.del_Poly();                      //释放临时多项式p3
        m=m->next;
    }
    return(p);
}