一元多项式的基本操作

#include<iostream>
#include"LinkList.h"
#define NUM 4
using namespace std;

class Polynomial{
public:
	//输入m项的系数和指数，建立表示一元多项式的有序链表P
	void CreatePolyn(polynomial &P,int m);
	//销毁一元多项式
	void DestroyPolyn(polynomial P);
	//打印输出一元多项式
	void PrintPolyn(polynomial P);
	//返回一元多项式P中的项数
	int PolynLength(polynomial P);
	//完成多项式相加运算，即：Pa=Pa+Pb，并销毁一元多项式Pb
	void AddPolyn(polynomial &Pa,polynomial &Pb);
	//完成多项式相减运算，即：Pa=Pa-Pb，并销毁一元多项式Pb
	void SubtractPolyn(polynomial &Pa,polynomial &Pb);
	//完成多项式相乘运算，即：Pa=Pa*Pb，并销毁一元多项式Pb
	void MultiplyPolyn(polynomial &Pa,polynomial &Pb);
};

void Polynomial::CreatePolyn(polynomial &P,int m)
{
	Link h,s,q;
	ElemType e;
	Status (*cmp)(ElemType,ElemType);
	cmp=compare;
	//输入m项的系数和指数，建立表示一元多项式的有序链表P
	LOP.InitList(P);
	h=LOP.GetHead(P);
	//q=LOP.NextPos(P,h);
	e.coef=0;e.expn=-1;LOP.SetCurElem(h,e);//设置头结点的数据元素
	cout<<"数据输入形式：系数（浮点数） 指数（整数）："<<endl;
	for(int i=0;i<m;i++)//依次输入m个非零项
	{
		cin>>e.coef>>e.expn;
		cout<<endl;
		if(!LOP.LocateElem(P,q,e,cmp))//当前链表中不存在该指数项
		{
			
			if(LOP.MakeNode(s,e)) //生成结点并插入链表
			{
					LOP.InsFirst(P,h,s);
					h=LOP.NextPos(P,h);
			}

		}
	}
}//CreatePolyn

void Polynomial::DestroyPolyn(polynomial P)
{
	cout<<LOP.DestroyList(P)<<endl;
}//DestroyPolyn

void Polynomial::PrintPolyn(polynomial P)
{
	Status (*vis)(ElemType);
	vis=visit;
	LOP.ListTraverse(P,vis);
}

int Polynomial::PolynLength(polynomial P)
{
	return LOP.ListLength(P);
}

void Polynomial::AddPolyn(polynomial &Pa,polynomial &Pb)
{
	ElemType sum;
	Link ha=LOP.GetHead(Pa),hb=LOP.GetHead(Pb);//ha和hb分别指向Pa和Pb的头结点
	Link qa=LOP.NextPos(Pa,ha),qb=LOP.NextPos(Pb,hb);//qa和qb分别指向Pa和Pb的当前结点
	while(!LOP.ListEmpty(Pa)&&!LOP.ListEmpty(Pb))
	{
		if(qa==NULL)//Pa中的最后一个结点的指数仍比Pa中结点的指数小
			break;
		ElemType a=LOP.GetCurElem(qa),b=LOP.GetCurElem(qb);//a和b为两表中当前元素
		switch(compare(a,b))
		{
		case -1://多项式Pa中当前节点的指数值较小
			ha=qa;
			qa=LOP.NextPos(Pa,ha);//Pa中结点后移
			break;
		case 0://两者的指数值相等
			sum.coef=a.coef+b.coef;
			sum.expn=a.expn;
			if(sum.coef!=0.0)//修改多项式Pa中当前结点的系数值
			{
				LOP.SetCurElem(qa,sum);
				ha=qa;
			}
			else
			{
				LOP.DelFirst(Pa,ha,qa);//删除该结点
				LOP.FreeNode(qa);//释放结点
				qa=LOP.NextPos(Pa,ha);//Qa指向下一个结点
			}
			LOP.DelFirst(Pb,hb,qb);//也删除Pb中的结点
			LOP.FreeNode(qb);
			qb=LOP.NextPos(Pb,hb);
			break;
		case 1://多项式Pa中当前结点的指数值较大
			LOP.DelFirst(Pb,hb,qb);//将该结点从Pb中删除
			LOP.InsFirst(Pa,ha,qb);//将该结点插入到Pa中
			ha=LOP.NextPos(Pa,ha);//使头结点后移指向插入的结点
			qb=LOP.NextPos(Pb,hb);//qb指向下一个结点
			break;
		}//switch
	}//while
	if(!LOP.ListEmpty(Pb))
		LOP.Append(Pa,hb->next);
	LOP.FreeNode(hb);
}//AddPolyn

