数据结构实验——一元多项式相加减

最新推荐文章于 2024-11-24 23:41:11 发布
最新推荐文章于 2024-11-24 23:41:11 发布
阅读量1.5k 收藏 18
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_52682273/article/details/116276799
版权
本文介绍了如何使用链表数据结构实现多项式的加减运算，并详细阐述了创建、合并和排序链表的过程。通过实例代码学习链表操作和多项式处理技巧，适合巩固基础算法知识。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

由于多项式的加减肯定会用到链表，所以本题运用链表来实现，其中会用到链表的插入，删除以及一些细节的地方，同时为了处理好一些其他的输入问题，或者是不是按照顺序的输入，加入了一些自己的理解，关于链表的知识点，可以通过此题多多学习，加上此代码非原创，但通过这个代码学到了许多，注意复习*的用法以及含义加上链表初级知识的复习。

#include <stdio.h>
#include <stdlib.h>
#include<malloc.h>   //考虑全局静态变量 

#define LEN sizeof(struct poly)
static struct poly *head1,*head2; 
struct poly
{
    int index;
    float ratio;
    struct poly *next;
};//建立链表，index储存指数，ratio储存系数
struct poly *creat()
{
    struct poly *temp,*head,*rear,*t;
    int index;
    float ratio;
    int flag=0;
    head=rear=(struct poly*)malloc(sizeof(LEN));
    rear->next=NULL;
    printf("请输入多项式的各项的系数与指数，以空格隔开，输入0 0代表输入结束\n");
    while(1)
    {

        scanf("%f %d",&ratio,&index);
        if(ratio==0&&index==0)
            return head;
        if(head->next==NULL)
        {
            temp=(struct poly*)malloc(sizeof(LEN));
            rear->next=temp;
            rear=temp;
            rear->next=NULL;
            rear->index=index;
            rear->ratio=ratio;
            continue;
        }
		for(t=head->next; t!=NULL; t=t->next)
        {
            if(t->index==index)
            {
                flag=1;
                t->ratio=t->ratio+ratio;
                break;
            }
        }
        if(flag==0)
        {
            temp=(struct poly*)malloc(sizeof(LEN));
            rear->next=temp;
            rear=temp;
            rear->next=NULL;
            rear->index=index;
            rear->ratio=ratio;

        }

    }
    return head;
};//输入数据，在输入时，可能存在输入两次相同系数的数据，此时将两组数据合并
struct poly sort(struct poly *head)
{
    struct poly *temp1,*temp2;
    temp1=head->next;
    temp2=NULL;
    while(temp1!=temp2)
    {
        while(temp1->next!=temp2)
        {
            if(temp1->index>temp1->next->index)
            {
                temp1->index=temp1->index+temp1->next->index;
                temp1->next->index=temp1->index-temp1->next->index;
                temp1->index=temp1->index-temp1->next->index;
                temp1->ratio=temp1->ratio+temp1->next->ratio;
                temp1->next->ratio=temp1->ratio-temp1->next->ratio;
                temp1->ratio=temp1->ratio-temp1->next->ratio;

            }
            temp1=temp1->next;
        }
        temp2=temp1;
        temp1=head->next;
    }
};//将多项式进行排序，以符合我们通常状态下升幂的次序
struct poly add(struct poly *head1,struct poly *head2)
{   
    struct poly *head,*rear,*temp1,*p,*q;
    head=rear=(struct poly*)malloc(sizeof(LEN));
    rear->next=NULL;
    p=head1->next;
    q=head2->next;
    while(p!=NULL||q!=NULL)
    {


        if(p==NULL||q==NULL)
        {
            if(p==NULL)
            {
                while(q!=NULL)
                {
                    temp1=(struct poly*)malloc(sizeof(LEN));
                    rear->next=temp1;
                    temp1->next=NULL;
                    temp1->index=q->index;
                    temp1->ratio=q->ratio;
                    rear=temp1;
                    q=q->next;
                }
            }//求和时，若head1为空，则直接将head2复制到新结果中去
            else if(q==NULL)
            {
                while(p!=NULL)
                {
                    temp1=(struct poly*)malloc(sizeof(LEN));
                    rear->next=temp1;
                    temp1->next=NULL;
                    temp1->index=p->index;
                    temp1->ratio=p->ratio;
                    rear=temp1;
                    p=p->next;
                }
            }//若head2为空，则将head1复制到结果中去
        }
        else
        {
            if(p->index<q->index)
            {
                temp1=(struct poly*)malloc(sizeof(LEN));
                temp1->index=p->index;
                temp1->ratio=p->ratio;
                rear->next=temp1;
                rear=temp1;
                rear->next=NULL;
                p=p->next;
            }
            else if(p->index>q->index)
            {
                temp1=(struct poly*)malloc(sizeof(LEN));
                temp1->index=q->index;
                temp1->ratio=q->ratio;
                rear->next=temp1;
                rear=temp1;
                rear->next=NULL;
                q=q->next;
            }
            else
            {
                temp1=(struct poly*)malloc(sizeof(LEN));
                temp1->index=p->index;
                temp1->ratio=q->ratio+p->ratio;
                if(temp1->ratio!=0)
                {
                    rear->next=temp1;
                    rear=temp1;
                    rear->next=NULL;
                    p=p->next;
                    q=q->next;
                }
                else
                {
                    p=p->next;
                    q=q->next;
                }
            }

        }//若head1和head2都不为空，则按照升幂的次序将其排序相加，系数为0的项不需要，注意，一定要按照次序来，少使用排序函数
    } 
   void print(struct poly *head);
   print(head);
  

   
};//对两多项式进行求和，求和结果储存在另一个结构体中
struct poly sub(struct poly *head1,struct poly *head2)
{
    struct poly *head,*rear,*temp1,*temp2,*p,*q;
    head=rear=(struct poly*)malloc(sizeof(LEN));
    head->next=rear->next=NULL;
    p=head1->next;
    q=head2->next;

