一元多项式计算器 数据结构

最新推荐文章于 2023-05-23 20:26:06 发布
置顶 最新推荐文章于 2023-05-23 20:26:06 发布
阅读量2.1k 收藏 20
点赞数 3
分类专栏： 数据结构 文章标签： 数据结构
Aroma
本文链接：https://blog.csdn.net/qq_43581283/article/details/105859165
版权

直接上代码，代码几乎没加注释，不懂可直接问我（实现了判断是否是稀疏结构进行存储）

#include <iostream>
#include <stdio.h>

#define MAXSIZE 10000  //表中元素的最大个数
#define OK 1
#define OVERFLOW -2
typedef int Status;
typedef int ElemType;  //元素类型
typedef struct xnode {
    ElemType x;//系数
    ElemType z;//指数
    struct xnode *next;
} XNode, *Xilist;
typedef struct cnode {//数组静态分配
    ElemType data[MAXSIZE];
    int length;//当前元素个数
} CNode, *Coulist;
char ch;

Status Initc(Coulist &C1, Coulist &C2);//初始化静态数组
Status Initx(Xilist &X1, Xilist &X2);//初始化链式表
Status CalculationOperationCou(Coulist &C1, Coulist &C2);//稠密多项式操作和计算
Status CalculationOperationXi(Xilist &X1, Xilist &X2);//稀疏多项式操作和计算
int main() {
    printf("=====请选择多项式是稀疏还是稠密?=====\n");
    printf("*****1、稀疏多项式运算，请按1*****\n");
    printf("*****2、稠密多项式运算，请按2*****\n");
    printf("请输入即将输入的多项式的类别序号1或者2：");
    int f;
    Xilist X1, X2;
    Coulist C1, C2;
    while (1) {
        scanf("%d", &f);
        if (f == 1) {
            if (Initx(X1, X2)) {
                printf("稀疏多项式存储结构初始化成功！\n");
                break;
            } else {
                printf("稀疏多项式存储结构初始化失败！\n");
                break;
            }
        } else if (f == 2) {
            if (Initc(C1, C2)) {
                printf("稠密多项式存储结构初始化成功！\n");
                break;
            } else {
                printf("稠密多项式存储结构初始化失败！\n");
                break;
            }
        } else
            printf("输入选择序号错误，请重新输入：");
    }
    printf("本程序只适合相减、相加、相乘运算,请输入将要进行的运算符号：");
    getchar();//吃掉空格
    scanf("%c", &ch);
    if (f == 2) {
        CalculationOperationCou(C1, C2);
    } else if (f == 1) {
        CalculationOperationXi(X1, X2);
    }

    return 0;
}

Status Initc(Coulist &C1, Coulist &C2) {
    C1 = new CNode;
    C2 = new CNode;
    if ((!C1) && (!C2)) {
        exit(OVERFLOW);
    } else {
        C1->length = 0;
        C2->length = 0;
        return OK;
    }
}

Status Initx(Xilist &X1, Xilist &X2) {
    X1 = new XNode;
    X1->next = NULL;
    X2 = new XNode;
    X2->next = NULL;
    if ((!X1) && (!X2)) {
        exit(OVERFLOW);
    } else {
        return OK;
    }
}

