需要了解的概念:结构体指针和链表

目录

1.要求

2.所需函数

3.整体思路

4.执行过程

1.创建多项式

2.插入项

3.其他函数

5.总体代码


 首先,这是数据结构老师布置的实验结构的作业,课上的时候没有怎么听,但是由于这个实验老师要现删代码让我们补,所以,糊弄肯定是不那么简单的,代码有点多,背代码真的不太现实,所以打算自己写,参考别人的代码,边理解边写

PS:代码参考了AI的思路(deepseek的生成的代码放在了结尾),和AI的部分代码

首先,先要了解一下什么是一元多项式(如下图)

如上图,有一个未知变量,变量旁边有系数和指数,具体概念可以去查数学课本上查一下

如果要把这个一元多项式在控制台输出出来,就是以下的形式:x^4 - 3 x^2 + 5 

废话不多说那就开始写把

1.要求

创建两个一元多项式

对两个多项式进行加、减、乘的运算;

对多项式进行升幂和降幂的输出;

x^4 - 3 x^2 + 5 (降幂)

5 + x^4 - 3 x^2( 升幂)

2.所需函数

因为程序有些复杂,所以就避免不了写亿些函数,函数已经在下面罗列出来了

    typedef struct poly
    {
        int coef; //系数
        int expo; //指数
        struct poly* next; //指向下一个项(结构体的指针)
    }*Polynomial;
    //宏定义项(起一个别名,目的是区分 多项式 和 项)

    #define Item Polynomial
    //这两个指针都是 struct poly 结构体的指针,一个是项的指针,一个是多项式的头指针
   
     Polynomial CreatePolynomial();//创建多项式

    void freePolynomial(Polynomial head);//释放多项式各个项的指针的内存

    Item CreateItem(int coef,int expo); //创建项

    void InserItem(Polynomial head,int coef,int expo);//向多项式中插入项

    void printPolynomial(Polynomial head);//打印多项式

    void DecPrintPolynomial(Polynomial head);//降序打印

    Polynomial AddPolynomial(Polynomial head_a, Polynomial head_b);//多项式相加

    Polynomial MinusPolynomial(Polynomial head_a, Polynomial head_b);//多项式相减

    Polynomial MultiplyPolynomials(Polynomial head_a, Polynomial head_b);//多项式相减

共有九个函数,分别按照使用顺序进行排列出来了 

3.整体思路

一元多项式的创建运用到了链式表的思路,所以就用到了指针,别问问为什么非得用指针,不用实验不符合要求而且肯定会不好写

为了更加直观的展示,我画了一张图作为参考

如图,我们要用到三个变量:系数(coef)、指数(expo)、指向下一个项(Item)的指针,其中系数和指数我们要用到整形变量,此外还有一个指向地址的指针,同时存多种变量类型的数据就要用到结构体,结构体的定义如下

struct poly
    {
        int coef; //系数
        int expo; //指数
        struct poly* next; //指向下一个项(结构体的指针)
    };

不过因为我们在写代码的时候会多次用到结构体(也就是Item)指针,所以我们在定义的时候给它起几个别名

 typedef struct poly
    {
        int coef; //系数
        int expo; //指数
        struct poly* next; //指向下一个项(结构体的指针)
    }*Polynomial;

 #define Item Polynomial

  //这两个指针都是 struct poly 结构体的指针,一个是项的指针,一个是多项式的头指针

这样可以少写很多 “*” 

Item 是项的英文

Polynomial 是多项式的英文

4.执行过程

可以参考main函数中的内容

