【数据结构】单链表的应用——有序多项式合并化简

已于 2022-10-16 18:22:47 修改
阅读量361 收藏
点赞数 3
分类专栏： C语言 文章标签： 链表 算法 数据结构
于 2022-10-13 23:16:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64811333/article/details/127310908
版权

 写在前面的话：本人是学生，水平有限，测试用例较少，如果有纰漏还请见谅。

有如下俩个多项式：

 

 利用链表将他们合并成一个并且化简。

结点结构：

typedef struct node {
    float coef;     //系数
    int exp;        //指数
    struct node *next;  //链
} PolyNode;

算法1：一般算法，将合并后的结果表存在新的链表中：

优点：该算法执行完后原链表都不被破坏

缺点：空间复杂度为O(N）

算法实现（C）：

void Add(PolyNode *ha, PolyNode *hb, PolyNode *&hc) {
    PolyNode *pa = ha->next, *pb = hb->next, *s, *tc;
    double c;
    hc = (PolyNode *) malloc(sizeof(PolyNode));
    tc = hc;
    while (pa != NULL && pb != NULL) {
        if (pa->exp > pb->exp) {
            //建立新结点
            s = (PolyNode *) malloc(sizeof(PolyNode));
            s->exp = pa->exp;   //配置新结点信息
            s->coef = pa->coef; //配置新结点信息
            tc->next = s;   //链入该节点
            tc = s; //指针移到当前结点
            pa = pa->next;  //扫描下一结点
        } else if (pa->exp < pb->exp) {
            //同上
            s = (PolyNode *) malloc(sizeof(PolyNode));
            s->exp = pb->exp;
            s->coef = pb->coef;
            tc->next = s;
            tc = s;
            pb = pb->next;
        } else {
            //计算系数和
            c = pa->coef + pb->coef;
            if (c != 0) {   //如果系数和不0则配置新结点
                s = (PolyNode *) malloc(sizeof(PolyNode));
                s->exp = pa->exp;
                s->coef = c;
                tc->next = s;
                tc = s;
            }
            pa = pa->next;  //同时移动俩指针
            pb = pb->next;
        }
    }
    if (pb != NULL) {
        pa = pb;    //如果a式扫描完了就换成扫描b，只是化简，少一部判断和置换
    }
    while (pa != NULL) {
        //将剩余全部结点复制一份并链入新表
        s = (PolyNode *) malloc(sizeof(PolyNode));
        s->exp = pa->exp;
        s->coef = pa->coef;
        tc->next = s;
        tc = s;
        pa = pa->next;
    }
    tc->next = NULL;    //新结点指针置空
}

算法2：利用原有链表构建新结果链表：

优点：空间复杂度为O(N)

缺点：算法执行完后原链不能再使用

算法实现（C）：

//不创建空间复杂度为O(1)的多项式合并算法
void AddNew(PolyNode *ha, PolyNode *hb, PolyNode *&hc) {
    PolyNode *pa = ha->next, *pb = hb->next, *tc, *fp1, *fp2;
    double c;
    hc = ha;    //结果表头结点指针
    tc = hc;    //结果表头结点赋值给tc，让tc去操作
    while (pa != NULL && pb != NULL) {
        if (pa->exp < pb->exp) {//如果有b表项比a表项大
            tc->next = pb;    //tc指向b表最大项节点，
            pb = pb->next;    //移动pb指针，防止b表扫描指针pb丢失链表
            tc = tc->next;    //此时移动到b表当前最大节点
            tc->next = pa;    //让该节点指针域重新指回a表
        } else if (pa->exp > pb->exp) {
            //如果没有比当前a表大的项
            tc->next=pa;      //链入该结点
            tc = tc->next;    //移动结果表指针
            pa = pa->next;    //移动a表指针
        } else {
            c = pa->coef + pb->coef;    //计算系数和
            fp1 = pa;
            fp2 = pb;   //保存可能被合并指针
            if (c != 0) {
                pa->coef = c;   //重置该结点系数
                tc->next=pa;    //链入该结点
                tc = tc->next;  //结果表指针后移动
            }
            pa = pa->next;  //扫描指针后移动
            pb = pb->next;
            if (c == 0)
                free(fp1);  //释放被合并节点
            free(fp2);  //释放被合并节点
        }
    }
    if (pb != NULL) {
        pa = pb;    //同样是化简下一步
    }
    tc->next = pa;  //将剩余节点全部链入结果表
}

关键步骤：

 此处算法思想如下图： 

 如果你想直接拿代码跑一把，复制下面代码即可：

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

#define Max 50
typedef struct node {
    float coef;     //系数
    int exp;        //指数
    struct node *next;  //链
} PolyNode;

//空间复杂度O(N)
void Add(PolyNode *ha, PolyNode *hb, PolyNode *&hc) {
    PolyNode *pa = ha->next, *pb = hb->next, *s, *tc;
    double c;
    hc = (PolyNode *) malloc(sizeof(PolyNode));
    tc = hc;
    while (pa != NULL && pb != NULL) {
        if (pa->exp > pb->exp) {
            //建立新结点
            s = (PolyNode *) malloc(sizeof(PolyNode));
            s->exp = pa->exp;   //配置新结点信息
            s->coef = pa->coef; //配置新结点信息
            tc->next = s;   //链入该节点
            tc = s; //指针移到当前结点
            pa = pa->next;  //扫描下一结点
        } else if (pa->exp < pb->exp) {
            //同上
            s = (PolyNode *) malloc(sizeof(PolyNode));
            s->exp = pb->exp;
            s->coef = pb->coef;
            tc->next = s;
            tc = s;
            pb = pb->next;
        } else {
            //计算系数和
            c = pa->coef + pb->coef;
            if (c != 0) {   //如果系数和不0则配置新结点
                s = (PolyNode *) malloc(sizeof(PolyNode));
                s->exp = pa->exp;
                s->coef = c;
                tc->next = s;
                tc = s;
            }
            pa = pa->next;  //同时移动俩指针
            pb = pb->next;
        }
    }
    if (pb != NULL) {
        pa = pb;    //如果a式扫描完了就换成扫描b，只是化简，少一部判断和置换
    }
    while (pa != NULL) {
        //将剩余全部结点复制一份并链入新表
        s = (PolyNode *) malloc(sizeof(PolyNode));
        s->exp = pa->exp;
        s->coef = pa->coef;
        tc->next = s;
        tc = s;
        pa = pa->next;
    }
    tc->next = NULL;    //新结点指针置空
}

//建立多项式列表
void CreateListR(PolyNode *&L, double a[], int b[], int n) {
    PolyNode *s, *tc;
    L = (PolyNode *) malloc(sizeof(PolyNode));
    tc = L;                 //tc始终指向尾结点，初始时间指向头结点
    for (int i = 0; i < n; ++i) {
        s = (PolyNode *) malloc(sizeof(PolyNode));
        s->coef = a[i];     //创建新结点
        s->exp = b[i];
        tc->next = s;       //将假设s插入tc结点之后
        tc = s;
    }
    tc->next = NULL;        //尾结点next域置为NULL
}

//销毁链表
void DestroyList(PolyNode *&L) {
    PolyNode *pre = L, *p = pre->next;  //保存下一个结点的地址
    while (p != NULL) {
        free(pre);  //释放当前指针所指内存空间
        pre = p;        //记录当前结点地址
        p = p->next;    //移向下一结点
    }
    free(pre);  //释放最后一个结点
}

//输出多项式链表
void DispPoly(PolyNode *&L) {
    PolyNode *p = L->next;
    while (p != NULL) { //如果当前指针不为空
        printf("(%gx^%d)", p->coef, p->exp);    //打印结点存储的信息
        p = p->next;
        if (p != NULL) {
            printf("+");
        }
    }
    printf("\n");
}

//不创建空间复杂度为O(1)的多项式合并算法
void AddNew(PolyNode *ha, PolyNode *hb, PolyNode *&hc) {
    PolyNode *pa = ha->next, *pb = hb->next, *tc, *fp1, *fp2;
    double c;
    hc = ha;    //结果表头结点指针
    tc = hc;    //结果表头结点赋值给tc，让tc去操作
    while (pa != NULL && pb != NULL) {
        if (pa->exp < pb->exp) {//如果有b表项比a表项大
            tc->next = pb;    //tc指向b表最大项节点，
            pb = pb->next;    //移动pb指针，防止b表扫描指针pb丢失链表
            tc = tc->next;    //此时移动到b表当前最大节点
            tc->next = pa;    //让该节点指针域重新指回a表
        } else if (pa->exp > pb->exp) {
            //如果没有比当前a表大的项
            tc->next=pa;      //链入该结点
            tc = tc->next;    //移动结果表指针
            pa = pa->next;    //移动a表指针
        } else {
            c = pa->coef + pb->coef;    //计算系数和
            fp1 = pa;
            fp2 = pb;   //保存可能被合并指针
            if (c != 0) {
                pa->coef = c;   //重置该结点系数
                tc->next=pa;    //链入该结点
                tc = tc->next;  //结果表指针后移动
            }
            pa = pa->next;  //扫描指针后移动
            pb = pb->next;
            if (c == 0)
                free(fp1);  //释放被合并节点
            free(fp2);  //释放被合并节点
        }
    }
    if (pb != NULL) {
        pa = pb;    //同样是化简下一步
    }
    tc->next = pa;  //将剩余节点全部链入结果表
}
 
int main(){
    PolyNode *Poly1,*Poly2,*Poly3;
    double a[Max];
    int b[Max],n;
    //第一个链表
    a[0]=6;b[0]=7;
    a[1]=1,b[1]=6;
    a[2]=0.5;b[2]=4;
    a[3]=-5;b[3]=2;
    a[4]=-5;b[4]=-1;
    n=5;
    CreateListR(Poly1,a,b,n);
    printf("第一个多项式：");
    DispPoly(Poly1);
    //第二个链表
    a[0]=-1;b[0]=6;
    a[1]=4;b[1]=5;
    a[2]=-3;b[2]=4;
    a[3]=5;b[3]=2;
    a[4]=-5;b[4]=1;
    a[5]=8;b[5]=-1;
    n=6;
    CreateListR(Poly2,a,b,n);
    printf("第二个多项式：");
    DispPoly(Poly2);
//    Add(Poly1,Poly2,Poly3); //空间复杂度O(N)
    AddNew(Poly1,Poly2,Poly3); //空间复杂度O(1)
    printf("相加后的多项式：");
    DispPoly(Poly3);
    DestroyList(Poly1);
    DestroyList(Poly2);
    DestroyList(Poly3);
    return 0;
}

.魚肉
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
多项式的合并-链表实现
qq_51728241的博客
11-01 1315
描述 键盘输入A，B两多项式，假设 A = 1x^2 + 2x^3 + 4x^4 + 1x^5 B = 9x^0 + 4x^1 + 3x^2 + 6x^3 得到的结果 C = 9x^0 + 4x + 4x^2 + 8x^3 + 4x^4 + 1x^5 例如：输入时，A表示为 1 2 2 3 4 4 1 5 0 0 ，其中0 0 为存入的终止判断 每两个数为一组，分别为A的某项的系数和指数 （***A,B都是指数从小到大排序好的多项式） 过程 1
数据结构链表合并c语言实现,链表实现多项式的合并
weixin_33526828的博客
05-21 314
已结贴√问题点数：20回复次数：4 链表实现多项式的合并#include #include //the definiton of listtypedef struct node{int xs;int zs;node *next;}lb;typedef lb* lbx ;//the creation of list (tail insert with head node)lbx create(v...
数据结构单向不循环链表实现多项式合并
qq_45767476的博客
05-03 164
多项式合并 思路 多项式合并 P1 = 5 + 2x + 8x ^8 +3x^16 P2 = 6x + 16x^6 - 8x^8 P = P1 + P2 = 5 + 8x + 16x^6 + 3x^16 使用带头结点的单向不循环链表 每个节点分为三个部分，系数项，指数项，指针域 结构体表示为 struct node_st { int exponent; int coefficient; struct node_st *next; }; 定义两个指针p,q,分别指向多项式P1
C语言实现的多项式合并运算系统
毕业作品网站
06-30 601
键盘输入多项式如下所示：7X500+9X100+2X3+2X2+100 与3X3000+35X2000+18X100-2X3+1000输出合并的结果：3X^3000 +35X^2000 +7X^500 +27X^100 +2X^2 +1100注意：输入多项式时，并不一定按照幂降次的次序排列，并且有可能出现输入格式错误，程序应能检查其输入格式是否正确。要求：使用链表结构实现多项式的存储。多项式合并系统由五大功能模块组成：输入模块，链表链接，输出模块，提示菜单，释放空间。其中，输入模块包括对输入的内容进行提取
数据结构一元多项式的相加-单链表实现
weixin_46341264的博客
10-18 5175
数据结构单链表实现一元多项式的相加
数据结构——一元多项式加法.zip
09-18
5. **扩展应用**：除了加法，数据结构如线性表也可以用于实现多项式的其他操作，如减法、乘法、求导和积分。这些操作在数值分析、信号处理和机器学习等领域都有广泛应用。 通过理解和掌握如何使用数据结构实现一元...
双向链表及其应用——实现多项式的加法及乘法
10-23
在IT领域，数据结构是计算机科学的基础，而链表作为一种重要的数据结构，有着广泛的应用。本文将深入探讨双向链表的实现以及它在一项特殊应用中的体现：一元多项式的加法与乘法运算。 首先，我们要理解双向链表的...
单链表的应用，多项式的合并
05-10
【单链表的应用，多项式的合并】 在计算机科学中，单链表是一种常见的数据结构，用于存储线性数据。在本实例中，单链表被应用于处理一元稀疏多项式的加法运算。稀疏多项式指的是那些含有较少非零项的多项式，这种...
单链表实现的多项式运算.cpp
03-25
利用单链表的数据结构，在读取数据时就按指数次方排序好，再加法的运算中可以直接按指数的大小进行运算，相比随机的读入数据，这个方法优化了程序。乘法则是在加法的基础上把每一项的系数进行相乘并最后求和。注意...
C语言版数据结构，用单链表实现稀疏多项式的加法运算。
04-26
最近在学数据结构，讲完单链表后老师就布置了一个这样的答辩作业。代码附上啦，大多地方都添加了注释，要交作业的同学可以看一看。 实现要求： 1）两个一元稀疏多项式进行存储，并实现加法运算。 2）使用单链表的...
链表实现合并多项式
05-21
数据结构用链表实现两个多项式的合并打印结果
C++一元多项式的乘法运算(单链表实现)
newbie的博客
10-02 2298
题目描述:给你两个一元多项式，输出这两个一元多项式的乘积。输入格式：输入包含两行，每行一个一元多项式。每行开头一个数字n,表示该多项式非零项项数，后面有n组数字，每组数字包含两个数字，按顺序分别为该项的系数和指数。
单链表的应用（多项式相加）
qq_58299006的博客
10-03 1641
题目内容 完成两个多项式的相加操作：已知有两个多项式Pm(x)、Qm(x)，设计算法实现Pm(x)+Qm(x)运算，而且对加法运算不重新开辟存储空间。要求用链式存储结构实现。例如：Pm(x)=5x^3+2x=1,Qm(x)=3x^3+x^2-2x-3,其计算输出结果为：8x^3+1x^2-2。 算法分析 本设计使用单链表实现。 两个多项式相加算法的实现，首先是将两个多项式分别用链表进行存放。可以设置两个指针LA1和LB1分别从多项式Pm(x)和Qm(x)的首结点移动，比较LA1...
单链表实现多项式的合并（指数降序输出）
weixin_30300523的博客
08-03 948
#include<stdio.h>#include<malloc.h>#define ElemType inttypedef struct ployNode{int coef,index;struct ployNode *next;}; ployNode *insert_ployNode(ployNode *L,ployNode *newp){//按指数...
单链表的运用——多项式及其运算
razorEdge的博客
10-07 4235
包括：多项式的class定义+多项式加法+多项式乘法 黄金周即将过去，好多任务都没有完成，还好提前意识到，最近两天只好奋笔疾书了！ 本篇依旧是数据结构的内容，但是是单链表的一个应用实例，还是比较实用的，相信透彻理解这个多项式的应用，对数据结构单链表这一块会更好的把握。废话不多说，下面给出完整代码： 多项式class定义：#include <iostream> #include <cmath>
多项式求和（链表实现）
weixin_62428212的博客
03-25 2350
c/c++用链表实现多项式合并
合并两个单链表练习，多项式合并
u012139045的专栏
10-25 1347
用节点node表示多项式的系数和次数，编程合并两个链式表达的多项式。 思路：先初始化两个单链表，然后将单链表的系数相加，如果一个单链表结束，将next节点直接指向不空的单链表，最后输出结果。 // multinomial.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include #include typedef s
双链表&链表合并&多项式相加算法
wqthaha的专栏
08-11 3230
//单链表的合并 //链表合并 //两个链表必须是有序的 #define Maxsize 5 typedef  int elemtype; typedef struct linklist {    elemtype data;    struct linklist *next; }Linklist;  //建立链表1 Linklist *CreateList1 ()
多项式合并（C语言实现）
weixin_43988887的博客
03-10 4284
0.前言 最近放假在家无事，就想想多学学编程底层的知识，就买了一本数据结构来看看，这是我见过比高数，理力更蛋疼的课程了。书上就给了源代码，也没有详细介绍算法知识。合并算法也是搞了好久才懂得。 1.算法介绍 /*多项式合并算法 1.首先设计三个指针变量：pre、qa和qb，其中pre永远指向合多项式链表的尾节点，qa,qb分别从多项式的pa和pb链表的首项开始扫描 比较qa和qb所指节点指数域的值...
利用有序单链表实现两个多项式相加
最新发布
03-22
2. 分别输入两个多项式的系数和指数，将它们按照指数从大到小的顺序插入到有序单链表中。 3. 定义一个新的有序单链表，用于存储相加后的多项式。 4. 遍历两个有序单链表，将相同指数的项相加，将结果插入到新的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

.魚肉

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值