【无浪】一元多项式的表示及相加

#include<iostream>
using namespace std;

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

#define ElemType int

typedef int Status;

typedef struct LNode{//结点类型
float coef;
int expn;
struct LNode *next;
int use_condition;  //使用情况0为未使用1为使用,用于避免二次插入造成死循环
}*Link,*Position;

typedef struct{   //链表类型
Link head,tail;   //分别指向线性链表中的头结点和最后一个结点
int len;          //指示线性链表中数据元素的个数
}polynomai;

class LinkList_Sq{
protected:
LNode *pS;
public:
Status MakeNode(Link& p,ElemType e,ElemType e1); //分配由p指向的值为e的结点，并返回OK；若分配失败，则返回ERROR
void FreeNode(Link &p); //释放p所指结点
Status InitList(polynomai &L);//构造一个空的线性链表L,链表L的头结点和尾结点赋值为-1
Status Delete(polynomai &P,Link& p);     //删除指定结点
Status CreatPolyn(polynomai &P,Link& p);  //通过MakeNode()创造结点后用此函数将结点插进指定的多项式链表中
Status DestroyPolyn(polynomai &P);  //销毁多项式链表
Status PrintPolyn(polynomai &P);  //输出函数
int PolynLength(polynomai &P);     //返回链表长度
Status AddPolyn(polynomai &Pa,polynomai &Pb,polynomai &Pc);  //多项式相加
Status SubtractPolyn(polynomai &Pa,polynomai &Pb,polynomai &Pc);//多项式相减
Status MultiplyPolyn(polynomai &Pa,polynomai &Pb,polynomai &Pc);//多项式相乘
Status ClearPolyn(polynomai &P);  //清空多项式链表
};