int main()
{
    /*
    两个多项式指针,a,b
    result是多项式进行运算后的指针
    */
    Polynomial poly_a=NULL,poly_b=NULL,result=NULL;
    int choice;
    while (1) {
        printf("\n多项式运算菜单:\n");
        printf("1. 输入多项式A和B\n");//要先进行操作1,添加多项式
        printf("2. 加法运算\n");
        printf("3. 减法运算\n");
        printf("4. 乘法运算\n");
        printf("5. 打印多项式\n");
        printf("6. 降序打印多项式\n");
        printf("请选择操作:");
        scanf("%d", &choice);
        switch (choice) {
        case 1:
            if (poly_a != NULL) freePolynomial(poly_a);
            //添加多项式前要先检查多项式是否已经存在,如果存在,那就释放内存
            if (poly_b != NULL) freePolynomial(poly_b);
            poly_a=CreatePolynomial();//添加多项式,赋的值为多项式的头指针
            printf("请输入第二个多项式");
            poly_b=CreatePolynomial();
            break;
        case 2:
            result=AddPolynomial(poly_a,poly_b);
            printPolynomial(result);
            DecPrintPolynomial(result);
            break;
        case 3:
            result=MinusPolynomial(poly_a,poly_b);
            printPolynomial(result);
            DecPrintPolynomial(result);
            break;
        case 4:
            result=MultiplyPolynomials(poly_a,poly_b);
            printPolynomial(result);
            DecPrintPolynomial(result);
            break;
        case 5:
            printPolynomial(poly_a);
            printPolynomial(poly_b);
            break;
        case 6:
            DecPrintPolynomial(poly_a);
            DecPrintPolynomial(poly_b);
            break;
        default:
            break;
        }
    }
}

首先定义三个Polynomial变量,就是指向结构体的指针,先定义为空,之后再让它们等于多项式的头指针(通过创建多项式和进行运算操作后)

1.创建多项式

参考我之前画的那张图,我们进行的是链式表的操作,所以我们要的其实就是一个(头)指针,这个(头)指针起的是一个定位的作用,可以把这个头指针理解成一个 “门”?

Polynomial CreatePolynomial()//创建多项式
{
    Polynomial head=CreateItem(0,0);
    //创建多项式的头指针,头指针其定位的作用
    //作用只是指向下一个项(结构体)的地址(位置)
    int coef,expo;
    while(1)//这个循环是用来创建项的,两个两个的输入,碰到0 0就会终止
    {
        #ifdef LOGOUT
            printf("请输入 系数 指数 ,然后回车,指数(输入0 0结束):");
        #endif
        scanf("%d %d",&coef,&expo);//不过输入的时候还是要判断一下的,看看那些能输入
        if (coef == 0 && expo == 0) break;//终止输入符
        if(coef !=0)//因为系数如果输入零就没有意义了
            InserItem(head,coef,expo);//项插入的函数

        #ifdef LOGOUT
        else
            printf("系数为0.跳过");
        #endif

    }
    printf("输入完成一个多项式");
    return head;
}

 我们首先要创建一个头指针,并对它进行初始化,所谓初始化,就是给你定义的结构体变量手动分配内存。头指针其实和其他项的指针没有任何本质区别都是结构体指针,怎么手动分配可以自行搜索一下(需要用到malloc函数),头指针的系数和指数随便定义,因为用不到,要的只是那个指向下一个项的指针

Item CreateItem(int coef,int expo)//创建项,创建头指针
{
    Item NewItem=(Item)malloc(sizeof(struct poly));//分配内存
    if(NewItem==NULL)
    {
        printf(" 内存分配失败\n");
    }
    NewItem->coef=coef;
    NewItem->expo=expo;
    NewItem->next=NULL;
    #ifdef LOGOUT
        printf("项创建成功\n");
    #endif
    return NewItem;
}

 这个函数同样适用于创建项

2.插入项

接下来就要开始插入项了,这个插入项的函数的功能很强大,以至于老师说我们模块化做得不行

它可以在插入的时候自动检测,最终让你插入的项进行升幂排序

