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

#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;
}