算法：一元多项式加法

题目描述
让我们重温小学初中时那些一元多项式的加法吧，不同的是现在使用计算机来帮我们计算了。多年前不想写作业的梦想终于快要实现了！下面就给出书上的算法。

输入
输入数据包含多组测试数据，每组数据包含两行一元多项式。每个多项式包含若干对整数，每对整数的第一个是系数，第二个是指数。每个多项式不超过100项，整数间用空格隔开，并且指数是递减的。

输出
每组测试数据输出一行结果，每个整数后面空一格。(包括行尾)

样例输入

3 2 4 1 7 0
2 4 1 1
2 3
1 4
3 2 4 1 7 0
2 4 -4 1

样例输出

2 4 3 2 5 1 7 0
1 4 2 3
2 4 3 2 7 0

提示：
1、由于多项式元素的重要信息在系数和指数，所以可以定义结点类型为含两个整数的结构体，一个代表系数而另一个代表指数。 2、定义完数据类型后，主要的就是怎么读取数据了。由于每个多项式占一行，所以可以用gets来读取一行，并判断是否为空行：while(gets(strA) && strlen(strA))…然后就将字符串中的数据转换为多项式类型。此时使用到一个字符串处理函数char * strtok ( char * str, const char * delimiters )。这个函数的主要功能是将字符串str按delimiters中的字符分割。使用这个字符串处理函数时注意在处理某个字符串时首次使用时传递的参数是字符串指针而以后在使用时传递的参数是NULL。 3、下面的算法与有序序列有序合并算法类似。因为是多次循环，如果里面含有迭代变量（i，j之类的）注意下次循环时初值对不对。
总结：
多项式加法的算法与有序序列有序合并的算法类似，注意多项式元素类型的定义即可。

**分析：**绞尽脑汁想了好久，刚学完链表没多久，其实看了代码容易理解，代码里有些地方比较繁琐，后续会继续改进。

#include<bits/stdc++.h>

using namespace std;
typedef struct Node
{
    int coef;
    int exp;
    struct Node *next;
}node,*linklist;
void init(linklist &l)//如果你要修改node这个指针本身的值，就要用&，表示引用，如果只是修改node指向的地址的内容就不需要
{
    l=(node*)malloc(sizeof(node));
    l->next=NULL;
    l->coef=0;
    l->exp=0;
}
void insertnode(linklist &l,int c,int e,int i)
{
    node *p,*q;
    q=(node*)malloc(sizeof(node));
    int j=1;
    q->coef=c;
    q->exp=e;
    q->next=NULL;
    p=l;
    while(j<=i)
    {
        p=p->next;
        j++;
    }//找到最后一个结点
    q->next=p->next;
    p->next=q;
}
node *addpoly(node *l1,node *l2)
{
    node *pa,*pb,*s,*pc,*p,*tc;
    pc=(node*)malloc(sizeof(node));
    pc->next=NULL;
    tc=pc;
    pa=l1->next;
    pb=l2->next;
    while(pa!=NULL&&pb!=NULL)
    {
        s=(node*)malloc(sizeof(node));
        if(pa->exp<pb->exp)//la指数小于lb
        {
            s->coef=pb->coef;
            s->exp=pb->exp;
            s->next=NULL;
            tc->next=s;
            tc=s;
            pb=pb->next;
        }
        else if(pa->exp>pb->exp)//la指数大于lb
        {
            s->coef=pa->coef;
            s->exp=pa->exp;
            s->next=NULL;
            tc->next=s;
            tc=s;
            pa=pa->next;
        }
        else//la.lb指数相等
        {
            if(pa->coef+pb->coef!=0)//如果系数相加为0则不用放入最后的结果中
            {
                s->coef=pa->coef+pb->coef;
                s->exp=pa->exp;
                s->next=NULL;
                tc->next=s;
                tc=s;
            }
            pa=pa->next;
            pb=pb->next;
        }
    }
    if(pa!=NULL)
        p=pa;
    else
        p=pb;//将链表中剩下的结点取出
    while(p!=NULL)
    {
        s=(node*)malloc(sizeof(node));
        s->coef=p->coef;
        s->exp=p->exp;
        s->next=NULL;
        tc->next=s;
        tc=s;
        p=p->next;
    }
    return pc;
}
void print(node *l)
{
    node *p;
    p=l->next;
    while(p!=NULL)
    {
        printf("%d %d ",p->coef,p->exp);
        p=p->next;
    }
    printf("\n");
}
int main()
{
    char a[105],b[105];
    while(gets(a))
    {
        gets(b);
        int p=0,q=0,k=0,v=0;
        int len1=strlen(a),len2=strlen(b);
        int c[105],d[105],e[105],f[105];
        for(int i=0;i<len1;)//将字符转化为数字存放
        {
            if(a[i]!=' ')
            {
                if(a[i]!='-')
                {
                    c[p++]=a[i]-'0';
                    if(a[i+2]!='-')
                        {
                            e[q++]=a[i+2]-'0';
                            i+=4;
                        }
                    else
                    {
                        e[q++]=(a[i+3]-'0')*-1;
                        i+=5;
                    }
                }
                else
                {
                    c[p++]=(a[i+1]-'0')*-1;
                    if(a[i+3]!='-')
                    {
                        e[q++]=a[i+3]-'0';
                        i+=5;
                    }
                    else
                    {
                        e[q++]=(a[i+4]-'0')*-1;
                        i+=6;
                    }
                }
            }
        }
        for(int i=0;i<len2;)
        {
            if(b[i]!=' ')
            {
                if(b[i]!='-')
                {
                    d[k++]=b[i]-'0';
                    if(b[i+2]!='-')
                        {
                            f[v++]=b[i+2]-'0';
                            i+=4;
                        }
                    else
                    {
                        f[v++]=(b[i+3]-'0')*-1;
                        i+=5;
                    }
                }
                else
                {
                    d[k++]=(b[i+1]-'0')*-1;
                    if(b[i+3]!='-')
                    {
                        f[v++]=b[i+3]-'0';
                        i+=5;
                    }
                    else
                    {
                        f[v++]=(b[i+4]-'0')*-1;
                        i+=6;
                    }
                }
            }
        }//这个地方有点繁琐了，后期有时间会进行改进
        node *la,*lb,*lc;
        init(la);
        init(lb);
        init(lc);
        for(int i=0;i<p;i++)
        {
            insertnode(la,c[i],e[i],i);
        }
        for(int i=0;i<k;i++)
        {
            insertnode(lb,d[i],f[i],i);
        }
        lc=addpoly(la,lb);
        print(lc);
    }
    return 0;
}

数据结构的小白献丑了orz