void InserItem(Polynomial head,int coef,int expo)//向一个多项式中插入项
{
    //定义变量的时候有点问题,pre应该是head,cur应该是head->next
    //凑合看吧
    Polynomial pre=NULL;//指向上一个结构体的指针
    Polynomial cur=head;//指向当前结构体的指针


    //因为head这个指针指向的结构体的数据(系数、指数)不会使用,要的只是head中指向下一个结构体的地址
    //所以一开始插入的逻辑就是让head的next指针指向下一个结构体地址
    while(cur->next!= NULL && cur->next->expo < expo)
    //插入的时候会按指数的大小进行排序,如果插入项的指数比较大,就会往后排
    //每次插入的时候都是从head指针开始遍历的,所以只要检测出cur->next->expo不小于插入项的系数就会跳出循环
    {
        pre=cur;//指针整体后移动
        cur=cur->next;
    }
    #ifdef LOGOUT
        printf("当前指数%d\n",cur->expo);//查看从那个指数后面插入
    #endif
    if(cur->next!= NULL && cur->next->expo == expo)//如果发现插入的项的指数一样,那就
    {
        pre=cur;
        cur=cur->next;
        cur->coef+=coef;//让系数相加就行了
        #ifdef LOGOUT
            printf("系数合并成功\n");
        #endif
        if(cur->coef==0)//系数正负抵消变为0
        {
            pre->next=cur->next;//跳过这一一个位置
            free(cur);//并释放当前地址的内存
        }
    }
    else//只要是指数不相等,无论指数过大还是过小,都用这种思路
    {
        if(cur->next)//下一个位置有地址说明插入的指针是偏小的
        {
            pre=cur->next;//存一下原来下一个结构体的地址,防止地址丢失
            cur->next=CreateItem(coef,expo);//插入进去然后重新指一下
            cur=cur->next;//后移一位
            cur->next=pre;//然后让下一个位置指向原来的地址

        }
        else//下一个位置没有地址,说明是向最后一个位置后面插的
        {
            cur->next=CreateItem(coef,expo);//就正常指就行
            //cur=cur->next;
        }

    }
}

插入项要考虑的情况有,项的正常插入,同指数项系数相加,系数相加为0的情况

3.其他函数

剩下的函数还有,升幂降幂打印,多项式的加、减、乘运算,相比较于插入函数都简单到💥了,

5.总体代码

我写的 

#include <stdio.h>
#include <stdlib.h>

#define LOGOUT
//定义宏,用来控制一些输出,注释掉会少很多输出
/*
 * 这个宏牵扯到这个语句
 * #ifdef LOGOUT
 * --要执行的语句
 * #endif
 * 意思就是如果通过#define定义了LOGOUT(不需要给值)
 * 就执行其中的语句
 * 与#ifdef同语法的有#ifndef(如果没有定义)
 * 就比如这个头文件的第一行和最后一行
 */

typedef struct poly
{
    int coef; //系数
    int expo; //指数
    struct poly* next; //指向下一个项(结构体的指针)
}*Polynomial;


//宏定义项(起一个别名,目的是区分 多项式 和 项)
#define Item Polynomial

//这两个指针都是 struct poly 结构体的指针,一个是项的指针,一个是多项式的头指针

Item CreateItem(int coef,int expo)//创建项
{
    Item NewItem=(Item)malloc(sizeof(struct poly));//分配内存
    if(NewItem==NULL)
    {
        printf(" 内存分配失败\n");
    }
    NewItem->coef=coef;
    NewItem->expo=expo;
    NewItem->next=NULL;
    #ifdef LOGOUT
    printf("项创建成功\n");
    #endif
    return NewItem;
}

void InserItem(Polynomial head,int coef,int expo)//向一个多项式中插入项
{
    //定义变量的时候有点问题,pre应该是head,cur应该是head->next
    //凑合看吧
    Polynomial pre=NULL;//指向上一个结构体的指针
    Polynomial cur=head;//指向当前结构体的指针


    //因为head这个指针指向的结构体的数据(系数、指数)不会使用,要的只是head中指向下一个结构体的地址
    //所以一开始插入的逻辑就是让head的next指针指向下一个结构体地址
    while(cur->next!= NULL && cur->next->expo < expo)
        //插入的时候会按指数的大小进行排序,如果插入项的指数比较大,就会往后排
        //每次插入的时候都是从head指针开始遍历的,所以只要检测出cur->next->expo不小于插入项的系数就会跳出循环
    {
        pre=cur;//指针整体后移动
        cur=cur->next;
    }
    #ifdef LOGOUT
    printf("当前指数%d\n",cur->expo);//查看从那个指数后面插入
    #endif
    if(cur->next!= NULL && cur->next->expo == expo)//如果发现插入的项的指数一样,那就
    {
        pre=cur;
        cur=cur->next;
        cur->coef+=coef;//让系数相加就行了
        #ifdef LOGOUT
        printf("系数合并成功\n");
        #endif
        if(cur->coef==0)//系数正负抵消变为0
        {
            pre->next=cur->next;//跳过这一一个位置
            free(cur);//并释放当前地址的内存
        }
    }
    else//只要是指数不相等,无论指数过大还是过小,都用这种思路
    {
        if(cur->next)//下一个位置有地址说明插入的指针是偏小的
        {
            pre=cur->next;//存一下原来下一个结构体的地址
            cur->next=CreateItem(coef,expo);//插入进去然后重新指一下
            cur=cur->next;//后移一位
            cur->next=pre;//然后让下一个位置指向原来的地址

        }
        else//下一个位置没有地址,说明是向最后一个位置后面插的
        {
            cur->next=CreateItem(coef,expo);//就正常指就行
            //cur=cur->next;
        }

    }
}