void Polynomial::SubtractPolyn(polynomial &Pa,polynomial &Pb)
{
	Link pt=Pb.head->next;
	while(pt)
	{
		pt->data.coef=0-pt->data.coef;
		pt=pt->next;
	}//while
	AddPolyn(Pa,Pb);
}//SubtractPolyn

void Polynomial::MultiplyPolyn(polynomial &Pa,polynomial &Pb)
{
	Link s,pa=Pa.head->next,pb=Pb.head->next,ha,hb;
	ElemType e;
	int Pa_len=Pa.len,Pb_len=Pb.len;
	polynomial PPa,PPb;
	LOP.InitList(PPa);
	ha=LOP.GetHead(PPa);
	ha->data.coef=0.0;ha->data.expn=-1;
	

	for(int i=1;i<=Pa_len;i++)//新建一个多项式PP，将Pa中的数据复制到PPa中
	{
		e.coef=pa->data.coef;e.expn=pa->data.expn;
		LOP.MakeNode(s,e);
		LOP.InsFirst(PPa,ha,s);
		ha=ha->next;
		pa=pa->next;
	}//for
	
	for(int i=1;i<=Pb_len;i++)
	{
		pa=PPa.head->next;
		LOP.InitList(PPb);//建立空的多项式PPb存放乘积结果
		hb=LOP.GetHead(PPb);
		hb->data.coef=0.0;hb->data.expn=-1;

		for(int j=1;j<=Pa_len;j++)//Pb中一个结点与PPa所有结点的乘积
		{
			e.coef=pa->data.coef*pb->data.coef;//当前结点的乘积
			e.expn=pa->data.expn+pb->data.expn;
			LOP.MakeNode(s,e);
			LOP.InsFirst(PPb,hb,s);//将乘积依次放置在构造的空链表PPb中
			hb=hb->next;
			pa=pa->next;//pa指向PPa中下一个结点
		}//for2
		AddPolyn(Pa,PPb);//完成多项式Pa与PPb相加，PPb被销毁
		LOP.DelFirst(Pb,Pb.head,pb);//删除已经参与乘积计算的Pb中的结点
		LOP.FreeNode(pb);//释放该结点
		pb=LOP.NextPos(Pb,Pb.head);//pb指向多项式中的下一个结点
	}//for1

	SubtractPolyn(Pa,PPa);//新的Pa多项式减去其中存在的原始的Pa多项式的值
	//DestroyPolyn(PPa);//销毁临时建立的多项式
}//MultiplyPolyn
void main()
{
	polynomial P,P1;
	Polynomial Polyn;
	Polyn.CreatePolyn(P,NUM);//建立多项式P
	Polyn.PrintPolyn(P);
	cout<<"P.len:"<<Polyn.PolynLength(P)<<endl;
	cout<<endl;

	Polyn.CreatePolyn(P1,NUM-1);//建立多项式P1
	Polyn.PrintPolyn(P1);
	cout<<"P1.len:"<<Polyn.PolynLength(P1)<<endl;
	cout<<endl;

	Polyn.MultiplyPolyn(P,P1);//多项式P和P1相乘，结果存放在P中
	Polyn.PrintPolyn(P);
	cout<<"P.len:"<<Polyn.PolynLength(P)<<endl;
}

注：#include“LinkList.h”为：

/*LinkList.h*/
#include<iostream>
#ifndef _LINKLIST_H_
#define _LINKLIST_H_
#include<iostream>
#define ok 1
#define error 0
using namespace std;

typedef int Status;
//typedef int ElemType;
typedef struct{
	float coef;
	int expn;
} term,ElemType;
typedef struct Lnode{
	ElemType data;
	Lnode	 *next;
} *Link,*Position;
typedef struct{
	Link head,tail;
	int len;
} LinkList;

typedef LinkList polynomial;

