数据结构之多项式相加

【问题描述】编写一个程序用单链表存储多项式，并实现两个一元多项式A与B相加的函数。A，B刚开始是无序的，A与B之和按降序排列。例如：
多项式A: 1.2X^0 2.5X^1 3.2X^3 -2.5X^5
多项式B: -1.2X^0 2.5X^1 3.2X^3 2.5X^5 5.4X^10
多项式A与B之和：5.4X^10 6.4X^3 5X^1

【输入形式】任意两个多项式A和B的项数及对应的系数和指数，要查询的第几项
【输出形式】多项式中某一项的系数与指数，系数保留一位小数

【输入样例】
4 1.2 0 2.5 1 3.2 3 -2.5 5
5 -1.2 0 2.5 1 3.2 3 2.5 5 5.4 10
2

【输出样例】

6.4 3

【样例说明】
第一个多项式的系数与指数对，以空格隔开
第二个多项式的系数与指数对，以空格隔开
输出第２项的系数与指数，系数与指数间用空格隔开，系数保留一位小数

【评分标准】必须用链表实现

嗯说实话这个题敲了一下午都没敲出来，我自己要反思一下。原因有很多，只找自己的问题吧。
比如非常浮躁，没沉下心，也没有认真思考，认真审题。题目都没看清。首先题目要求的是两个指数无序的序列，所以会需要排序。再者要求的输出，不是合并相加之后的多项式各个指数还有系数，而是第几个。嗯这些我都没看，直接就敲了，结果可想而知，那就是究极自闭。而且我用了花里胡哨的方法，因为不久前看了看某大的mooc正好讲了多项式相加，于是就套用了那个方法，还是没有熟练掌握，具体细节也没明白所以爆炸了。

到最后很多人都敲出来了，我才悔改，用最为朴实无华的常规思路进行求解。但中间的问题太多了，感觉自己能力还差了很多，还需更长远的修炼。

#include
#include
typedef struct node*list;
struct node{
    float coef;
    int expon;
    list next;
};
list create()//最基本的构建其实是最好的方法 我也不多说了
{
    list q, r, head;
    int i;
    head = (list)malloc(sizeof(struct node));
    r = head;
    int n;
    scanf("%d",&n);
    for(i=0;icoef,&q->expon);
        r->next = q;
        r = q;
    }
    r->next = NULL;
    return head;
}
list sort(list head)//这是一个排序的函数
{
    list p=head->next,q,r;
    if (p!=NULL)
    {
        r=p->next;
        p->next=NULL;
        p=r;
        while(p!=NULL)
        {
            r=p->next;
            q=head;
            while (q->next!=NULL && q->next->expon>p->expon)
                q=q->next;
            p->next=q->next;
            q->next=p;
            p=r;
        }
    }
    return head;

}
list add(list a,list b)//排好序的多项式相加
{
    list p,q,r,c,s;
    p=a->next;
    q=b->next;
    c=(list)malloc(sizeof(struct node));
    r=c;
    while(p&&q){
        if(p->exponexpon){
            s=(list)malloc(sizeof(struct node));
            s->expon=q->expon;
            s->coef=q->coef;
            r->next=s;
            r=s;
            q=q->next;
        }
        else if(p->expon>q->expon){
            s=(list)malloc(sizeof(struct node));
            s->expon=p->expon;
            s->coef=p->coef;
            r->next=s;
            r=s;
            p=p->next;
        }
        else{
            double sum=p->coef+q->coef;
            if(sum!=0){
                s=(list)malloc(sizeof(struct node));
                s->coef=sum;
                s->expon=p->expon;
                r->next=s;
                r=s;
                p=p->next;
                q=q->next;
                }
            else{
                p=p->next;
                q=q->next;
            }
        }
    }
    if(p == NULL &&q == NULL)
        r->next = NULL;
    if(p!=NULL){
        r->next = p;
    }
    if(q!=NULL){
        r->next = q;
    }
    return c;
}
void show(list l)//输出函数
{
    int n;
    list p=l;
    scanf("%d",&n);
    while(n--){
        p=p->next;
    }
    printf("%.1f %d",p->coef,p->expon);//这个格式十分重要啊
    printf("\n");
}
int main()
{
    list a,b,c,d,e;
    a=create();
    b=create();
    d=sort(a);
    e=sort(b);
    c=add(d,e);
    show(c);
    return 0;

}

sort函数想用冒泡排序+只有值交换而不是指针的改变但是系统不让我过啊，这就很难受了，大家也可以尝试一下使用我最初的方法。其实我感觉冒泡排序更通俗易懂 用双重for循环然后一直遍历比较就好了；

add函数我用的方法复杂了，我的方法是创建新的链表，然后不停创建新结点。其实只要一个指针然后指向就好了；

list add(list a,list b)
{
list p, q,r,temp;
    p = a->next;
    q = b->next;
    r = a;
    while(p != NULL && q != NULL){
        if(p->expon > q->expon){
            r->next = p;
            r = p;
            p = p->next;
        }
        else if(p->expon < q->expon){
            r->next = q;
            r = q;
            q = q->next;
        }
        else{
            double sum = p->coef + q->coef;
            if(sum == 0){
                temp = p;
                p = p->next;
                free(temp);
                temp = q;
                q = q->next;
                free(temp);
            }
            else{
                p->coef = sum;
                r->next =p;
                r = p;
                p = p->next;
                temp = q;
                q = q->next;
                free(temp);
        }

    }
    r->next = NULL;
}
        if(p != NULL)
            r->next = p;
        if(q != NULL)
            r->next = q;
    return a;
    }

这道题思路不算特别难，但是操作起来确实是特别复杂，要注意的东西特别多。大家千万不能像我这样，不认真看题，不打草稿，不专注！后面会再编辑过一次的。