数据结构基础 一元多项式的乘法与加法运算

这道题呢，我写的超级长- -
我觉得可以缩减很多，但是我不想改了，就酱紫吧- -
*相乘那个函数可以把那个创建节点单独拎出来，相加那个也是。。
但是我不想改了
应该可以优化个30行的。。但是还好啦，就是难看了点- -*
02-线性结构2 一元多项式的乘法与加法运算（20 分）
设计函数分别求两个一元多项式的乘积与和。

输入格式:
输入分2行，每行分别先给出多项式非零项的个数，再以指数递降方式输入一个多项式非零项系数和指数（绝对值均为不超过1000的整数）。数字间以空格分隔。

输出格式:
输出分2行，分别以指数递降方式输出乘积多项式以及和多项式非零项的系数和指数。数字间以空格分隔，但结尾不能有多余空格。零多项式应输出0 0。

输入样例:
4 3 4 -5 2 6 1 -2 0
3 5 20 -7 4 3 1

输出样例:
15 24 -25 22 30 21 -10 20 -21 8 35 6 -33 5 14 4 -15 3 18 2 -6 1
5 20 -4 4 -5 2 9 1 -2 0

#include <stdio.h>
#include <stdlib.h>
typedef struct PolyNode{
    int coef;
    int expon;
    struct PolyNode* Next;
}Node;
typedef Node* PtrToNode;
typedef PtrToNode polynominal;

polynominal add(polynominal p1, polynominal p2);
polynominal multiple(polynominal p1,polynominal p2);
void Insert(polynominal p, PtrToNode node);
int tryFind(polynominal p,PtrToNode node);
void notFind(polynominal p, PtrToNode node);
polynominal readin(void);
void print(polynominal p);

int main(){
    polynominal p1, p2;
    p1 = readin();
    p2 = readin();

    polynominal Addp;
    Addp = add(p1, p2);
    polynominal mulp;
    mulp = multiple(p1, p2);

    print(mulp);
    printf("\n");
    print(Addp);
    return 0;
}

polynominal readin(void){
    PtrToNode p = (PtrToNode)malloc(sizeof(Node));
    p->Next = NULL;
    PtrToNode tmp = p;

    int num,coef,expon;
    scanf("%d",&num);
    while(num){
        scanf("%d",&coef);
        scanf("%d",&expon);
        PtrToNode node = (PtrToNode)malloc(sizeof(Node));
        node->coef = coef;
        node->expon = expon;
        node->Next = NULL;
        while (tmp->Next) {
            tmp = tmp->Next;
        }
        tmp->Next = node;
        num--;
    }
    return p;
}

void print(polynominal p){
    PtrToNode tmp;
    tmp = p->Next;
    if(tmp == NULL){
        printf("0 0");
    }else{
        while(tmp->Next){
            printf("%d %d ",tmp->coef,tmp->expon);
            tmp = tmp->Next;
        }
        printf("%d %d",tmp->coef,tmp->expon);
    }

}

/*p1 p2都分别设置一个方向指针tmp1,tmp2，对两个指针指向的节点；
 比较指数哪个更大 大的那边那个放入addp中，并向下一位，如果一样大则合并，两个都向下移一位
 我想了想，否则还是新建node吧,不想改变原本的p1,p2，不然会导致下一次运算出现问题
 所以导致了我的代码特别冗长-  -*/