void freePolynomial(Polynomial head)//释放多项式各个项的指针的内存
{
    Polynomial current = head->next;
    while (current != NULL)//看下一个位置是否有地址
    {
        Polynomial temp = current;
        current = current->next;
        free(temp);//有的话就释放
    }
    free(head);//顺带把头指针也释放了
}

Polynomial CreatePolynomial()//创建多项式
{
    Polynomial head=CreateItem(0,0);
    //创建多项式的头指针,头指针其定位的作用
    //作用只是指向下一个项(结构体)的地址(位置)
    int coef,expo;
    while(1)//这个循环是用来创建项的,两个两个的输入,碰到0 0就会终止
    {
        #ifdef LOGOUT
        printf("请输入 系数 指数 ,然后回车,指数(输入0 0结束):");
        #endif
        scanf("%d %d",&coef,&expo);//不过输入的时候还是要判断一下的,看看那些能输入
        if (coef == 0 && expo == 0) break;//终止输入符
        if(coef !=0)//因为系数如果输入零就没有意义了
            InserItem(head,coef,expo);//项插入的函数

            #ifdef LOGOUT
            else
                printf("系数为0.跳过");
        #endif

    }
    printf("输入完成一个多项式");
    return head;
}

void printPolynomial(Polynomial head)//打印多项式
{
    if(head->next==NULL)//先判断多项式是否为空,不为空才能打印
    {
        printf("多项式为空\n");
        return;
    }
    while(head->next)//遍历打印
    {
        if(head->next->expo)//指数为不为0就把指数打印出来
            printf("%dx^%d",head->next->coef,head->next->expo);
        else//为0就只打印系数
            printf("%d",head->next->coef);
        head=head->next;//后移一位
        if(head->next !=NULL && head->next->coef > 0 )printf("+");//打印"+"号

    }
    printf("打印完毕\n");
}

void DecPrintPolynomial(Polynomial head)//降序打印
{
    //思路就是通过while循环先看多项式存了多少个数据
    //然后两层for循环,外层是看需要打印多少个数据,内层是要打印的数据的位置
    Polynomial p=head;
    int index=0;
    while (p->next)//根据下一个位置是存数据来判断
    {
        index++;
        p=p->next;
    }
    p=head;//重置
    int Index=index;
    //printf("index=%d\n",index);
    for (int i = 0; i < Index; i++)//几个数据循环几次,打印几次
    {
        for (int j = index; j >0; j--)//因为是降幂打印,所以是递减的
        {
            p=p->next;
        }
        if(p->coef > 0 && Index != index)printf("+");
        //第一次打印数据前不需要写"+"号
        //系数小于零就更不用打印"+"号,负数自带符号
        if(p->expo)//老样子
            printf("%dx^%d",p->coef,p->expo);
        else
            printf("%d",p->coef);
        index--;
        p=head;//重置

    }
    printf("降幂打印结束\n");
}

Polynomial AddPolynomial(Polynomial head_a, Polynomial head_b)//多项式相加
{
    //总体思路就是把两个多项式的    项    挨个插入(有自己写的插入函数)到一个新的多项式中
    Polynomial result=CreateItem(0,0);
    Polynomial pa=head_a;
    Polynomial pb=head_b;
    while(pa->next)//插到底
    {
        pa=pa->next;
        //printf("A的%d %d\n",pa->coef,pa->expo);
        InserItem(result,pa->coef,pa->expo);
    }
    while(pb->next!=NULL)//插到底
    {
        pb=pb->next;
        InserItem(result,pb->coef,pb->expo);
        //printf("B的%d %d\n",pb->coef,pb->expo);
    }
    return result;//返回
}