class ListOperation
{
public:
	//分配由p指向的值为e的结点，并返回ok；若分配失败，则返回error;
	Status MakeNode(Link &p,ElemType e);
	//释放p所指结点
	void FreeNode(Link &p);
	//构造一个空的线性链表L
	Status InitList(LinkList &L);
	//将线性链表重置为空表，并释放原链表的结点空间
	Status ClearList(LinkList &L);
	//销毁线性链表L，L不再存在
	Status DestroyList(LinkList &L);
	//已知h指向线性链表的头结点，将s所指结点插入在第一个结点之前
	Status InsFirst(LinkList &L,Link h,Link s);
	//已知h指向线性链表的头结点，删除链表中的第一个结点并以q返回
	Status DelFirst(LinkList &L,Link h,Link &q);
	//将指针s所指（彼此以指针相链）的一串结点链接在线性链表L的最后一个结点
	//之后，并改变链表的L的尾指针指向新的尾结点
	Status Append(LinkList &L,Link s);
	//删除线性链表L中的尾结点并以q返回，改变链表的L的尾指针指向新的尾结点
	Status Remove(LinkList &L,Link &q);
	//已知p指向线性链表L中的一个结点，将s所指结点插入在p所指结点之前
	//并修改指针p指向新插入的结点
	Status InsBefore(LinkList &L,Link &p,Link s);
	//已知p指向线性链表L中的一个结点，将s所指结点插入在p所指结点之后
	//并修改指针p指向新插入的结点
	Status InsAfter(LinkList &L,Link &p,Link s);
	//已知p指向线性链表L中一个结点，用e更新p所指结点中数据元素的值
	Status SetCurElem(Link &p,ElemType e);
	//已知p指向线性链表中一个结点，返回p所结点中数据元素的值
	ElemType GetCurElem(Link p);
	//若线性链表L为空表，则返回true，否则返回false
	bool ListEmpty(LinkList L);
	//返回线性链表L中元素个数
	int ListLength(LinkList L);
	//返回线性链表中头结点位置
	Position GetHead(LinkList L);
	//返回线性链表中最后一个结点的位置
	Position GetLast(LinkList L);
	//已知p指向线性链表L中的一个结点，返回p所指结点的直接前驱的位置
	//若无前驱，则返回NULL
	Position PriorPos(LinkList L,Link p);
	//已知p指向线性链表L中的一个结点，返回p所指结点的直接后继的位置
	//若无后继，则返回NULL
	Position NextPos(LinkList L,Link p);
	//返回p指向线性链表L中第i个结点的位置并返回ok，i值不合法时返回error
	Status LocatePos(LinkList L,int i,Link p);
	//返回线性链表L中第一个与e满足函数compare()判定关系的位置，
	//若不存在这样的元素则返回NULL,此处compare是指向函数的指针变量
	//Status compare(ElemType x,ElemType y);
	Status LocateElem(LinkList L,Link &q,ElemType e,Status(*compare)(ElemType ,ElemType));
	//依次对L的每个元素调用函数visit（）。一旦visit（）失败，则操作失败
	//Status visit(ElemType x);
	Status ListTraverse(LinkList L,Status(*visit)(ElemType));
} LOP;


Status ListOperation::MakeNode(Link &p,ElemType e)
{
	p=new Lnode;
	p->data=e;
	if(p)
		return ok;
	else
		return error;
}

void ListOperation::FreeNode(Link &p)
{
	delete p;
	p=NULL;
}

Status ListOperation::InitList(LinkList &L)
{
	L.head=new Lnode;
	L.head->next=NULL;
	L.tail=L.head;
	L.len=0;
	if(L.head)
	{
		//cout<<"线性链表初始化成功"<<endl;
		return ok;
	}	
	else
		return error;
}

Status ListOperation::ClearList(LinkList &L)
{
	Link p=L.head->next;
	while(p)
	{
		L.head->next=p->next;
		delete p;
		p=NULL;
		L.len--;
		p=L.head->next;
	}
	if(L.head->next==NULL)
	{
		//cout<<"线性链表重置为空"<<endl;
		return ok;
	}
	else
		return error;	
}

Status ListOperation::DestroyList(LinkList &L)
{
	ClearList(L);
	delete L.head;
	L.head=NULL;
	L.tail=NULL;
	if(!L.head)
		return ok;
	else
		return error;
}

Status ListOperation::InsFirst(LinkList &L,Link h,Link s)
{
	s->next=h->next;
	h->next=s;
	if(h==L.tail)
		L.tail=h->next;
	L.len++;
	return ok;

}

Status ListOperation::DelFirst(LinkList &L,Link h,Link &q)
{
	if(!L.head)
	{
		cout<<"线性链表不存在"<<endl;
		return error;
	}
	//q=h->next->next;
	q=h->next;
	if(h->next==L.tail)
		L.tail=L.head;
	//delete h->next;
	h->next=q->next;
	L.len--;
	return ok;
}