    while(p!=NULL||q!=NULL)
    {
        if(p==NULL||q==NULL)
        {
            if(p==NULL)
            {
                while(q!=NULL)
                {
                    temp1=(struct poly*)malloc(sizeof(LEN));
                    rear->next=temp1;
                    temp1->next=NULL;
                    temp1->index=q->index;
                    temp1->ratio=-q->ratio;
                    rear=temp1;
                    q=q->next;
                }
            }
            else if(q==NULL)
            {
                while(p!=NULL)
                {
                    temp1=(struct poly*)malloc(sizeof(LEN));
                    rear->next=temp1;
                    temp1->next=NULL;
                    temp1->index=p->index;
                    temp1->ratio=p->ratio;
                    rear=temp1;
                    p=p->next;
                }
            }
        }
        else
        {
            if(p->index<q->index)
            {
                temp1=(struct poly*)malloc(sizeof(LEN));
                temp1->index=p->index;
                temp1->ratio=p->ratio;
                rear->next=temp1;
                rear=temp1;
                rear->next=NULL;
                p=p->next;
            }
            else if(p->index>q->index)
            {
                temp1=(struct poly*)malloc(sizeof(LEN));
                temp1->index=q->index;
                temp1->ratio=-q->ratio;
                rear->next=temp1;
                rear=temp1;
                rear->next=NULL;
                q=q->next;
            }
            else
            {
                temp1=(struct poly*)malloc(sizeof(LEN));
                temp1->index=p->index;
                temp1->ratio=p->ratio-q->ratio;
                if(temp1->ratio!=0)
                {
                    rear->next=temp1;
                    rear=temp1;
                    rear->next=NULL;
                    p=p->next;
                    q=q->next;
                }
                else
                {
                    p=p->next;
                    q=q->next;
                }
            }

        }
        
        
    }
  
   void print(struct poly *head);
   print(head);
   
   
};//多项式求差，与求和同理