polynominal add(polynominal p1, polynominal p2){
    polynominal addp,tmp;
    addp = (PtrToNode)malloc(sizeof(Node));
    addp->Next = NULL;
    tmp = addp;

    PtrToNode tmp1, tmp2;
    tmp1 = p1->Next;
    tmp2 = p2->Next;

    while (!(tmp1 == NULL && tmp2 == NULL)) {
        if(tmp1 == NULL && tmp2 != NULL){
            PtrToNode node = (PtrToNode)malloc(sizeof(Node));
            node->expon = tmp2->expon;
            node->coef = tmp2->coef;
            node->Next = NULL;
            tmp->Next = node;
            tmp = tmp->Next;
            tmp2 = tmp2->Next;
        }
        if(tmp1 != NULL && tmp2 == NULL){
            PtrToNode node = (PtrToNode)malloc(sizeof(Node));
            node->expon = tmp1->expon;
            node->coef = tmp1->coef;
            node->Next = NULL;
            tmp->Next = node;
            tmp = tmp->Next;
            tmp1 = tmp1->Next;
        }
        if(tmp1 != NULL && tmp2 != NULL){
            if ((tmp1->expon) > (tmp2->expon)) {/* 如果第一个的指数比第二个的指数要大 */
                PtrToNode node = (PtrToNode)malloc(sizeof(Node));
                node->expon = tmp1->expon;
                node->coef = tmp1->coef;
                node->Next = NULL;
                tmp->Next = node;
                tmp = tmp->Next;
                tmp1 = tmp1->Next;
            }else if (tmp1->expon == tmp2->expon){
                PtrToNode node = (PtrToNode)malloc(sizeof(Node));
                node->expon = tmp2->expon;
                node->coef = tmp1->coef + tmp2->coef;
                node->Next = NULL;
                if (node->coef == 0) {
                    free(node);
                    tmp1 = tmp1->Next;
                    tmp2 = tmp2->Next;
                    continue;
                }
                tmp->Next = node;
                tmp = tmp->Next;
                tmp1 = tmp1->Next;
                tmp2 = tmp2->Next;
            }else{
                PtrToNode node = (PtrToNode)malloc(sizeof(Node));
                node->expon = tmp2->expon;
                node->coef = tmp2->coef;
                node->Next = NULL;
                tmp->Next = node;
                tmp = tmp->Next;
                tmp2 = tmp2->Next;
            }
        }
    }
    return addp;
}

/*找得到指数相同的就直接加上去*/
int tryFind(polynominal p,PtrToNode node){
    int flag = 0;
    PtrToNode tmp,pre;
    tmp = p->Next;
    while (tmp) {
        if (tmp->expon == node->expon) {
            tmp->coef += node->coef;
            flag = 1;
            free(node);  /*不要忘了free掉*/
            if (tmp->coef == 0) {/*判断相加如果为零怎么办*/
                pre->Next = tmp->Next;
                PtrToNode s = tmp;
                free(s);
            }
        }
        pre = tmp;
        tmp = tmp->Next;
    }
    return flag;
}
/*找不到指数相同的就尝试找应该插入哪个位置*/
void notFind(polynominal p, PtrToNode node){
    PtrToNode tmp;
    tmp = p;
    int flag = 0;
    if (node->expon > tmp->Next->expon) {/*应该放在最前面*/
        node->Next = tmp->Next;
        tmp->Next = node;
        flag = 1;
    }else{
        while (tmp->Next) { /* 这里要认真点 不要出错了*/
            if (tmp->Next && tmp->expon > node->expon && tmp->Next->expon < node->expon) {
                node->Next = tmp->Next;/*应该放在中间*/
                tmp->Next = node;
                flag = 1;
                break;
            }
        tmp = tmp->Next;
        }
    }

    if(flag == 0)
        tmp->Next = node; /*应该放在最后*/
    return;
}
/* 插入节点 */
void Insert(polynominal p, PtrToNode node){
    PtrToNode tmp;
    tmp = p->Next;
    if (tmp == NULL) {
        p->Next = node;
    }else if(!tryFind(p, node)){
        notFind(p, node);
    }
}

polynominal multiple(polynominal p1,polynominal p2){
    polynominal mulp;
    mulp = (PtrToNode)malloc(sizeof(Node));
    mulp->Next = NULL;

    PtrToNode tmp1, tmp2;
    tmp1 = p1->Next;
    tmp2 = p2->Next;
    while (tmp1) {
        if (tmp1->coef == 0)
            continue;
        tmp2 = p2->Next;   /* 不要忘了重设 */
        while (tmp2) {
            if (tmp2->coef == 0) {
                continue;
            }
            PtrToNode node = (PtrToNode)malloc(sizeof(Node));
            node->expon = tmp1->expon + tmp2->expon;
            node->coef = tmp1->coef * tmp2->coef;
            node->Next = NULL;
            Insert(mulp,node);
            tmp2 = tmp2->Next;
        }
        tmp1 = tmp1->Next;
    }
    return mulp;
}