3．线性表的链式表示和实现
       链表是非随机存取的存储结构
       线性表的单链表存储结构
       typedef struct LNode
       {
              ElemType       data;
              struct LNode  *next;
       }LNode, *LinkList;
       1）单链表的取元素操作：
       Status GetElem_L(LinkList L, int i, ElemType &e)
       {
              p = L->next;
              j = 1;
              while (p && j < i)
              {
                     p = p -> next; ++ j;
              }
              if ( !p || j > i)
                     return ERROR;
              e = p -> data;
              return OK;
       }
       其时间复杂度为O(n)。
       2）单链表的插入操作：
       Status ListInsert_L(LinkList &L, int i, ElemType e)
       {
              p = L;
              j = 0;
              while (p && j < i -1)
              {
                     p = p -> next;
                     ++ j;
              }
              if (!p || j > i - 1)
                     return ERROR;
              s = (LinkList) malloc(sizeof(LNode));
              s -> data = e;
              s -> next = p -> next;
              p -> next = s;
              return OK;
       }
       其时间复杂度为O(n)。
       3）单链表的删除操作：
       Status ListDelete_L(LinkList &L, int i, ElemType &e)
       {
              p = L;
              j = 0;
              while (p -> next && j < i - 1)
              {
                     p = p -> next;
                     ++ j;
              }
              if (!(p -> next) || j > i - 1)
                     return ERROR;
              q = p -> next;
              p-> next = q ->next;
              e = q -> data;
              free(q);
              return OK;
       }
       其时间复杂度为O(n)。
       4）单链表的建立操作：    
       void CreateList_L(LinkList &L, int n)
       {
              L = (LinkList) malloc(sizeof(LNode));
              L->next = NULL;
              for (i = n; i > 0; i ++)
              {
                     p = (LinkList) malloc(sizeof(LNode));
                     scanf(&p -> data);
                     p -> next = L -> next;
                     L -> next = p;
              }
       }
       其时间复杂度为O(n)。
       5）单链表的归并操作：
       void MergeList_L(LinkList &La, LinkList & Lb, LinkList & Lc)
       {
              pa = La -> next;
              pb = Lb -> next;
              Lc = pc = La;
              while (pa && pb)
              {
                     if (pa -> data <= pb -> data)
                     {
                            pc -> next = pa;
                            pc = pa;
                            pa = pa -> next;
                     }
                     else
                     {
                            pc-> next = pb;
                            pc = pb;
                            pb = pb -> next;
                     }
              }
              pc -> next = pa ? pa : pb;
              free(Lb);
       }
      
       线性表的双向链表存储结构
       typedef struct DuLNode
       {
              ElemType              data;
              struct DuLNode     *prior;
              struct DuLNode     *next;
       }DuLNode, *DuLinkList;
1）  双向链表的结点插入操作：
       Status ListInsert_DuL(DuLinkList &L, int i, ElemType e)
       {
              if (! (p = GetElemP_Dul(L, i)))
                     return ERROR;
              if (! (s = (DuLinkList)malloc(sizeof(DuLNode))))
                     return ERROR;
              s -> data = e;
              s -> prior = p -> piror;
              p -> prior -> next = s;
              s -> next = p;
              p -> prior = s;
              return OK;
       }
2）  双向链表的结点删除操作：
Status ListDelete_DuL(DuLinkList &L, int i, ElemType &e)
{
       if (! (p = GetElemP_DuL(L, i)))
              return ERROR;
       e = p -> data;
       p -> prior -> next = p -> next;
       p -> next -> prior = p -> prior;
       free(p);
}
 
4 一元多项式的表示及相加
       抽象数据类型一元多项式的定义如下：
       ADT Polynomial
       {
              数据对象：D = {|∈TermSet，i = 1, 2, …, m, m≥0
                                   TermSet中的每个元素包含一个表示系数的实数和表示指数的整数}
              数据关系：R1 = {<, > | , ∈D，且中的指数值<中的指数值，
                                          i = 2, …, n}
              基本操作：
              CreatePolyn(&P, m)
              操作结果：输入m项的系数的指数，建立一元多项式P。
              DestroyPolyn(&P)
              初始条件：一元多项式P已存在。
              操作结果：销毁一元多项式P。
              PrintPolyn(P)
              初始条件：一元多项式P已存在。
              操作结果：打印输出一元多项式P。
              PolynLength(P)
              初始条件：一元多项式P已存在。
              操作结果：返回一元多项式P中的项数。
              AddPolyn(&Pa, &Pb)
              初始条件：一元多项式Pa和Pb已存在。
              操作结果：完成多项式相加运算，即：Pa = Pa + Pb，并销毁一元多项式Pb。
              SubtractPolyn(&Pa, &Pb)
              初始条件：一元多项式Pa和Pb已存在。
              操作结果：完成多项式相减运算，即Pa = Pa – Pb，并销毁一元多项式Pb。
              MultiplyPolyn(&Pa, &Pb)
              初始条件：一元多项式Pa和Pb已存在。
              操作结果：完成多项式相乘运算，即Pa = Pa ⅹPb，并销毁一元多项式Pb。  
       }ADT Polynomial
 
       多项式相加的运算规则如下：
              假设指针qa和qb分别指向多项式A和多项式B中当前进行比较的某个结点，则           比较两个结点中的指数项，有下列3种情况：1）指针qa所指结点的指数值小于指针    qb所指结点的指数值，则应摘取qa指针所指结点插入到“和多项式”链表中去；2) 指  针qa所指结点的指数值大于指针qb所指结点的指数值，则应摘取qb指针所指结点插 入到“和多项式”链表中去；3）指针qa所指结点的指数值等于指针qb所指结点的指          数值，则将两个结点中的系数相加，若和数不为零，则修改qa所指结点的系数值，同         时释放qb所指结点；反之，从多项式A的链表删除相应结点，并释放指针qa和qb所 指结点。