Status CalculationOperationCou(Coulist &C1, Coulist &C2) {

    int x, z, flag = 1;
    bool Bool = false;
    Coulist C3;
    C3 = new CNode;
    for (int k = 0; k < MAXSIZE; ++k) {
        C1->data[k] = 0;
        C2->data[k] = 0;
        C3->data[k] = 0;
    }
    printf("请输入多项式1的系数和指数，以0 0结束！\n");
    while (scanf("%d%d", &x, &z) && (x || z)) {//循环读取指数和系数
        C1->data[z] += x;
        C1->length++;
    }
    printf("请输入多项式2的系数和指数，以0 0结束！\n");
    while (scanf("%d%d", &x, &z) && (x || z)) {//循环读取指数和系数
        C2->data[z] += x;
        C2->length++;
    }
    if (ch == '+') {
        for (int i = 0; i < MAXSIZE; ++i) {
            if (C1->data[i] != 0) {
                C1->length--;
            }
            C2->data[i] = C2->data[i] + C1->data[i];
            if (!C1->length) {
                break;
            }
        }
    } else if (ch == '-') {
        for (int i = 0; i < MAXSIZE; ++i) {
            C2->data[i] = C2->data[i] - C1->data[i];
        }
    } else {
        for (int i = 0; i < MAXSIZE; ++i) {
            if (C1->data[i] == 0) {
                continue;
            }
            C1->length--;
            for (int j = 0; j < MAXSIZE; ++j) {
                if (C2->data[j] == 0) {
                    continue;
                }
                C2->length--;
                C3->data[i + j] += C2->data[j] * C1->data[i];
                if (!C2->length) {
                    break;
                }
            }
            if (!C1->length) {
                break;
            }
        }
        C2 = C3;
    }
    printf("=====请选择输出结果的幂序=====\n");
    printf("*****若想按照升序输入，请选择1*****\n");
    printf("*****若想按照降序输入，请选择2*****\n");
    while (1) {
        scanf("%d", &x);
        if (x != 1 && x != 2) {
            printf("你输入的序号有误，请重新输入：\n");
        } else {
            break;
        }
    }

    if (x == 1) {
        if (C2->data[0] != 0) {
            printf("%d", C2->data[0]);
            flag--;
            Bool = true;
        }
        for (int i = 1; i < MAXSIZE; ++i) {
            if (flag) {
                if (C2->data[i] > 0 && C2->data[i] != 1 && i != 1) {
                    printf("%dx^%d", C2->data[i], i);
                    flag--;
                    Bool = true;
                } else if (C2->data[i] < 0 && i != 1 && C2->data[i] == -1) {
                    printf("-x^%d", i);
                    flag--;
                    Bool = true;
                } else if (C2->data[i] < 0 && i == 1 && C2->data[i] == -1) {
                    printf("-x");
                    flag--;
                    Bool = true;
                } else if (C2->data[i] < 0 && i != 1 && C2->data[i] != -1) {
                    printf("%dx^%d", C2->data[i], i);
                    flag--;
                    Bool = true;
                } else if (C2->data[i] > 0 && C2->data[i] != 1 && i == 1) {
                    printf("%dx", C2->data[i]);
                    flag--;
                    Bool = true;
                } else if (C2->data[i] > 0 && C2->data[i] == 1 && i == 1) {
                    printf("x", i);
                    flag--;
                    Bool = true;
                } else if (C2->data[i] > 0 && C2->data[i] == 1 && i != 1) {
                    printf("x^%d", i);
                    flag--;
                    Bool = true;
                }
            } else {
                if (C2->data[i] > 0 && C2->data[i] != 1 && i != 1) {
                    printf(" + %dx^%d", C2->data[i], i);
                } else if (C2->data[i] < 0 && i != 1 && C2->data[i] == -1) {
                    printf("-x^%d", i);
                } else if (C2->data[i] < 0 && i == 1 && C2->data[i] == -1) {
                    printf("-x");
                } else if (C2->data[i] < 0 && i != 1 && C2->data[i] != -1) {
                    printf(" %dx^%d", C2->data[i], i);
                } else if (C2->data[i] > 0 && C2->data[i] != 1 && i == 1) {
                    printf(" + %dx", C2->data[i]);
                } else if (C2->data[i] > 0 && C2->data[i] == 1 && i == 1) {
                    printf(" + x");
                } else if (C2->data[i] > 0 && C2->data[i] == 1 && i != 1) {
                    printf(" + x^%d", i);
                }
            }
        }
        if (!Bool) {
            printf("0");
        }
    } else {
        int f = 0;
        for (int i = MAXSIZE - 1; i > 0; --i) {
            if (C2->data[i] < 0) {
                printf("%dx^%d", C2->data[i], i);
                f++;
                Bool = true;
            } else if (C2->data[i] > 0) {
                if (f != 0) {
                    printf(" + %dx^%d", C2->data[i], i);
                    f++;
                    Bool = true;
                } else {
                    printf("%dx^%d", C2->data[i], i);
                    f++;
                    Bool = true;
                }

            }
        }
        if (C2->data[0] > 0) {
            printf(" + %d", C2->data[0]);
        } else if (C2->data[0] < 0) {
            printf(" %d", C2->data[0]);
        }
        if (!Bool) {
            printf("0");
        }
    }

    return 0;

}

