用单链表表示一元多项式及相加相减相乘运算

头文件：Polynomial.h

#include<cstdlib>
#include<iostream>
using namespace std;
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
typedef int Status;
typedef struct
{
 float coef;  //系数
 int expn;    //指数
}term, ElemType;

typedef struct LNode
{
 ElemType data;
 struct LNode* next;
}*Link, *Position;

typedef struct
{
 Link head, tail;
 int len;
}LinkList_L;

typedef LinkList_L polynomial;

//分配由p指向的值为e的结点，并返回OK;若分配失败，则返回ERROR
Status MakeNode(Link& p, ElemType e)
{
 p = (Link)malloc(sizeof(LNode));
 if (!p)
  return ERROR;
 p->data = e;
 p->next = NULL;
 return OK;
}

//释放p所指向的结点
void FreeNode(Link& p)
{
 free(p);
 p = NULL;
}

//构造一个空的线性链表L
Status InitList(LinkList_L& L)
{
 L.head = (Link)malloc(sizeof(LNode));
 L.head->next = NULL;
 L.tail = L.head;
 L.len = 0;
 return OK;
}

//将线性链表L置为空表
Status ClearList(LinkList_L& L)
{
 if (!L.head->next)
 {
  L.tail = L.head;
  L.len = 0;
  return OK;
 }
 Link p = L.head->next;
 while (p)
 {
  Link q = p->next;
  FreeNode(p);
  p = q;
 }
 L.head->next = NULL;
 L.tail = L.head;
 L.len = 0;
 return OK;
}

//销毁线性链表L
Status DestroyList(LinkList_L& L)
{
 ClearList(L);
 free(L.head);
 return OK;
}

//已知h指向线性链表的头结点，将s所指向结点插入在第一个结点之前
Status InsFirst(Link h, Link s)
{
 s->next = h->next;
 h->next = s;
 return OK;
}

//已知h指向线性链表的头结点，删除链表中的第一个结点并以q返回
Status DelFirst(Link h, Link& q)
{
 q = h->next;
 if (q)
 {
  h->next = q->next;
  q->next = NULL;
  return OK;
 }
 return ERROR;
}

//将指针s所指向的一串结点链接在线性链表L的最后一个结点之后，并改变链表L的尾指针指向新的尾结点
Status Append(LinkList_L& L, Link s)
{
 int num = 0;
 L.tail->next = s;
 while (s)
 {
  num++;
  if (!s->next)
  {
   L.tail = s;
   L.len += num;
   return OK;
  }
  s = s->next;
 }
 return ERROR;
}

//删除线性链表L中的尾结点并以q返回，改变链表L的尾指针指向新的尾结点
Status Remove(LinkList_L& L, Link& q)
{
 if (L.head == L.tail)
  return ERROR;
 Link s = L.head;
 while (s)
 {
  if (L.tail == s->next)
  {
   q = s->next;
   s->next = NULL;
   L.tail = s;
   L.len--;
   return OK;
  }
  s = s->next;
 }
 return ERROR;
}

//已知p指向线性链表L中的一个结点，将s所指结点插入在p所指结点之前，并修改指针p指向新插入的结点
Status InsBefore(LinkList_L& L, Link& p, Link s)
{
 Link q = L.head;
 while (q)
 {
  if (q->next == p)
  {
   q->next = s;
   s->next = p;
   p = s;
   L.len++;
   return OK;
  }
  q = q->next;
 }
 return ERROR;
}

//已知p指向线性链表L中的一个结点，将s所指结点插入p所指结点之后，并修改指针p指向新插入的结点
Status InsAfter(LinkList_L& L, Link& p, Link s)
{
 s->next = p->next;
 p->next = s;
 p = s;
 if (!p->next)
  L.tail = p;
 L.len++;
 return OK;
}

//已知p指向线性链表中的一个结点，用e更新p所指结点中数据元素的值
Status SetCurElem(Link& p, ElemType e)
{
 p->data = e;
 return OK;
}

//已知p指向线性链表中的一个结点，返回p所指向结点的数据元素
ElemType GetCurElem(Link p)
{
 return p->data;
}

//若线性链表L为空，则返回TRUE;否则返回FALSE
Status ListEmpty(LinkList_L L)
{
 if (!L.len)
  return TRUE;
 else
  return FALSE;
}

//返回线性链表L中元素个数
int ListLength(LinkList_L L)
{
 return L.len;
}

//返回线性链表L中头结点的位置
Position GetHead(LinkList_L L)
{
 return L.head;
}

//返回线性链表L中最后一个结点的位置
Position GetLast(LinkList_L L)
{
 if (L.head->next)
  return L.tail;
 else
  return NULL;
}

//返回线性链表中第i个结点
Position GetNode(LinkList_L L, int i)
{
 if (i<1 || i>ListLength(L))
  return NULL;
 Link p = L.head;
 int j = 0;
 while (j<i)
 {
  p = p->next;
  ++j;
 }
 return p;
}