void print(struct poly *head)
{   FILE * fp;
	fp=fopen("test18.txt","a+");
    struct poly *temp;
    temp=head->next;
    if(temp==NULL)
    {
        fprintf(fp,"0\n");
        return;
    }//多项式的输出，若多项式为NULL则直接输出0
    while(temp!=NULL)
    {
        if(temp==head->next)
        {
            fprintf(fp," %.2f",temp->ratio);
            if(temp->index!=0)
            {
                if(temp->index==1)
                    fprintf(fp,"x");
                else
                    fprintf(fp,"x^%d",temp->index);
            }
            else
                fprintf(fp," ");
        }//在输出第一项时，系数为正，直接输出，系数为负，也直接输出
        else
        {
            if(temp->ratio>0)
            {
                fprintf(fp,"+%.2f",temp->ratio);
                if(temp->index!=0)
                {
                    if(temp->index==1)
                        fprintf(fp,"x");
                    else
                        fprintf(fp,"x^%d",temp->index);
                }

                else
                    fprintf(fp," ");
            }
            else
            {
                fprintf(fp,"%.2f",temp->ratio);
                if(temp->index!=0)
                {
                    if(temp->index==1)
                        fprintf(fp,"x");
                    else
                        fprintf(fp,"x^%d",temp->index);
                }

                else
                    fprintf(fp," ");
            }//之后的每一项中，系数为正，则加上正号，即加号，系数为负，可直接输出
        }
        temp=temp->next;
    }
    fprintf(fp,"\n");
fclose(fp);
};