Status ListOperation::Append(LinkList &L,Link s)
{
	L.tail->next=s;
	while(L.tail->next!=NULL)
	{
		L.len++;
		L.tail=L.tail->next;
	}
	return ok;
}

Status ListOperation::Remove(LinkList &L,Link &q)
{
	if(!L.head)
	{
		cout<<"线性链表不存在"<<endl;
		return error;
	}
	q=L.head;
	while(q->next!=L.tail)
	{
		q=q->next;	
	}
	L.tail=q;
	q=q->next;
	L.tail->next=NULL;
	L.len--;
	delete q;
	q=NULL;
	return ok;
}

Status ListOperation::InsBefore(LinkList &L,Link &p,Link s)
{
	Link q=L.head;
	if(!L.head)
	{
		cout<<"线性链表不存在"<<endl;
		return error;
	}
	while(q->next!=p)
	{
		q=q->next;
	}
	q->next=s;
	s->next=p;
	p=s;
	L.len++;
	return ok;
}

Status ListOperation::InsAfter(LinkList &L,Link &p,Link s)
{
	if(!L.head)
	{
		cout<<"线性链表不存在"<<endl;
		return error;
	}
	s->next=p->next;
	p->next=s;
	if(p==L.tail)
		L.tail=L.tail->next;
	p=s;
	L.len++;
	return ok;
}

Status ListOperation::SetCurElem(Link &p,ElemType e)
{
	p->data=e;
	return ok;
}

ElemType ListOperation::GetCurElem(Link p)
{
	return p->data;
}

bool ListOperation::ListEmpty(LinkList L)
{
	if(!L.head)
	{
		cout<<"线性链表不存在"<<endl;
		return error;
	}
	if(L.head->next==NULL)
		return true;
	else
		return false;
}

int ListOperation::ListLength(LinkList L)
{
	if(!L.head)
	{
		cout<<"线性链表不存在"<<endl;
		return error;
	}
	return L.len;
}

Position ListOperation::GetHead(LinkList L)
{
	if(!L.head)
	{
		cout<<"线性链表不存在"<<endl;
		return error;
	}
	return L.head;
}
Position ListOperation::GetLast(LinkList L)
{
	if(!L.head)
	{
		cout<<"线性链表不存在"<<endl;
		return error;
	}
	return L.tail;
}

Position ListOperation::PriorPos(LinkList L,Link p)
{
	Link q=L.head;
	if(!L.head)
	{
		cout<<"线性链表不存在"<<endl;
		return error;
	}
	if(p==L.head)
		return NULL;
	while(q->next!=p)
	{
		q=q->next;
	}
	return q;
}

Position ListOperation::NextPos(LinkList L,Link p)
{
	if(!L.head)
	{
		cout<<"线性链表不存在"<<endl;
		return error;
	}
	if(p==L.tail)
		return NULL;
	return p->next;
}

Status ListOperation::LocatePos(LinkList L,int i,Link q)
{
	int j=0;
	Link pt=L.head;
	while(pt&&j<i)
	{
		pt=pt->next;
		j++;
	}
	if(!pt||j>i)
		return error;
	else
	{
		/*if(p==L.tail)
			GetLast(L);
		else
			PriorPos(L,p->next);
		return ok;*/
		q=pt;
		return ok;
	}
}

Status compare(ElemType x,ElemType y)
{
	if(x.expn==y.expn)
		return 0;
	else if(x.expn<y.expn)
		return -1;
	else
		return 1;
}
Status ListOperation::LocateElem(LinkList L,Link &q,ElemType e,Status(*compare)(ElemType ,ElemType))
{
	Link pt;
	if(L.head->next==NULL)
	{q=L.head;return 0;}
	pt=L.head->next;
	while(pt!=NULL)
	{
		if(!compare(e,pt->data))
		{
			break;return 1;
		}
		pt=pt->next;
	}
	q=pt;
	return 0;
}

Status visit(ElemType x)
{
	cout<<"("<<x.coef<<","<<x.expn<<")"<<endl;
	return ok;
}
Status ListOperation::ListTraverse(LinkList L,Status(*visit)(ElemType))
{
	Link q=L.head->next;
	while(q)
	{
		if(visit(q->data))
			q=q->next;
		else
			return error;
	}
	return ok;
}
#endif/*LinkList.h*/

点击打开链接