Polynomial MinusPolynomial(Polynomial head_a, Polynomial head_b)//多项式相减
{
    //和相加一样,就是把其中一个多项式的项在插入的时候把系数变为其相反数
    Polynomial result=CreateItem(0,0);
    Polynomial pa=head_a;
    Polynomial pb=head_b;
    while(pa->next)
    {
        pa=pa->next;
        //printf("A的%d %d\n",pa->coef,pa->expo);
        InserItem(result,pa->coef,pa->expo);
    }
    while(pb->next!=NULL)
    {
        pb=pb->next;
        InserItem(result,-(pb->coef),pb->expo);//系数取反
        //printf("B的%d %d\n",pb->coef,pb->expo);
    }
    return result;
}

Polynomial MultiplyPolynomials(Polynomial head_a, Polynomial head_b)//多项式相乘
{
    //一个多项式的各个项与另一个多项式的各个项进行乘法运算
    Polynomial result=CreateItem(0,0);
    Polynomial pa=head_a;
    Polynomial pb=head_b;
    while(pa->next)//嵌套while循环
    {
        pa=pa->next;
        while(pb->next)
        {
            pb=pb->next;
            int coef=pa->coef*pb->coef;
            int expo=pa->expo+pb->expo;
            InserItem(result,coef,expo);
        }
        pb=head_b;//重置一下
    }
    return result;
}


int main()
{
    /*
     *    两个多项式指针,a,b
     *    result是多项式进行运算后的指针
     */
    Polynomial poly_a=NULL,poly_b=NULL,result=NULL;
    int choice;
    while (1) {
        printf("\n多项式运算菜单:\n");
        printf("1. 输入多项式A和B\n");//要先进行操作1,添加多项式
        printf("2. 加法运算\n");
        printf("3. 减法运算\n");
        printf("4. 乘法运算\n");
        printf("5. 打印多项式\n");
        printf("6. 降序打印多项式\n");
        printf("请选择操作:");
        scanf("%d", &choice);
        switch (choice) {
            case 1:
                if (poly_a != NULL) freePolynomial(poly_a);
                //添加多项式前要先检查多项式是否已经存在,如果存在,那就释放内存
                if (poly_b != NULL) freePolynomial(poly_b);
                poly_a=CreatePolynomial();//添加多项式,赋的值为多项式的头指针
                printf("请输入第二个多项式\n");
                poly_b=CreatePolynomial();
                break;
            case 2:
                result=AddPolynomial(poly_a,poly_b);
                printPolynomial(result);
                DecPrintPolynomial(result);
                break;
            case 3:
                result=MinusPolynomial(poly_a,poly_b);
                printPolynomial(result);
                DecPrintPolynomial(result);
                break;
            case 4:
                result=MultiplyPolynomials(poly_a,poly_b);
                printPolynomial(result);
                DecPrintPolynomial(result);
                break;
            case 5:
                printPolynomial(poly_a);
                printPolynomial(poly_b);
                break;
            case 6:
                DecPrintPolynomial(poly_a);
                DecPrintPolynomial(poly_b);
                break;
            default:
                break;
        }
    }

}

 这是运行结果

多项式运算菜单:
1. 输入多项式A和B
2. 加法运算
3. 减法运算
4. 乘法运算
5. 打印多项式
6. 降序打印多项式
请选择操作:1
1 1 2 2 0 0
输入完成一个多项式请输入第二个多项式
2 3 4 5 0 0
输入完成一个多项式
多项式运算菜单:
1. 输入多项式A和B
2. 加法运算
3. 减法运算
4. 乘法运算
5. 打印多项式
6. 降序打印多项式
请选择操作:5
1x^1+2x^2打印完毕
2x^3+4x^5打印完毕

多项式运算菜单:
1. 输入多项式A和B
2. 加法运算
3. 减法运算
4. 乘法运算
5. 打印多项式
6. 降序打印多项式
请选择操作:6
2x^2+1x^1降幂打印结束
4x^5+2x^3降幂打印结束

多项式运算菜单:
1. 输入多项式A和B
2. 加法运算
3. 减法运算
4. 乘法运算
5. 打印多项式
6. 降序打印多项式
请选择操作:2
1x^1+2x^2+2x^3+4x^5打印完毕
4x^5+2x^3+2x^2+1x^1降幂打印结束