//已知p指向线性链表L中的一个结点，返回p所指结点的直接前驱的位置，若无前驱则返回NULL
Position PriorPos(LinkList_L L, Link p)
{
 if (p == L.head->next)
  return NULL;
 Link q = L.head->next;
 while (q&&q->next)
 {
  if (q->next == p)
   return q;
  q = q->next;
 }
 return NULL;
}

//已知p指向线性链表L中的一个结点，返回p所指结点的直接后继的位置，若无后继则返回NULL
Position NextPos(LinkList_L L, Link p)
{
 if (p->next == NULL)
  return NULL;
 else
  return p->next;
}

//用结点p替换线性链表中第i个结点
Status DisplaceLink(LinkList_L& L, int i, Link p)
{
 if (i<1 || i>ListLength(L))
  return ERROR;
 Link q=GetNode(L, i);
 SetCurElem(q, p->data);
 return OK;
}

//返回p指示线性链表L中第i个结点的位置，并返回OK，i值不合法时返回ERROR
Status LocatePos(LinkList_L L, int i, Link& p)
{
 if (i<1 || i>ListLength(L))
  return ERROR;
 int j = 0;
 p = L.head;
 while (j<i)
 {
  p = p->next;
  ++j;
 }
 return OK;
}

//若当前项a的指数小于b的指数，返回-1，若相等返回0，若大于则返回1
int compare(ElemType a, ElemType b)
{
 if (a.expn < b.expn)
  return -1;
 else
 {
  if (a.expn == b.expn)
   return 0;
  else
   return 1;
 }
}

//若一元多项式中存在和e指数相同的项，返回OK，否则返回ERROR
Status LocateElem(LinkList_L L, ElemType e, Link& q, Status(*compare)(ElemType, ElemType))
{
 q = L.head->next;
 while (q && (*compare)(e, q->data)!=0)
 {
  q = q->next;
  if (!q)
   return ERROR;
 }
 if (!q)
  return ERROR;
 return OK;
}

//在带头结点的单链表L的第i个元素之前插入元素e
Status ListInsert(LinkList_L& L, int i, ElemType e)
{
 Link h, s;
 if (!(MakeNode(s, e)))
  return ERROR;
 if (1 == i)
 {
  InsFirst(L.head, s);
  L.tail = s;
  L.len++;
  return OK;
 }
 if (!LocatePos(L, i - 1, h))
  return ERROR;
 InsFirst(h, s);
    if (!s->next)
  L.tail = s;
 L.len++;
 return OK;
}

//在带头结点的单链表L中删除第i个元素，并用e返回
Status ListDelete(LinkList_L& L, int i, ElemType& e)
{
 Link p;
 if (!LocatePos(L, i, p))
  return ERROR;
 e = p->data;
 Link s = PriorPos(L, p);
 if (!s)
  return ERROR;
 s->next = p->next;
 if (!p->next)
  L.tail = s;
 FreeNode(p);
 L.len--;
 return OK;
}

//将线性链表L复制给S
Status Copy(LinkList_L& S, LinkList_L L)
{
 InitList(S);
 for (int i = 1; i <= ListLength(L); ++i)
 {
  Link s = GetNode(L, i);
  ListInsert(S, i, s->data);
 }
 return OK;
}

//输入m项的系数和指数，建立表示一元多项式的有序链表P
void CreatPolyn(polynomial& P, int m)
{
 InitList(P);
 Link h = GetHead(P);
 ElemType e;
 e.coef = 0.0;
 e.expn = -1;
 SetCurElem(h, e);
 Link s, q;
 for (int i = 1; i <= m; ++i)
 {
  cout << "输入第" << i << "项的系数和指数:";
  cin >> e.coef >> e.expn;
  if (!LocateElem(P, e, q, compare))               //当前多项式中没有与此指数相同的项
  {
   if (MakeNode(s, e))
   {
    InsFirst(h, s);
    P.len++;
    P.tail = s;
    h = s;
   }
  }
  else
  {
   cout << "当前链表中已有指数为" << e.expn << "的项" << endl;
   cout << "重新";
   --i;
  }
 }
}

//销毁一元多项式P
void DestroyPolyn(polynomial& P)
{
 Link p = P.head->next;
 while (p)
 {
  Link q = p->next;
  FreeNode(p);
  p = q;
 }
 FreeNode(P.head);
}

//打印输出一元多项式P
void PrintPolyn(polynomial P)
{
 Link h = P.head->next;
 while (h)
 {
  if (h->data.coef == 0)
   h = h->next;
  switch (h->data.expn)
  {
  case 0:
   cout << h->data.coef;
   break;
  case 1:
   if (h->data.coef == 1)
    cout << 'x';
   else if (h->data.coef == -1)
    cout << '-' << 'x';
   else
    cout << h->data.coef << 'x';
   break;
  default:
   if (h->data.coef == 1)
    cout << 'x' << '^' << h->data.expn;
   else if (h->data.coef == -1)
    cout << '-' << 'x' << '^' << h->data.expn;
   else
       cout << h->data.coef << 'x' << '^' << h->data.expn;
   break;
  }
  if (h->next)
  {
   if (h->next->data.coef > 0)
    cout << '+';
  }
  h = h->next;
 }
 cout << endl;
}

