多项式加法

题目的链接为 http://acm.njupt.edu.cn/acmhome/problemdetail.do?&method=showdetail&id=1005
题目如下：
多项式加法
时间限制(普通/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:指向下个项的指针

C++代码

1. typedef struct node{   
2.          
3.       int xs;   
4.       int zs;   
5.       struct node *next;     
6. }Node;  

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

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

C++代码

1. #include<iostream>   
2. using namespace std;   
3. typedef struct node{   
4.          
5.       int xs;   
6.       int zs;   
7.       struct node *next;     
8. }Node;   
9. int xs,zs;   
10. bool tag=true;   
11. void print(Node *root)   
12. {   
13.     Node *p=root->next;   
14.     while(p!=NULL)   
15.     {   
16.          if(p==root->next)   
17.          {   
18.               if(p->xs!=1)   
19.               {   
20.                  if(p->xs==-1)   
21.                  {   
22.                      cout<<"-";    
23.                  }       
24.                  else  
25.                  {   
26.                      cout<<p->xs;    
27.                  }   
28.               }    
29.          }    
30.          else  
31.          {   
32.               if(p->xs>0)   
33.               {   
34.                    cout<<"+";   
35.                    if(p->xs!=1)   
36.                    {   
37.                        cout<<p->xs;    
38.                    }   
39.               }    
40.               else  
41.               {   
42.                     if(p->xs!=-1)   
43.                     {   
44.                        cout<<p->xs;   
45.                     }    
46.                     else  
47.                     {   
48.                        cout<<"-";    
49.                     }   
50.               }   
51.          }   
52.          if(p->zs!=0)   
53.          {   
54.                cout<<"X";   
55.          }   
56.          else  
57.          {   
58.                if(p->xs==1||p->xs==-1)   
59.                {   
60.                   cout<<"1";    
61.                }   
62.                   
63.                p=p->next;   
64.                continue;    
65.          }   
66.          if(p->zs!=1)   
67.          {   
68.                cout<<"^"<<p->zs;    
69.          }   
70.             
71.          p=p->next;   
72.     }   
73.     cout<<endl;   
74. }   
75. int main(){   
76.   
77.     Node *root[2],*root1,*t,*u,*k;   
78.     for(int i=0;i<2;i++){   
79.         root[i]=NULL;    
80.     }    
81.     root1=new Node();   
82.     for(int i=0;i<2;i++){   
83.         while(cin>>xs>>zs&&(xs!=0||zs!=-1)){   
84.             
85.             if(xs==0)   
86.             {   
87.                continue;   
88.             }   
89.             if(root[i]==NULL)   
90.             {   
91.                   Node *temp=new Node();   
92.                   temp->xs=xs;   
93.                   temp->zs=zs;   
94.                   temp->next=NULL;   
95.                      
96.                   root[i]=new Node();   
97.                   root[i]->next=temp;   
98.             }   
99.             else  
100.             {   
101.                   Node *p,*q;   
102.                   p=root[i]->next;   
103.                   q=root[i];   
104.                   while(p!=NULL&&p->zs!=zs)   
105.                   {   
106.                        q=p;   
107.                        p=p->next;    
108.                   }   
109.                   if(p==NULL)   
110.                   {   
111.                        Node *temp=new Node();   
112.                        temp->xs=xs;   
113.                        temp->zs=zs;   
114.                        temp->next=NULL;   
115.                      
116.                        q->next=temp;   
117.                   }   
118.                   else  
119.                   {   
120.                        p->xs+=xs;   
121.                        if(p->xs==0)   
122.                        {   
123.                            q->next=p->next;    
124.                        }   
125.                   }   
126.             }   
127.         }   
128.         print(root[i]);     
129.     }   
130.     t=root[0]->next;   
131.     u=root[1]->next;   
132.     k=root1;   
133.     while(t!=NULL&&u!=NULL)   
134.     {   
135.              Node *tempNode=new Node();   
136.              if(t->zs>u->zs)   
137.              {   
138.                   tempNode->xs=t->xs;   
139.                   tempNode->zs=t->zs;   
140.                   t=t->next;   
141.                   tag=false;   
142.              }    
143.              else if(t->zs<u->zs)   
144.              {   
145.                   tempNode->xs=u->xs;   
146.                   tempNode->zs=u->zs;   
147.                   u=u->next;      
148.                   tag=false;   
149.              }   
150.              else  
151.              {   
152.                   if(t->xs+u->xs==0)   
153.                   {   
154.                       t=t->next;   
155.                       u=u->next;   
156.                       continue;    
157.                   }    
158.                   tempNode->xs=u->xs+t->xs;   
159.                   tempNode->zs=u->zs;   
160.                   u=u->next;    
161.                   t=t->next;   
162.                   tag=false;   
163.              }   
164.              k->next=tempNode;   
165.              k=tempNode;   
166.     }   
167.     while(t!=NULL)   
168.     {   
169.            Node *tempNode=new Node();   
170.            tempNode->xs=t->xs;   
171.            tempNode->zs=t->zs;   
172.               
173.            k->next=tempNode;   
174.            k=tempNode;   
175.            t=t->next;   
176.            tag=false;   
177.     }   
178.     while(u!=NULL)   
179.     {   
180.            Node *tempNode=new Node();   
181.            tempNode->xs=u->xs;   
182.            tempNode->zs=u->zs;   
183.               
184.            k->next=tempNode;   
185.            k=tempNode;   
186.            u=u->next;   
187.            tag=false;   
188.     }   
189.     if(!tag)   
190.     {   
191.       print(root1);   
192.     }   
193.     else  
194.     {   
195.       cout<<"0"<<endl;    
196.     }    
197.        
198.     for(int i=0;i<2;i++)   
199.     {   
200.         t=root[i];   
201.         u=t;   
202.         while(t!=NULL)   
203.         {   
204.               u=t->next;   
205.               delete t;   
206.               t=u;   
207.         }    
208.     }   
209.     t=root1;   
210.     u=t;   
211.     while(t!=NULL)   
212.     {   
213.               u=t->next;   
214.               delete t;   
215.               t=u;   
216.     }    
217.     system("pause");   
218.     return 0;   
219. }