用带头结点的单链表

设两个工作指针p和q，分别指向两个单链表的开始节点，两个多项式求和的实质上是对结点p的指数域和结点q的指数域进行比较。

（1）若p->exp<q->exp，则结点p应为结果中的一个结点，将指针p后移。

（2）若p->exp>q->exp，则结点q应为结果中的一个结点，将q插入到第一个单链表结点p之前，再将指针q后移。

（3）若p->exp=q->exp，则p与q所指的为同类项，将q的系数加到p的系数上，若相加结果不为0，则将指针p后移，删除结点q，若相加结果为0，则标明结果中无此项，删除结点p和结点q，并将指针p和指针q分别后移。

 

  1. #include "stdafx.h"  
  2. #include<iostream>    
  3. using namespace std;    
  4.  
  5. struct Node  
  6. {  
  7.     int coef;  
  8.     int exp;  
  9.     Node *next;  
  10. };  
  11. void add(Node *firstp,Node *firstq)  
  12. {  
  13.     Node *pre=firstp;  
  14.     Node *p=pre->next;  
  15.     Node * qre=firstq;  
  16.     Node *q=qre->next;  
  17.     while(p&&q)  
  18.     {  
  19.         if(p->exp<q->exp)  
  20.         {  
  21.             pre=p;  
  22.             p=p->next;  
  23.         }  
  24.         else if(p->exp>q->exp)  
  25.         {  
  26.             Node *qnext=q->next;  
  27.             pre->next=q;  
  28.             q->next=p;  
  29.             qre->next=qnext;  
  30.             q=qnext;  
  31.         }  
  32.         else 
  33.         {  
  34.             p->coef=p->coef+q->coef;  
  35.             if(p->coef==0)  
  36.             {  
  37.                 pre->next=p->next;  
  38.                 p=pre->next;  
  39.             }  
  40.             else 
  41.             {  
  42.                 pre=p;  
  43.                 p=p->next;  
  44.             }  
  45.             qre->next=q->next;  
  46.               
  47.             q=qre->next;  
  48.  
  49.       
  50.         }  
  51.     }  
  52.     if(q)  
  53.         pre->next=q;  
  54.       
  55. }  
  56. void main()    
  57. {   
  58.  
  59.     Node p[5];  
  60.     p[0].next=&p[1];  
  61.     p[1].coef=7;  
  62.     p[1].exp=0;  
  63.     p[1].next=&p[2];  
  64.     p[2].coef=12;  
  65.     p[2].exp=3;  
  66.     p[2].next=&p[3];  
  67.     p[3].coef=-2;  
  68.     p[3].exp=8;  
  69.     p[3].next=&p[4];  
  70.     p[4].coef=5;  
  71.     p[4].exp=12;  
  72.     p[4].next=NULL;  
  73.  
  74.     Node q[6];  
  75.     q[0].next=&q[1];  
  76.     q[1].coef=4;  
  77.     q[1].exp=1;  
  78.     q[1].next=&q[2];  
  79.     q[2].coef=6;  
  80.     q[2].exp=3;  
  81.     q[2].next=&q[3];  
  82.     q[3].coef=2;  
  83.     q[3].exp=8;  
  84.     q[3].next=&q[4];  
  85.     q[4].coef=5;  
  86.     q[4].exp=20;  
  87.     q[4].next=&q[5];  
  88.     q[5].coef=7;  
  89.     q[5].exp=28;  
  90.     q[5].next=NULL;  
  91.    add(&p[0],&q[0]);  
  92.    Node *tmp=p[0].next;  
  93.    while(tmp!=NULL)  
  94.    {  
  95.        cout<<tmp->coef<<"x^"<<tmp->exp<<"  ";  
  96.        tmp=tmp->next;  
  97.    }  
  98. }