Status LinkList_Sq::MakeNode(Link& p,ElemType e,ElemType e1) //分配由p指向的值为e的结点，并返回OK；若分配失败，则返回ERROR
{
p=new LNode;        //为p进行存储分配
if(!p)exit(OVERFLOW);//存储分配失败
p->coef=e;            //结点赋值
p->expn=e1;
if(p->coef==0){return FALSE;}     //系数为0不建立结点
if(p->coef==e&&p->expn==e1)
{
p->next=NULL;           // next赋值为NULL
p->use_condition=0;    //结点已经赋值，可以使用,赋值为0
return OK;
}
else return ERROR;  //判断赋值是否成功
}
void LinkList_Sq::FreeNode(Link &p) //释放p所指结点
{
free(p);
}
Status LinkList_Sq::InitList(polynomai &L)//构造一个空的线性链表L,链表L的头结点和尾结点赋值为-1
{
cout<<"初始化链表..."<<endl;
L.head=NULL;
L.tail=NULL;

pS=new LNode;		         //创造头结点
MakeNode(pS,0,0);	//头结点赋值为0
//pS,head两个指针指向头结点
L.head=pS;

pS=new LNode;              //创造尾结点
MakeNode(pS,0,0);   //尾结点赋值为0
//pS,tail两个指针指向尾结点
L.tail=pS;

//连接头结点和尾结点
L.head->next=L.tail;
//链长为零
L.len=0;
return OK;
}
Status LinkList_Sq::Delete(polynomai &P,Link& p)
{
LNode *ps=P.head;
while(ps->next!=p)  //遍历直到p前一个结点
{
ps=ps->next;
}
ps->next=ps->next->next;
P.len--;
return OK;
}
Status LinkList_Sq::CreatPolyn(polynomai &P,Link& p)  //通过MakeNode()创造结点后用此函数将结点插进指定的多项式链表中
{
if(!(p->coef)||p->use_condition==1)return ERROR;  //系数为0则无需加入
if(P.len==0)                 //长度为0的时候
{
P.head->next=p;          //head->p->tail
p->next=P.tail;
p->use_condition=1;      //标记已使用
P.len++;
return OK;
}
else
{
LNode *ps,*pN;
ps=P.head;
pN=ps->next;
//比较指数大小来进行移位，一种情况是多项式内没有相同指数的插在前面，另一种情况是多项式内有相同指数的直接系数相加。
while((ps->next->expn <= p->expn) && (ps->next->coef!=0))
{
ps=ps->next;
pN=ps->next;
}
if(ps->expn == p->expn)   //有相同指数项的情况
{
ps->coef+=p->coef;
if(!ps->coef)          //如果系数为0则删除该结点。
{
Delete(P,ps);      //删除该结点
return OK;
}
p->use_condition=1;
return OK;
}
else
{
//p插在ps和pN之间
ps->next=p;
p->next=pN;
P.len++;
return OK;
}
}
}
Status LinkList_Sq::DestroyPolyn(polynomai &P)  //销毁多项式链表
{
if(P.head->coef!=0||P.tail->coef!=0)return ERROR;
cout<<"销毁多项式..."<<endl;
LNode *ps,*pN;
ps=P.head;
pN=P.head->next;
while(pN->coef)            //pN一直在ps后驱，循环直到pN指向tail，ps指向tail前一个结点
{
delete ps;
ps=pN;
pN=pN->next;
}
delete ps;
delete pN;
return OK;
}
Status LinkList_Sq::PrintPolyn(polynomai &P)  //输出函数
{
if(P.head->coef!=0||P.tail->coef!=0)return ERROR;
cout<<"输出多项式"<<endl;
LNode *ps;
ps=P.head->next;
while(ps->coef)            //由于在给链表插入值的时候就避免插入系数为0的值，所以这里可以直接循环到链尾，尾结点为0
{
if(ps->coef>0)cout<<ps->coef;   //正数直接输出，负数加括号
else cout<<"("<<ps->coef<<")";

if(ps->expn)cout<<"x^";    //如果指数不为0则输出x^

if(ps->expn>0)cout<<ps->expn;      //正数直接输出，负数加括号
else if(ps->expn<0) cout<<"("<<ps->expn<<")";

if(ps->next->coef)cout<<" + ";    //下一个结点是尾结点0就不输出+号
ps=ps->next;
}
cout<<endl;
return OK;
}
int LinkList_Sq::PolynLength(polynomai &P)
{
cout<<"返回多项式项数..."<<endl;
return P.len;
}
Status LinkList_Sq::AddPolyn(polynomai &Pa,polynomai &Pb,polynomai &Pc)
{
cout<<"多项式相加..."<<endl;
LNode *pa,*pb;
Link e1;
pa=Pa.head->next;
pb=Pb.head->next;
while(pa->coef)
{
MakeNode(e1,pa->coef,pa->expn);
CreatPolyn(Pc,e1);
pa=pa->next;
}
while(pb->coef)
{
MakeNode(e1,pb->coef,pb->expn);
CreatPolyn(Pc,e1);
pb=pb->next;
}
return OK;
}
Status LinkList_Sq::SubtractPolyn(polynomai &Pa,polynomai &Pb,polynomai &Pc)
{
cout<<"多项式相减..."<<endl;
LNode *pa,*pb;
Link e1;
pa=Pa.head->next;
pb=Pb.head->next;
//相减跟相加不同的是MakeNode()创造结点时赋的值不同
while(pa->coef)
{
MakeNode(e1,pa->coef,pa->expn);
CreatPolyn(Pc,e1);
pa=pa->next;
}
while(pb->coef)
{
MakeNode(e1,-pb->coef,pb->expn);
CreatPolyn(Pc,e1);
pb=pb->next;
}
return OK;
}
Status LinkList_Sq::MultiplyPolyn(polynomai &Pa,polynomai &Pb,polynomai &Pc)
{
cout<<"多项式相乘..."<<endl;
LNode *pa,*pb;
Link e1;
pa=Pa.head->next;
pb=Pb.head->next;
while(pa->coef)
{
while(pb->coef)
{
MakeNode(e1,pa->coef * pb->coef,pa->expn + pb->expn);
CreatPolyn(Pc,e1);
pb=pb->next;
}
pa=pa->next;
pb=Pb.head->next;
}
return OK;
}
Status LinkList_Sq::ClearPolyn(polynomai &P)
{
cout<<"清空链表..."<<endl;
while(P.head->next->coef)
{
Delete(P,P.head->next);
}
return OK;
}

int main()
{
polynomai poly,poly1,poly2;
LinkList_Sq L;
Link e;
//链表初始化
L.InitList(poly);
L.InitList(poly1);
L.InitList(poly2);
cout<<endl;
//建立(-1)x^(-1) + 2 + 1x^1
L.MakeNode(e,-1,-1);
L.CreatPolyn(poly,e);
L.MakeNode(e,1,1);
L.CreatPolyn(poly,e);
L.MakeNode(e,2,0);
L.CreatPolyn(poly,e);
L.MakeNode(e,0,2);
L.CreatPolyn(poly,e);
L.PrintPolyn(poly);
//建立2x^(-1) + (-3) + 3x^1 + (-3)x^7
L.MakeNode(e,2,-1);
L.CreatPolyn(poly1,e);
L.MakeNode(e,3,1);
L.CreatPolyn(poly1,e);
L.MakeNode(e,-3,0);
L.CreatPolyn(poly1,e);
L.MakeNode(e,-3,7);
L.CreatPolyn(poly1,e);
L.PrintPolyn(poly1);
//多项式相加
cout<<endl;
L.AddPolyn(poly,poly1,poly2);
cout<<endl;
L.PrintPolyn(poly2);
L.ClearPolyn(poly2);
//多项式相减
cout<<endl;
L.SubtractPolyn(poly,poly1,poly2);
cout<<endl;
L.PrintPolyn(poly2);
L.ClearPolyn(poly2);
//多项式相乘
cout<<endl;
L.MultiplyPolyn(poly,poly1,poly2);
cout<<endl;
L.PrintPolyn(poly2);
//输出链长
cout<<L.PolynLength(poly2)<<endl;
return OK;
}