多项式运算菜单:
1. 输入多项式A和B
2. 加法运算
3. 减法运算
4. 乘法运算
5. 打印多项式
6. 降序打印多项式
请选择操作:3
1x^1+2x^2-2x^3-4x^5打印完毕
-4x^5-2x^3+2x^2+1x^1降幂打印结束

多项式运算菜单:
1. 输入多项式A和B
2. 加法运算
3. 减法运算
4. 乘法运算
5. 打印多项式
6. 降序打印多项式
请选择操作:4
2x^4+4x^5+4x^6+8x^7打印完毕
8x^7+4x^6+4x^5+2x^4降幂打印结束

AI(deepseek的) 

#include <stdio.h>
#include <stdlib.h>

typedef struct Term {
    int coef;
    int exp;
    struct Term *next;
} Term;

typedef Term* Polynomial;

// 创建新项
Term* createTerm(int coef, int exp) {
    Term* newTerm = (Term*)malloc(sizeof(Term));
    if (newTerm == NULL) {
        printf("内存分配失败\n");
        exit(1);
    }
    newTerm->coef = coef;
    newTerm->exp = exp;
    newTerm->next = NULL;
    return newTerm;
}

// 插入项并合并同类项
void insertTerm(Polynomial head, int coef, int exp) {
    if (coef == 0) return; // 忽略零系数项

    Term* prev = head;
    Term* current = head->next;

    while (current != NULL && current->exp < exp) {
        prev = current;
        current = current->next;
    }

    if (current != NULL && current->exp == exp) {
        current->coef += coef;
        if (current->coef == 0) {
            prev->next = current->next;
            free(current);
        }
    } else {
        Term* newTerm = createTerm(coef, exp);
        newTerm->next = current;
        prev->next = newTerm;
    }
}

// 输入多项式
Polynomial inputPolynomial() {
    Polynomial head = createTerm(0, 0); // 头结点
    int coef, exp;
    printf("输入多项式各项的系数和指数(输入0 0结束):\n");
    while (1) {
        scanf("%d %d", &coef, &exp);
        if (coef == 0 && exp == 0) break;
        insertTerm(head, coef, exp);
    }
    return head;
}

// 释放多项式内存
void freePolynomial(Polynomial head) {
    Term* current = head->next;
    while (current != NULL) {
        Term* temp = current;
        current = current->next;
        free(temp);
    }
    free(head);
}

// 复制多项式
Polynomial copyPolynomial(Polynomial src) {
    Polynomial dst = createTerm(0, 0);
    Term* s = src->next;
    Term* d = dst;
    while (s != NULL) {
        d->next = createTerm(s->coef, s->exp);
        d = d->next;
        s = s->next;
    }
    return dst;
}

// 多项式相加
Polynomial addPolynomials(Polynomial a, Polynomial b) {
    Polynomial result = createTerm(0, 0);
    Term* pa = a->next;
    Term* pb = b->next;

    while (pa != NULL || pb != NULL) {
        if (pa == NULL) {
            insertTerm(result, pb->coef, pb->exp);
            pb = pb->next;
        } else if (pb == NULL) {
            insertTerm(result, pa->coef, pa->exp);
            pa = pa->next;
        } else if (pa->exp < pb->exp) {
            insertTerm(result, pa->coef, pa->exp);
            pa = pa->next;
        } else if (pa->exp > pb->exp) {
            insertTerm(result, pb->coef, pb->exp);
            pb = pb->next;
        } else {
            int sum = pa->coef + pb->coef;
            if (sum != 0) {
                insertTerm(result, sum, pa->exp);
            }
            pa = pa->next;
            pb = pb->next;
        }
    }
    return result;
}

// 多项式相减
Polynomial subtractPolynomials(Polynomial a, Polynomial b) {
    Polynomial negB = copyPolynomial(b);
    Term* p = negB->next;
    while (p != NULL) {
        p->coef = -p->coef;
        p = p->next;
    }
    Polynomial result = addPolynomials(a, negB);
    freePolynomial(negB);
    return result;
}