//返回一元多项式P中的项数
int PolynLength(polynomial P)
{
 return ListLength(P);
}

//多项式加法：Pa=Pa+Pb，利用两个多项式的结点构成"和多项式"
void AddPolyn(polynomial& Pa, polynomial& Pb)
{
 Link ha = GetHead(Pa);
 Link hb = GetHead(Pb);
 Link qa = NextPos(Pa, ha);
 Link qb = NextPos(Pb, hb);
 while (qa&&qb)
 {
  ElemType a = GetCurElem(qa);
  ElemType b = GetCurElem(qb);
  switch ((*compare)(a,b))
  {
  case -1:                    //Pa当前项的指数小于Pb当前项的指数
   ha = qa;                //结点ha后移
   qa = NextPos(Pa, qa);   //结点qa后移
   break;
  case 0:                                       //Pa与Pb指数相同
      a.coef+=b.coef;              //指数相同的项系数之和
   if (a.coef)                   //如果系数之和不等于0
   {
    SetCurElem(qa, a);         //当前项指数的系数更新
    ha = qa;
   }
   else                                      //如果系数之和等于0 
   {
    if (!qa->next)
     Pa.tail = ha;
    DelFirst(ha, qa);                     //删除当前项
    Pa.len--;
    FreeNode(qa);                         //释放空间
   }
   DelFirst(hb, qb);          //Pa=Pa+Pb,不管系数之和等于0或不等于0，Pb的当前项都要删除
   Pb.len--;
   FreeNode(qb);              //释放空间
   qb = NextPos(Pb, hb);      //结点qb后移
   qa = NextPos(Pa, ha);      //结点qa后移
   break;
  case 1:                                      //Pa当前项的指数大于Pb当前项的指数
   DelFirst(hb, qb);                        //删除Pb的当前项
   Pb.len--;
   InsFirst(ha, qb);                        //插入到Pa中与当前项的前面
   Pa.len++;
   qb = NextPos(Pb, hb);                    //结点qb后移
   ha = NextPos(Pa, ha);                    //结点ha后移到刚插入的结点
   break;
  }
 }
 if (!ListEmpty(Pb))
  Append(Pa, qb);
 FreeNode(hb);
}

//多项式减法：Pa=Pa-Pb,可理解为Pa=Pa+(-Pb),并销毁一元多项式Pb
void SubtractPolyn(polynomial& Pa, polynomial& Pb)
{
 Link hb = GetHead(Pb);
 Link qb = NextPos(Pb, hb);
 while (qb)
 {
  qb->data.coef = -qb->data.coef;
  SetCurElem(qb, qb->data);
  qb = NextPos(Pb, qb);
 }
 AddPolyn(Pa, Pb);
}

//多项式相乘运算，即Pa=Pa*Pb,并销毁一元多项式Pb
void MultiplyPolyn(polynomial& Pa, polynomial& Pb)
{
 polynomial Pc ,Pd, Pe ;
 Copy(Pc, Pa);
 Copy(Pd, Pa);
 Copy(Pe, Pa);
 int i, j;
 for (i = 1; i <= ListLength(Pb); ++i)
 {
  Link p=GetNode(Pb, i);
  for (j = 1; j <= ListLength(Pc); ++j)
  {
   Copy(Pc, Pe);
   Link q=GetNode(Pc, j);
   q->data.coef *= p->data.coef;
   q->data.expn += p->data.expn;
   SetCurElem(q, q->data);
   if (i == 1)
    DisplaceLink(Pa, j, q);
   else
    DisplaceLink(Pd, j, q);
  }
  if (i > 1)
  {
   AddPolyn(Pa, Pd);
   Copy(Pd, Pc);
  }
 }
 DestroyList(Pd);
}

主函数：

#include"Polynomial.h"
void main(void)
{
polynomial P1,P2,P3,P4;
 int P1_length, P2_length,P3_length;
 cout << "输入P1的项数:";
 cin >> P1_length;
 CreatPolyn(P1, P1_length);
 cout << "输入P2的项数:";
 cin >> P2_length;
 CreatPolyn(P2, P2_length);
 cout << "输入P3的项数:";
 cin >> P3_length;
 CreatPolyn(P3, P3_length);
 Copy(P4, P1);
 cout << "P1：";
 PrintPolyn(P1);
 cout << "P2：";
 PrintPolyn(P2);
 cout << "P3：";
 PrintPolyn(P3);
 AddPolyn(P1, P2);
 cout << "P1+P2：";
 PrintPolyn(P1);
 MultiplyPolyn(P1, P3);
 cout << "(P1+P2)*P3=";
 PrintPolyn(P1);
 SubtractPolyn(P1, P4);
 cout << "(P1+P2)*P3-P1=";
 PrintPolyn(P1);
}