多项式加法

题目的链接为[url]http://acm.njupt.edu.cn/acmhome/problemdetail.do?&method=showdetail&id=1005[/url]
题目如下：
多项式加法
时间限制(普通/Java):1000MS/3000MS 运行内存限制:65536KByte
总提交:964 测试通过:100

描述


线性表是一种最简单、最基本，也是最常用的数据结构，其用途十分广泛，例如，用带表头结点的单链表求解一元整系数多项式加法和乘法运算。

现给两个一元整系数多项式，请求解两者之和。


输入


两组数据，每一组代表一个一元整系数多项式，有多行组成，其中每一行给出多项式每一项的系数和指数，这些行按指数递减次序排序，每一组结束行为

0 -1


输出


三组数据，前两组为一元整系数多项式，最后一组为两个多项式的和。

一元整系数多项式输出形式如下：

（1）多项式项4x输出为4X

（2）多项式项4x2输出为4X^2

（3）第一项系数为正数时，加号不要输出

（4）除常系数项外，项系数为1不显式输出，-1输出为-

例如，4x3- x2+x-1正确输出形式为4X^3-X^2+X-1，错误输出形式为 +4X^3-1X^2+1X-1

样例输入

3 14
-8 8
6 2
2 0
0 -1
2 10
4 8
-6 2
0 -1

样例输出

3X^14-8X^8+6X^2+2
2X^10+4X^8-6X^2
3X^14+2X^10-4X^8+2


提示


该题属于南京邮电大学《数据结构A》实验一中的内容，验证的是课本代码，请慎重解答。


题目来源

CHENZ
说是多项式的加法，其实考察的是对于链表的操作。
我们设一个结构体，包括3个部分：
xs:多形式某项的系数
zs:多项式某项的指数
next:指向下个项的指针

typedef struct node{

      int xs;
      int zs;
      struct node *next;  
}Node;

对于一个多项式的输入，由于是按指数递减输入的，故我们只需按照输入顺序进行存储即可。
对待一个输入，算法如下：
1.如果当前多项式为空，那么将此项放入第一项
2.如果当前多项式不为空
2.1如果有指数相同的项，那么将此项与指数相同的项合并，如果系数变为0，则将此项删除。
2.2如果没有指数相同的项(那么此项的指数一定比当前所有项的指数都小)，那么将此项放入多项式末尾。
这样就可以得到输入的两个多项式，并输出。
对于最后一步，多项式加法，即将多项式指数相同的项分别相加，而将指数不同的项保留输出即是加法结果。
代码如下，思路不难，重在细心：
PS：我是第100个AC的，好彩头！

#include<iostream>
using namespace std;
typedef struct node{

      int xs;
      int zs;
      struct node *next;  
}Node;
int xs,zs;
bool tag=true;
void print(Node *root)
{
    Node *p=root->next;
    while(p!=NULL)
    {
         if(p==root->next)
         {
              if(p->xs!=1)
              {
                 if(p->xs==-1)
                 {
                     cout<<"-"; 
                 }    
                 else
                 {
                     cout<<p->xs; 
                 }
              } 
         } 
         else
         {
              if(p->xs>0)
              {
                   cout<<"+";
                   if(p->xs!=1)
                   {
                       cout<<p->xs; 
                   }
              } 
              else
              {
                    if(p->xs!=-1)
                    {
                       cout<<p->xs;
                    } 
                    else
                    {
                       cout<<"-"; 
                    }
              }
         }
         if(p->zs!=0)
         {
               cout<<"X";
         }
         else
         {
               if(p->xs==1||p->xs==-1)
               {
                  cout<<"1"; 
               }

               p=p->next;
               continue; 
         }
         if(p->zs!=1)
         {
               cout<<"^"<<p->zs; 
         }

         p=p->next;
    }
    cout<<endl;
}
int main(){

    Node *root[2],*root1,*t,*u,*k;
    for(int i=0;i<2;i++){
        root[i]=NULL; 
    } 
    root1=new Node();
    for(int i=0;i<2;i++){
        while(cin>>xs>>zs&&(xs!=0||zs!=-1)){

            if(xs==0)
            {
               continue;
            }
            if(root[i]==NULL)
            {
                  Node *temp=new Node();
                  temp->xs=xs;
                  temp->zs=zs;
                  temp->next=NULL;

                  root[i]=new Node();
                  root[i]->next=temp;
            }
            else
            {
                  Node *p,*q;
                  p=root[i]->next;
                  q=root[i];
                  while(p!=NULL&&p->zs!=zs)
                  {
                       q=p;
                       p=p->next; 
                  }
                  if(p==NULL)
                  {
                       Node *temp=new Node();
                       temp->xs=xs;
                       temp->zs=zs;
                       temp->next=NULL;

                       q->next=temp;
                  }
                  else
                  {
                       p->xs+=xs;
                       if(p->xs==0)
                       {
                           q->next=p->next; 
                       }
                  }
            }
        }
        print(root[i]);  
    }
    t=root[0]->next;
    u=root[1]->next;
    k=root1;
    while(t!=NULL&&u!=NULL)
    {
             Node *tempNode=new Node();
             if(t->zs>u->zs)
             {
                  tempNode->xs=t->xs;
                  tempNode->zs=t->zs;
                  t=t->next;
                  tag=false;
             } 
             else if(t->zs<u->zs)
             {
                  tempNode->xs=u->xs;
                  tempNode->zs=u->zs;
                  u=u->next;   
                  tag=false;
             }
             else
             {
                  if(t->xs+u->xs==0)
                  {
                      t=t->next;
                      u=u->next;
                      continue; 
                  } 
                  tempNode->xs=u->xs+t->xs;
                  tempNode->zs=u->zs;
                  u=u->next; 
                  t=t->next;
                  tag=false;
             }
             k->next=tempNode;
             k=tempNode;
    }
    while(t!=NULL)
    {
           Node *tempNode=new Node();
           tempNode->xs=t->xs;
           tempNode->zs=t->zs;

           k->next=tempNode;
           k=tempNode;
           t=t->next;
           tag=false;
    }
    while(u!=NULL)
    {
           Node *tempNode=new Node();
           tempNode->xs=u->xs;
           tempNode->zs=u->zs;

           k->next=tempNode;
           k=tempNode;
           u=u->next;
           tag=false;
    }
    if(!tag)
    {
      print(root1);
    }
    else
    {
      cout<<"0"<<endl; 
    } 

    for(int i=0;i<2;i++)
    {
        t=root[i];
        u=t;
        while(t!=NULL)
        {
              u=t->next;
              delete t;
              t=u;
        } 
    }
    t=root1;
    u=t;
    while(t!=NULL)
    {
              u=t->next;
              delete t;
              t=u;
    } 
    system("pause");
    return 0;
}