// 多项式相乘
Polynomial multiplyPolynomials(Polynomial a, Polynomial b) {
    Polynomial result = createTerm(0, 0);
    Term* pa = a->next;

    while (pa != NULL) {
        Term* pb = b->next;
        while (pb != NULL) {
            int coef = pa->coef * pb->coef;
            int exp = pa->exp + pb->exp;
            insertTerm(result, coef, exp);
            pb = pb->next;
        }
        pa = pa->next;
    }
    return result;
}

// 反转链表用于降序输出
Polynomial reversePolynomial(Polynomial head) {
    Polynomial newHead = createTerm(0, 0);
    Term* current = head->next;
    while (current != NULL) {
        Term* next = current->next;
        current->next = newHead->next;
        newHead->next = current;
        current = next;
    }
    free(head);
    return newHead;
}

// 打印多项式
void printPolynomial(Polynomial head, int isDescending) {
    if (head->next == NULL) {
        printf("0\n");
        return;
    }

    if (isDescending) {
        head = reversePolynomial(copyPolynomial(head));
    }

    Term* current = head->next;
    int isFirst = 1;

    while (current != NULL) {
        if (!isFirst) {
            if (current->coef > 0) printf(" + ");
            else printf(" - ");
        } else {
            if (current->coef < 0) printf("-");
        }

        int absCoef = abs(current->coef);
        if (absCoef != 1 || current->exp == 0) {
            printf("%d", isFirst ? abs(current->coef) : absCoef);
        }

        if (current->exp > 0) {
            printf("x");
            if (current->exp > 1) printf("^%d", current->exp);
        }

        isFirst = 0;
        current = current->next;
    }
    printf("\n");

    if (isDescending) {
        freePolynomial(head);
    }
}

// 主菜单
int main() {
    int choice;
    Polynomial polyA = NULL, polyB = NULL, result = NULL;

    while (1) {
        printf("\n多项式运算菜单:\n");
        printf("1. 输入多项式A和B\n");
        printf("2. 加法运算\n");
        printf("3. 减法运算\n");
        printf("4. 乘法运算\n");
        printf("0. 退出\n");
        printf("请选择操作:");
        scanf("%d", &choice);

        if (choice == 0) break;

        if (choice != 1 && (polyA == NULL || polyB == NULL)) {
            printf("请先输入多项式A和B!\n");
            continue;
        }

        switch (choice) {
            case 1:
                if (polyA != NULL) freePolynomial(polyA);
                if (polyB != NULL) freePolynomial(polyB);
                printf("输入多项式A:\n");
                polyA = inputPolynomial();
                printf("输入多项式B:\n");
                polyB = inputPolynomial();
                break;
            case 2:
                result = addPolynomials(polyA, polyB);
                printf("\n加法结果(升幂):");
                printPolynomial(result, 0);
                printf("加法结果(降幂):");
                printPolynomial(result, 1);
                freePolynomial(result);
                break;
            case 3:
                result = subtractPolynomials(polyA, polyB);
                printf("\n减法结果(升幂):");
                printPolynomial(result, 0);
                printf("减法结果(降幂):");
                printPolynomial(result, 1);
                freePolynomial(result);
                break;
            case 4:
                result = multiplyPolynomials(polyA, polyB);
                printf("\n乘法结果(升幂):");
                printPolynomial(result, 0);
                printf("乘法结果(降幂):");
                printPolynomial(result, 1);
                freePolynomial(result);
                break;
            default:
                printf("无效选择!\n");
        }
    }

    if (polyA != NULL) freePolynomial(polyA);
    if (polyB != NULL) freePolynomial(polyB);
    return 0;
}

框架很像,但又不是那么像

 6.自言自语

今个儿给老师汇报实验,呃......,老师说我讲的过于细了,啧,然后还教育(指导)了我一顿,多项唉,上一次听到这样的话还是在我大一的时候,果然是真心的,也是今天突然发现我的汇报能力还是没有什么长进,总是啰嗦而且还卡壳,我确实不适合演讲,回汇报,有稿子也一样,因为就算有稿子我也还是会一意孤行,边讲边改,为什么呢,因为书面语和口语还是有很大不一样的。

老师说让我以后再向ta汇报一次,不让我现写代码,说相信我的代码😎,挺好的。

文章以后再改改

点击阅读全文
Logo

欢迎加入DeepSeek 技术社区。在这里,你可以找到志同道合的朋友,共同探索AI技术的奥秘。

更多推荐