int main()
{
	int a,b;
    head1=creat();
    head2=creat();
    sort(head1);
    sort(head2);
    printf("\n多项式a(x)为：\n");
    print(head1);
    printf("\n多项式b(x)为：\n");
    print(head2);
    printf("\n两多项式之和为：\n");
    add(head1,head2);
    printf("\n两多项式之差为：\n");
    sub(head1,head2);
   
    
    return 0;
}
椿&湫
关注
数据结构实验1 一元多项式的加减法
Gamer_Lee的博客
10-26 6220
实验一  线性表操作（一元多项式的运算） 实验目的 定义线性表的链式存储 2、实现对线性表的一些基本操作和具体函数定义   实验要求： 1、定义线性表的链式存储； 2、实现对线性表的一些基本操作和具体函数定义。 3、定义输出一元多项式的函数； 4、编写主程序调用上面的函数实现一元多项式的加减。   数据输入输出要求：   输入示例： 3 2 3 3 4 5 7 5...
数据结构（C语言）代码实现（七）——一元多项式的表示与相加
weixin_74746867的博客
02-06 1532
寒假在家，有点学不下去，写文章的速度也很慢，看来四十天完成这项任务是不可能了。但比较兴奋的是，在这个过程中，我调试代码的速度有了明显的提升，很多时候一些小细节我可以通过网上资源的帮助解决，这是我以前严重缺乏的能力。第二个收获就是在复现代码的过程中真正意识到了模块化的好处，就想这篇文章，就与上一篇单链表的代码实现息息相关，可以说，上一篇稍微改改，就可以成为这一篇的一个头文件，因此节省了我很大的工作量。这一章也算告一段落，下面就看看我的成果吧。数据结构（C语言）代码实现（六）——单链表的实现-优快云博客。
数据结构--一元多项式加减法
03-19
使用链表操作一元多项式，使之可以直接进行一元多项式的加减法,vs可以直接打开运行，其他软件，请找到文件中的main.c文件进行运行，所有代码均为本人自己写的，仅供学习，请勿做一切任何商业用途
数据结构-一元多项式加减程序
张建波专栏
02-09 6401
//一元多项式加减程序//程序：张建波//时间：2005/7/12 PM:20-08//功能：//     1：可以计算 1+2+3-1+2-5+6+3 (加减法均可)//     2: 可以计算 2x+3x+5x-x^2+x^3+4x^7+9//     3: 可以进行组合计算 A=1+2+x+x^2  B=x+x^2  A+B=3+2x+2x^2//注意：除指数不能为 负！！其余都可以输入负数
数据结构实验：一元多项式的加减乘
qq_53216148的博客
12-01 1015
实验一 一元多项式相加（链表应用实验） 定义一元多项式链表结点结构HLink (1)实现创建一元多项式链表函数void Build(HLink &H)； (2)实现输出一元多项式链表函数void Exp(HLink H)； (3)实现函数void showH(HLink &H, int beds, char *state)，显示已经建立的多项式。 (4) 容错处理：检测任何不合规的输入，并给出必要提示。 (5)函数void Add(HLink &H，HLink A，HLink B)，将多项式A、B相加，结果
[数据结构]一元多项式的加/减法运算（链表）
codeTcy的博客
07-07 4281
一元多项式的加/减法运算（链表） 问题描述 : 假设2个稀疏一元多项式分别由带头结点的有序单链表A和B存储（指数项递增有序）。现要求设计一个算法，实现稀疏一元多项式的加减法计算。要求使用A和B的原存储空间（运算后B不再存在，A链表中保存结果多项式）。输入中的单链表的长度不得在计算算法中利用，仅作为建表使用。 注意：加/减法计算后，如某一项的结果系数为0，则该项要从多项式链表中删除。 输入说明 : 第一行：加/减法选择（0：加法 1：减法） 第二行：一元多项式A的项数 第三行：一元多项式A的各项的系数（系数
数据结构——一元多项式加法.zip
09-18
一元多项式加法是数学中的基本运算，而在编程和算法设计中，这种运算可以通过利用数据结构，尤其是线性表来实现。这篇内容将深入探讨如何使用线性表来实现一元多项式加法。 首先，理解一元多项式。一元多项式是由...
数据结构——一元多项式加法、减法、乘法运算的实现
07-13
### 数据结构——一元多项式加法、减法、乘法运算的实现 #### 设计内容及要求 本节详细介绍了如何使用不同的数据结构来实现一元多项式的加法、减法以及乘法运算。 ##### 1.1 设计内容 1. **使用顺序存储结构实现...
数据结构 （8）线性表的应用——一元多项式的表示及应用
最新发布
m0_73399576的博客
11-24 1089
数据结构——线性表的应用——一元多项式的表示及应用篇
数据结构——一元多项式乘法与加法
Bridge3的博客
09-09 2023
02-线性结构2 一元多项式的乘法与加法运算（20 分） 设计函数分别求两个一元多项式的乘积与和。 输入格式: 输入分2行，每行分别先给出多项式非零项的个数，再以指数递降方式输入一个多项式非零项系数和指数（绝对值均为不超过1000的整数）。数字间以空格分隔。 输出格式: 输出分2行，分别以指数递降方式输出乘积多项式以及和多项式非零项的系数和指数。数字间以空格分隔，但结尾不能有多余空格。零...
数据结构C语言 一元多项式的加减法
12-12
数据结构 C语言 动态链表 议员多项式的加减法 数据结构C语言 一元多项式的加减法算法实现 代码，用vs运行，已测试成功运行，
一元多项式加减乘运算-数据结构-课程设计
01-20
Polyn.h #include #include #include typedef struct polyn { double coef; int expn; struct polyn* next; }PolyNode, *PLinkList; PLinkList CreatePolyn(int n);//创建一元多项式，使一元多项式呈指数递减 void PrintPolyn(PLinkList head);//输出一元多项式 PLinkList Addition(PLinkList L1,PLinkList L2);//多项式的加法 PLinkList Subtraction(PLi
数据结构一元多项式的加减乘.
05-26
数据结构一元多项式的加减乘. 数据结构的链表形式
一元多项式的加法、减法、乘法
06-17
使用链表来实现单元多项式的加法、减法、乘法。其中，加法是其它运算的基础，减法：poly1-poly2=poly1+(-poly2)，乘法：poly1*poly2，可用poly1乘以poly2的每一项，相加其乘积结果。
数据结构一元多项式加减法
12-14
本程序是C语言编写的一元多项式加法和减法，适合数据结构课程设计等……
一元多项式加减
LLXLQY的博客
03-27 724
#include using namespace std; #define OK 1 #define ERROR 0 #define OVERFLOW -1 typedef struct{ float coef; int expn; }elemtype; typedef struct Lnode{ struct Lnode*next; elemtype data; }Lno
一元多项式的加减
lxf1128的博客
12-04 453
 #include #include typedef struct nodetype {  float coef;  int expn;  struct nodetype *next; }nodetype; nodetype *creatpoly() {     nodetype *head,*rear,*s;  float c;  int e;     head=
数据结构 -- 一元多项式加减乘
兜兜的博客
03-22 758
又是被作业狠狠支配的一天枯了。。。
【数据结构】用链表实现一元多项式相加减（C语言版）
m0_63425312的博客
04-18 4557
一元多项式的表示及相加 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 文章目录一元多项式的表示及相加前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任
线性表与一元多项式相加——数据结构讲解
在处理一元多项式相加时，代码首先分配内存来创建新的多项式`Lc`，然后遍历两个输入多项式`La`和`Lb`的项。如果当前遍历到的`pa`项的指数小于`pb`项的指数，就将`pa`的系数和指数复制到新创建的项`p`中，并将`p`添加...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值