Status CalculationOperationXi(Xilist &X1, Xilist &X2) {
    XNode *x1, *x2;
    printf("请输入多项式1的系数和指数，以0 0结束！\n");
    x1 = X1;
    x2 = new XNode;
    while (scanf("%d%d", &x2->x, &x2->z) && (x2->x || x2->z)) {//循环读取指数和系数
        x1->next = x2;
        x2->next = NULL;
        x1 = x2;
        x2 = new XNode;
    }
    x1 = X2;
    printf("请输入多项式2的系数和指数，以0 0结束！\n");
    while (scanf("%d%d", &x2->x, &x2->z) && (x2->x || x2->z)) {//循环读取指数和系数
        x1->next = x2;
        x2->next = NULL;
        x1 = x2;
        x2 = new XNode;
    }
    XNode *x4, *x5, *p, *q;//临时变量，分别指向X1，X2
    x4 = X1->next;

    x5 = X2->next;

    while (x4) {//重复指数项合并
        p = x4->next;
        while (p) {
            if (x4->z == p->z) {
                x4->x += p->x;
                p->z = 0;
                p->x = 0;
            } else {
                p = p->next;
            }
        }
        x4 = x4->next;
    }

    while (x5) {//重复指数项合并
        q = x5->next;
        while (q) {
            if (x5->z == q->z) {
                x5->x += q->x;
                q->z = 0;
                q->x = 0;
            } else {
                q = q->next;
            }
        }
        x5 = x5->next;
    }
    Xilist X3;
    X3 = new XNode;
    X3->next = NULL;
    p = X3;
    x5 = X1->next;
    x4 = X2->next;
    if (ch == '+') {
        while (x4) {
            int flag = 0;
            if (x4->z || x4->x) {
                while (x5) {
                    if ((x4->z == x5->z) && (x5->z || x5->x)) {
                        q = new XNode;
                        q->next = NULL;
                        q->x = x4->x + x5->x;
                        q->z = x4->z;
                        x5->x = 0;
                        x5->z = 0;
                        flag = 1;
                        p->next = q;
                        p = p->next;
                        flag++;
                    }
                    x5 = x5->next;
                }
                if (flag == 0) {
                    q = new XNode;
                    q->next = NULL;
                    q->x = x4->x;
                    q->z = x4->z;
                    x4->x = 0;
                    x4->z = 0;
                    x4->x = 0;
                    p->next = q;
                    p = p->next;
                }
            }
            x4->x = 0;
            x4->z = 0;
            x4 = x4->next;
            x5 = X1->next;
        }
        x5 = X1->next;
        for (x5; x5 != NULL; x5 = x5->next) {
            if (x5->x != 0) {
                q = new XNode;
                q->next = NULL;
                q->x = x5->x;
                q->z = x5->z;
                x5->x = 0;
                p->next = q;
                p = p->next;
            }
        }
        x4 = X2->next;
        for (x4; x4 != NULL; x4 = x4->next) {
            if (x4->x != 0) {
                q = new XNode;
                q->next = NULL;
                q->x = x4->x;
                q->z = x4->z;
                x4->x = 0;
                p->next = q;
                p = p->next;
            }
        }
    } else if (ch == '-') {
        while (x4) {
            int flag = 0;
            if (x4->z || x4->x) {
                while (x5) {
                    if ((x4->z == x5->z) && (x5->z || x5->x)) {
                        q = new XNode;
                        q->next = NULL;
                        q->x = x4->x - x5->x;
                        q->z = x4->z;
                        x5->x = 0;
                        x5->z = 0;
                        flag = 1;
                        p->next = q;
                        p = p->next;
                        flag++;
                    }
                    x5 = x5->next;
                }
                if (flag == 0) {
                    q = new XNode;
                    q->next = NULL;
                    q->x = x4->x;
                    q->z = x4->z;
                    x4->x = 0;
                    x4->z = 0;
                    x4->x = 0;
                    p->next = q;
                    p = p->next;
                }
            }
            x4->x = 0;
            x4->z = 0;
            x4 = x4->next;
            x5 = X1->next;
        }
        x5 = X1->next;
        for (x5; x5 != NULL; x5 = x5->next) {
            if (x5->x != 0) {
                q = new XNode;
                q->next = NULL;
                q->x = 0 - x5->x;
                q->z = x5->z;
                x5->x = 0;
                p->next = q;
                p = p->next;
            }
        }
        x4 = X2->next;
        for (x4; x4 != NULL; x4 = x4->next) {
            if (x4->x != 0) {
                q = new XNode;
                q->next = NULL;
                q->x = x4->x;
                q->z = x4->z;
                x4->x = 0;
                p->next = q;
                p = p->next;
            }
        }
    } else {
        while (x4) {
            if (x4->x) {
                while (x5) {
                    if (x5->x) {
                        q = new XNode;
                        q->next = NULL;
                        q->x = x4->x * x5->x;
                        q->z = x4->z + x5->z;
                        p->next = q;
                        p = p->next;
                    }
                    x5 = x5->next;
                }
            }
            x4 = x4->next;
            x5 = X1->next;
        }
    }
    x5 = X3->next;

    while (x5) {//重复项合并
        q = x5->next;
        while (q) {
            if (x5->z == q->z) {
                x5->x += q->x;
                q->z = 0;
                q->x = 0;
            } else {
                q = q->next;
            }

        }
        x5 = x5->next;
    }
    int x, flag = 0;
    printf("=====请选择输出结果的幂序=====\n");
    printf("*****若想按照升序输入，请选择1*****\n");
    printf("*****若想按照降序输入，请选择2*****\n");
    while (1) {
        scanf("%d", &x);
        if (x != 1 && x != 2) {
            printf("你输入的序号有误，请重新输入：\n");
        } else {
            break;
        }
    }

    if (x == 1) {
        //排序小到大
        x5 = X3->next;
        for (x5; x5 != NULL; x5 = x5->next) {
            int t;
            for (x4 = x5->next; x4 != NULL; x4 = x4->next) {
                if (x5->z > x4->z) {
                    t = x5->z;
                    x5->z = x4->z;
                    x4->z = t;
                    t = x5->x;
                    x5->x = x4->x;
                    x4->x = t;
                }
            }
        }
        X3 = X3->next;
        while (X3) {
            if (flag) {
                if (X3->z == 0) {
                    if (X3->x > 0) {
                        printf(" + %d", X3->x);
                    } else if (X3->x < 0) {
                        printf(" %d", X3->x);
                    }

                } else {
                    if (X3->x > 0 && X3->x != 1 && X3->z != 1) {
                        printf(" + %dx^%d", X3->x, X3->z);
                    } else if (X3->x > 0 && X3->x != 1 && X3->z == 1) {
                        printf(" + %dx", X3->x);
                    } else if (X3->x > 0 && X3->x == 1 && X3->z == 1) {
                        printf(" + x");
                    } else if (X3->x > 0 && X3->x == 1 && X3->z != 1) {
                        printf(" + x^%d", X3->z);
                    } else if (X3->x < 0 && X3->x != -1 && X3->z != 1) {
                        printf(" %dx^%d", X3->x, X3->z);
                    } else if (X3->x < 0 && X3->x != -1 && X3->z == 1) {
                        printf(" %dx", X3->x);
                    } else if (X3->x < 0 && X3->x == -1 && X3->z == 1) {
                        printf(" -x");
                    } else if (X3->x < 0 && X3->x == -1 && X3->z != 1) {
                        printf(" -x^%d", X3->z);
                    }
                }
            } else {
                if (X3->z == 0) {
                    printf("%d", X3->x);
                } else if (X3->z == 1 && X3->x == 1) {
                    printf("x");
                } else if (X3->x == -1 && X3->z == 1) {
                    printf("-x");
                } else if (X3->x == -1 && X3->z != 1) {
                    printf("-x^%d", X3->z);
                } else if (X3->z == 1 && X3->x != 1) {
                    printf("%dx", X3->x);
                } else if (X3->z != 1 && X3->x == 1) {
                    printf("x^%d", X3->x);
                } else {
                    printf("%dx^%d", X3->x, X3->z);
                }
                flag++;
            }
            X3 = X3->next;
        }
    } else if (x == 2) {
        //排序大到小
        x5 = X3->next;
        for (x5; x5 != NULL; x5 = x5->next) {
            int t;
            for (x4 = x5->next; x4 != NULL; x4 = x4->next) {
                if (x5->z < x4->z) {
                    t = x5->z;
                    x5->z = x4->z;
                    x4->z = t;
                    t = x5->x;
                    x5->x = x4->x;
                    x4->x = t;
                }
            }
        }
        X3 = X3->next;
        while (X3) {
            if (flag) {
                if (X3->z == 0) {
                    if (X3->x > 0) {
                        printf(" + %d", X3->x);
                    } else if (X3->x < 0) {
                        printf(" %d", X3->x);
                    }

                } else {
                    if (X3->x > 0 && X3->x != 1 && X3->z != 1) {
                        printf(" + %dx^%d", X3->x, X3->z);
                    } else if (X3->x > 0 && X3->x != 1 && X3->z == 1) {
                        printf(" + %dx", X3->x);
                    } else if (X3->x > 0 && X3->x == 1 && X3->z == 1) {
                        printf(" + x");
                    } else if (X3->x > 0 && X3->x == 1 && X3->z != 1) {
                        printf(" + x^%d", X3->z);
                    } else if (X3->x < 0 && X3->x != -1 && X3->z != 1) {
                        printf(" %dx^%d", X3->x, X3->z);
                    } else if (X3->x < 0 && X3->x != -1 && X3->z == 1) {
                        printf(" %dx", X3->x);
                    } else if (X3->x < 0 && X3->x == -1 && X3->z == 1) {
                        printf(" -x");
                    } else if (X3->x < 0 && X3->x == -1 && X3->z != 1) {
                        printf(" -x^%d", X3->z);
                    }
                }
            } else {
                if (X3->z == 0) {
                    printf("%d", X3->x);
                } else if (X3->z == 1 && X3->x == 1) {
                    printf("x");
                } else if (X3->x == -1 && X3->z == 1) {
                    printf("-x");
                } else if (X3->x == -1 && X3->z != 1) {
                    printf("-x^%d", X3->z);
                } else if (X3->z == 1 && X3->x != 1) {
                    printf("%dx", X3->x);
                } else if (X3->z != 1 && X3->x == 1) {
                    printf("x^%d", X3->x);
                } else {
                    printf("%dx^%d", X3->x, X3->z);
                }
                flag++;
            }
            X3 = X3->next;
        }
    }
}
不许人间见白头～
关注
专栏目录
【数据结构-C语言】一元多项式计算器
Brave_Runer的博客
04-29 4401
#include <stdio.h> #include <stdlib.h> typedef struct PolyNode *Polynomial;//存储结构为：带头节点的单链表 struct PolyNode { int coef;//多项式系数 int expon;//多项式指数 Polynomial next;//指向下一个节点 }; t...
数据结构：一元多项式
weixin_52485836的博客
03-24 670
1.头文件(poly.h) #pragma once typedef struct { float coef;//系数 int expn;//指数 }trem,ElemType; typedef struct PNode { ElemType data;;//数据 (系数+指数) struct PNode* next;//后继指针 }PNode,*Poly; //初始化带头结点多项式 void InitPoly(Poly po); //往po多项式插入数据val,按照指数升序 bool .
数据结构——一元多项式计算
11-25
　用Ｃ＋＋完成一元稀疏多项式的加、减、乘、求导、求值运算　功能很强大
数据结构一元多项式的计算
06-21
并较完善的一元多项式计算代码，能够实现一元多项式的加减运算！并且正确输出结果！
一元多项式计算-数据结构设计报告
04-15
基于线性表的一元多项式计算-数据结构设计报告，欢迎大家试用。
数据结构 一元多项式运算
小胡同的诗
04-20 9240
链表的生成利用链表实现一元多项式的+、-、*运算，注意具体的思路是判断同类项，对其进行合并同类项，在乘法运算达到了O(n^3)，可以优化的地方是先对结果链表C进行预处理，先复制这个链表给C，然后表C的操作过程就将了一维，变成O(n^2)，并且每次可以利用链表的有序性这一点进行二分，但这是链表啊！怎么二分？还没想到，干脆把链表先导入数组中，然后在操作？这样就O(nlogn)了？....扯远了，就先O...
数据结构-------一元多项式运算
weixin_46061565的博客
05-02 423
两个一元多项式相加。 比如输入 x+x2+x4 x+2x2+x3 之后的结果为 2x+3x2+x3+x^4 输入输出样例：1组 #1 样例输入： //输入第一个多项式，按照系数、指数的形式输入每一个子项！ 1 1 1 2 1 4 0 0 //输入结束的条件，系数和指数同时为0时输入结束 1 1 2 2 1 3 0 0 样例输出： 2 1 3 2 1 3 1 4 //注意 //1:该程序每次运行的时间必须小于10秒，否则会超时,程序超时将不会测试剩余的测试集 //
一元稀疏多项式计算器 数据结构课程设计
06-11
在本课程设计中，主题是“一元稀疏多项式计算器”，这是一项针对数据结构学习者的重要实践任务。数据结构是计算机科学中的基石，它研究如何有效地存储和组织数据，以便于高效地进行访问和操作。在这个项目中，我们将...
一元多项式计算器.zip_C++_attentionyhs_单链表实现一元多项式_数据结构_表达式 计算器
07-14
（2）设有一元多项式Am(x)和Bn(x). Am(x)=A0+A1x1+A2x2+A3x3+...+Amxm Bn(x)=B0+B1x1+B2x2+B3x3+...+Bnxn 请实现求M(x)=Am(x)+Bn(x)、M(x)=Am(x)-Bn(x)、M(x)=Am(x)×Bn(x)以及计算M(x)=0的根，计算多项式在x处的...
哈工大数据结构实验一_一元多项式计算器
03-26
实验题目：一元多项式计算器 实验内容： 设计线性表的动态或者静态链式存储结构，并实现一个一元多项式的计算器。 实验要求： 以动态或者静态链表存储一元多项式，在此基础上按要求完成对一元多项式 的运算。（为...
简单的一元多项式计算器程序
10-13
(1)能够实现输入并建立多项式； (2)能够实现输出多项式； (3)能够实现两个多项式相加，建立并输出和多项式； (4)能够实现两个多项式相减，建立并输出差多项式。
数据结构实现一元多项式的运算
04-27
用数据结构的相关知识中的链表实现一元多项式的运算，深入理解链表的插入删除等操作。
一元多项式 计算器
12-12
c++编程实现 输入两个一元多项式做加减计算 用链表做的
一个一元多项式简单的计算器
02-23
一元多项式计算器的基本功能定为 (1) 建立多项式 (2) 输出多项式 (3) 两个多项式相加，建立并输出和多项式 (4) 两个多项式相减，建立并输出差多项式 实现提示：可选择带头结点的单向循环链表 或单链表存储多项式，头结点可存放多项式 的参数，如项数等。 希望对大家有帮助，我们都加油吧。
设计一个一元多项式简单的计算器
06-01
本程序中，分别输入两个多项式P（X）和Q（X）的系数a和指数e；系数a为实数，指数e为大于-1的整数。建立好两个多项式，输入0、1、2、3分别表示加法、减法、乘法、退出。输入的形式为一个以“回车符”为结束标志。
一元多项式计算器数据结构
最新发布
05-11
一元多项式计算器是一种基于数据结构实现的计算器，可以用于对一元多项式进行各种基本运算，如加、减、乘、除、求导、积分等。它通常采用链表作为数据结构来存储多项式中的每一项，并对每一项进行必要的操作，例如...
一元多项式计算器(哈工大数据结构作业)
10-15
在哈工大的数据结构课程中，一元多项式计算器是一个典型的编程作业，旨在帮助学生深入理解和应用数据结构。这个计算器的实现涉及到多项式表示、加法、减法、乘法等基本运算，以及可能的优化策略。下面我们将详细讨论...
数据结构（严蔚敏）【一元多项式的运算】【C语言】
热门推荐
java小豪的博客
10-01 1万+
将顺序表数组下标作为多项式的指数项，数组内的数据元素存放多项式的系数，通过访问数组内元素的同时获取下标并对二者进行不同的运算后，将运算结果依旧按原形式放入新的数组中，完成对两个多项式的加减乘运算。用顺序存储结构实现一元多项式的加法、减法和乘法。具体要求为：用五个函数分别实现一元多项式的创建、输出、加法、减法和乘法；
数据结构（C语言）：一元多项式的操作（链表实现）
lbcbjtlhmjq的博客
05-23 1959
设有两个一元多项式：多项式项的系数为实数，指数为整数，设计实现一元多项式操作的程序：① 多项式链表建立：以（系数，指数）方式输入项建立多项式，返回所建立的链表的头结点；② 多项式排序：将所建立的多项式按指数非递减（从小到大）进行排序；③ 多项式相加：实现两个多项式相加操作。操作生成一个新的多项式，原有的两个多项式不变，返回生成的多项式的头结点；④ 多项式的输出；⑤ 主函数通过调用多项式链表建立函数，输入两个多项式并分别输出；输出排序后的两个多项式；
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值