算法与数据结构——一元多项式的表示和相加

最新推荐文章于 2024-05-02 18:18:56 发布
最新推荐文章于 2024-05-02 18:18:56 发布
阅读量1.4k 收藏 13
点赞数 1
文章标签： 数据结构 算法 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63148076/article/details/129390630
版权

一元多项式的表示和相加

1，实验目的

用户可以通过键盘输入两个多项式，并非能够实现输入的一元多项式的显示，能够完成各项的排序，以及两个一元多项式的相加。
掌握链表的表示方法及存储。
掌握链表的操作。

2，实验内容

一个一元多项式的每一个子项都由“系数-指数”两部分组成，因此课抽象为包含系数coef,指数exp,指针域next构成的链式线性表。将两个多项式分别存放在两个线性表中，然后经过相加后将所得的多项式放入一个新的线性表里，然后进行打印。
利用链表实现一元多项式的表示和相加。通过main()函数调用实现。包括建立链表函数，输出链表函数，链表排序函数，链表相加函数。采用链式存储结构，将两个线性链表表示的一元多项式相加，并输出。此一元多项式遵循多项式相加运算规则：对于两个一元多项式中存在指数相同的项时，其对应系数相加：合并时系数和为零时，删除“和多项式”中此项；合并时系数和不为零时，则构成“和多项式”中的一项。对于两个一元多项式中存在的指数不相同的项，则分别复抄到“和多项式”中去，原多项式保持不变。

3，代码展示

//一元多项式的表示及相加
//打开相应库文件
//定义多项式最大项数
#include <stdio.h>
#include <malloc.h>
#define MAX 20
//定义单链表结点类型
typedef struct pnode
{
float coef;
int exp;
struct pnode* next;
}PolyNode;
//定义存放多项式的数组类型
typedef struct
{float coef;
int exp;
}PolyArray[MAX]; ;

//一元多项式的表示（建立多项式链表）
void CreateListR(PolyNode*& L, PolyArray a, int n)
{
PolyNode* s, * r; int i;
L = (PolyNode*)malloc(sizeof(PolyNode));
L->next = NULL;
r = L;
for (i = 0; i < n; i++) {
s = (PolyNode*)malloc(sizeof(PolyNode));
s->coef = a[i].coef;
s->exp = a[i].exp;
s->next = NULL;
r->next = s;
r = s; }
r->next = NULL；}
//原多项式链表排序
void Sort(PolyNode*& head)
{
PolyNode* p = head->next, * q, * r;
if (p != NULL) {
r = p->next;
p->next = NULL;
p = r;
while (p != NULL) {
r = p->next;
q = head;
while (q->next != NULL && q->next->exp > p->exp)
q = q->next;
p->next = q->next;
q->next = p;
p = r; }}}
//一元多项式的相加
void Add(PolyNode* ha,PolyNode* hb, PolyNode*& hc)
{
PolyNode* pa = ha->next, * pb = hb->next, * s, * tc;
float 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;
s->next = NULL;
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;
s->next = NULL;
tc->next = s; tc = s;
pb = pb->next; }
else {c = pa->coef + pb->coef;
if ©
{ s = (PolyNode*)malloc(sizeof(PolyNode));
s->exp = pa->exp; s->coef = c;
s->next = NULL;
tc->next = s; tc = s; }
pa = pa->next;
pb = pb->next;} }
if (pb != NULL) pa = pb;
while (pa != NULL)
{
s = (PolyNode*)malloc(sizeof(PolyNode));
s->exp = pa->exp; s->coef = pa->coef;
s->next = NULL;
tc->next = s; tc = s;
pa = pa->next;
}
tc->next = NULL;
}//输出多项式链表
void DispPoly(PolyNode* L)
{
PolyNode* p = L->next;
while (p != NULL)
{
printf(“%gX^%d+”, p->coef, p->exp); p = p->next; }
printf(“\b “);
printf(”\n\n”);
}//主函数的设定及调用
void main()
{PolyNode* ha, * hb, * hc; //单链表结点类型
PolyArray a = { {1.2 ,0}, {2.5,1} ,{3.2,3} ,{-2.5,5} }; //存放多项式a的数组类型
PolyArray b = { {-1.2,0}, {2.5,1}, {3.2,3} ,{2.5,5} ,{5.4,10} };//存放多项式b的数组类型
CreateListR(ha, a, 4); //一元多项式的表示（建立多项式链表）
CreateListR(hb, b, 5); //一元多项式的表示（建立多项式链表）
printf(“原 多项式A：”);
DispPoly(ha); //输出多项式链表
printf(“原 多项式B：”);
DispPoly(hb); //输出多项式链表
Sort(ha); //原多项式链表排序
Sort(hb); //原多项式链表排序
printf(“有序多项式A：”);
DispPoly(ha); //输出多项式链表
printf(“有序多项式B：”);
DispPoly(hb); //输出多项式链表
Add(ha, hb, hc); //一元多项式的相加
printf(“多项式相 加：”);
DispPoly(hc); //输出多项式链表
}

4，运行展示在这里插入图片描述

在这里插入代码片
//一元多项式的表示及相加
//打开相应库文件
//定义多项式最大项数
#include   <stdio.h>
#include   <malloc.h>
#define   MAX  20
//定义单链表结点类型
typedef   struct  pnode
{
    float  coef;
    int   exp;
    struct  pnode* next;
}PolyNode;
//定义存放多项式的数组类型
typedef   struct
{float  coef;
 int   exp;
}PolyArray[MAX]; ;

//一元多项式的表示（建立多项式链表）
void  CreateListR(PolyNode*& L, PolyArray a, int  n)
{
    PolyNode* s, * r; int i;
    L = (PolyNode*)malloc(sizeof(PolyNode));
    L->next = NULL;
    r = L;
    for (i = 0; i < n; i++)
    {
        s = (PolyNode*)malloc(sizeof(PolyNode));
        s->coef = a[i].coef;
        s->exp = a[i].exp;
        s->next = NULL;
        r->next = s;
        r = s;
    }
    r->next = NULL;
}

//原多项式链表排序
void Sort(PolyNode*& head)
{
    PolyNode* p = head->next, * q, * r;
    if (p != NULL)
    {
        r = p->next;
        p->next = NULL;
        p = r;
        while (p != NULL)
        {
            r = p->next;
            q = head;
            while (q->next != NULL && q->next->exp > p->exp)
                q = q->next;
            p->next = q->next;
            q->next = p;
            p = r;
        }
    }
}

//一元多项式的相加
void Add(PolyNode* ha,PolyNode* hb, PolyNode*& hc)
{
    PolyNode* pa = ha->next, * pb = hb->next, * s, * tc;
    float 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;
            s->next = NULL;

            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;
            s->next = NULL;
            tc->next = s; tc = s;
            pb = pb->next;
        }

        else {
            c = pa->coef + pb->coef;
            if (c)
            {
                s = (PolyNode*)malloc(sizeof(PolyNode));
                s->exp = pa->exp; s->coef = c;
                s->next = NULL;
                tc->next = s; tc = s;
            }
            pa = pa->next;
            pb = pb->next;
        }
    }
    if (pb != NULL) pa = pb;
    while (pa != NULL)
    {
        s = (PolyNode*)malloc(sizeof(PolyNode));
        s->exp = pa->exp; s->coef = pa->coef;
        s->next = NULL;
        tc->next = s; tc = s;
        pa = pa->next;
    }
    tc->next = NULL;
}

//输出多项式链表
void  DispPoly(PolyNode* L)
{
    PolyNode* p = L->next;
    while (p != NULL)
    {
        printf("%gX^%d+", p->coef, p->exp); p = p->next;
      
    }
    printf("\b ");
    printf("\n\n");
}

//主函数的设定及调用
void main()
{
    PolyNode* ha, * hb, * hc;                                              //单链表结点类型
    PolyArray a = { {1.2 ,0}, {2.5,1} ,{3.2,3} ,{-2.5,5} };         //存放多项式a的数组类型
    PolyArray b = { {-1.2,0}, {2.5,1}, {3.2,3} ,{2.5,5} ,{5.4,10} };//存放多项式b的数组类型

    CreateListR(ha, a, 4);                              //一元多项式的表示（建立多项式链表）
    CreateListR(hb, b, 5);                              //一元多项式的表示（建立多项式链表）
    printf("原  多项式A：");
    DispPoly(ha);                                                          //输出多项式链表
    printf("原  多项式B：");
    DispPoly(hb);                                                          //输出多项式链表

    


    Sort(ha);                                                            //原多项式链表排序
    Sort(hb);                                                            //原多项式链表排序
    printf("有序多项式A：");
    DispPoly(ha);                                                          //输出多项式链表
    printf("有序多项式B：");
    DispPoly(hb);                                                          //输出多项式链表

    Add(ha, hb, hc);                                                     //一元多项式的相加
    printf("多项式相 加：");
    DispPoly(hc);                                                          //输出多项式链表
}
卦拾伍
关注
  • 1
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
【数据结构1】一元多项式相加（线性表链式存储）
zzynb666的博客
01-17 2292
题目描述：通过键盘输入两组多项式的系数和指数，当系数为零时表示输入结束，规定输入的指数是按从小到大顺序的，计算两个一元多项式相加的和多项式并用相同的方式输出 1.建立两个单链表，存储两个一元多项式（尾插法） typedef struct node{ int c; int e; struct node* next; }Node; Node* PolyCreate() { Node *head,*tail,*s;//head指向头结点，tail指向尾结点，*s是当前结点 head =.
C++ 链表实现两个一元多项式相加
09-15
c++，算法链表实现一元多项式相加，通过链表实现，非常好的一个程序
数据结构——一元多项式加法.zip
09-18
数据结构——一元多项式加法，使用数据结构中的线性表实现一元多项式加法
数据结构线性表一元多项式的表示及相加PPT学习教案.pptx
10-05
数据结构线性表一元多项式的表示及相加PPT学习教案.pptx
数据结构（C语言）代码实现（七）——一元多项式的表示与相加
weixin_74746867的博客
02-06 978
寒假在家，有点学不下去，写文章的速度也很慢，看来四十天完成这项任务是不可能了。但比较兴奋的是，在这个过程中，我调试代码的速度有了明显的提升，很多时候一些小细节我可以通过网上资源的帮助解决，这是我以前严重缺乏的能力。第二个收获就是在复现代码的过程中真正意识到了模块化的好处，就想这篇文章，就与上一篇单链表的代码实现息息相关，可以说，上一篇稍微改改，就可以成为这一篇的一个头文件，因此节省了我很大的工作量。这一章也算告一段落，下面就看看我的成果吧。数据结构（C语言）代码实现（六）——单链表的实现-CSDN博客。
C++实现一元多项式的表示及相加
01-11
用户可以根据自己的需求分别输入两个一元多项式，并且能够实现显示输入的一元多项式，再将这两个一元多项式相加，输出结果。
一元多项式表示及相加
10-17
数据结构第二章实验一元多项式求和，c语言链式结构实现
实验四 一元多项式的表示及相加
11-18
厦门大学信息科学与技术学院软件技术基础实验内容
【数据结构】一元多项式的表示及相加
程序员好冰的博客
03-27 5119
一元多项式的表示与相加
数据结构 实验1——一元多项式的表示与相加
热门推荐
m0_57587757的博客
09-16 1万+
一、实验名称：多项式相加 二、实验学时：4学时 三、实验目的 1.理解单链表的结构特性和基本操作算法； 2.掌握利用单链表实现两个多项式相加算法。 四、实验内容(步骤) 1.创建两个一元多项式； 2.输出一元多项式； 3.实现两个一元多项式相加； 4.输出相加后的一元多项式。 实验代码 #include<iostream> #include<stdlib.h> #define flag -1 // 定义数据输入结束的标志数据 using
[C语言、C++]数据结构作业：一元多项式的表示、求和
Yhisken的博客
10-09 1564
[C语言、C++]数据结构作业：一元多项式的表示、求和
数据结构——一元多项式相加（C语言版本）
qq_29992017的博客
09-25 1万+
创建多项式函数要求能在函数中输入多项式的各项 输入时逐项、按顺序输入一元多项式的系数、指数，输入系数为。本关任务：设计一种单链表存储结构，每个结点存储一项的系数和指数，类型都是整型，编写完成产生多项式的函数、多项式相加及输出多项式的函数。，则构成结果多项式中的一项，对于两个多项式中所有指数不同的项，则分别复制到结果多项式中。系数项，采用链式存储，对应链表结点数据结构可采取：（设多项式的系数和指数都是整型）一般情况下，一元多项式只表示非。输入时逐项、按顺序输入一元多项式的系数、指数，输入系数为。
实验一_数据结构算法_一元多项式_
10-04
数据结构算法，练习，较简单，一元多项式的加减乘除，练手完成作业
数据结构实验1.5：一元多项式的相加和相乘.doc
10-29
数据结构实验报告
一元多项式相加 数据结构实验报告.pdf
11-01
一元多项式相加 数据结构实验报告.pdf
数据结构-栈
2302_81705247的博客
05-02 777
遍历第一个数组，并将每一个元素放到栈中，直到栈顶元素与第二个数组的元素相同，弹出栈顶元素，并且第二个数组向后遍历，并判断栈顶元素是否与第二个数组的元素是否相同，如果相同，重复上一步骤。如果放入的元素大于minStack的栈顶元素，则不放入minStack，如果放入的元素小于minStack栈顶元素，则将该元素放入minStack。（2）pop：弹出stack的栈顶元素，如果stack的栈顶元素与minStack的栈顶元素相同，则minStack也弹出栈顶元素。给一个括号的式子，看式子中的括号是否相互匹配。
计算机408备考-数据结构重要知识点-数据结构的定义
Protinx的博客
05-02 165
数据结构是相互之间存在一种或多种特定关系的数据元素的集合。数据结构包括三方面的内容：逻辑结构、存储结构和数据的运算。数据的逻辑结构和存储结构是密不可分的两个方面，一个算法的设计取决于所选定的逻辑结构，而算法的实现则依赖于所采用的存储结构。【计算机408备考-数据结构重要知识点-数据结构的定义-哔哩哔哩】
《数据结构》C语言版 (清华严蔚敏考研版） 第二章 线性表知识梳理与总结
路漫漫其修远兮，吾将上下而求索。小手点一波关注进阶的李仙桎，我们一起携手进步，
04-28 1391
线性表是数据结构的一种，它是一组具有相同数据类型的数据元素的有限序列。在线性表中，除了第一个和最后一个数据元素之外，每个数据元素均只有一个直接前驱和一个直接后继。线性表的元素个数n（n≥0）定义为线性表的长度，当n=0时，称为空表。线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链表的形式存储线性表的抽象数据类型定义ADT List{数据对象:D={ai|aiEElemSet.i=1,2,…,n,n≥0} //任意数据元素的集合。
14.集合、常见的数据结构
最新发布
weixin_50975714的博客
05-02 775
Java是一个面向对象语言，将来肯定会处理对象。为了方便操作多个对象，就需要把这些对象存储起来，存储多个对象，就需要一个容器Java之前提供了数组、StringBuffer这两个容器，但是他们用来存放对象不是很方便所以，Java就提供了Collection集合。ArrayList底层是一个可以动态扩容的数组，可以存放任意类型的元素，可以存放null元素，存取有序，元素可以重复，线程是不安全的。
一元多项式合并同类项
11-24
合并一元多项式的同类项可以按照以下步骤进行： 1. 定义一个新的链表用于存储合并后的多项式。 2. 遍历原始多项式链表，将每一项的指数作为新链表的下标，将系数相加作为新链表该下标处的值。 3. 如果新链表某一项的值为0，则删除该项。 4. 将新链表按照指数从大到小排序，得到最终的合并后的多项式。 以下是一个Java实现的例子： ```java public class Polynomial { private Lnode head; // 定义多项式类的其他方法 // 合并同类项 public void merge() { Lnode newHead = new Lnode(0, 0); Lnode p = head; Lnode q = newHead; // 遍历原始多项式链表 while (p != null) { int exp = p.exp; float coef = p.coef; // 在新链表中查找是否已经存在该指数的项 Lnode r = newHead; while (r.next != null && r.next.exp > exp) { r = r.next; } // 如果存在，则将系数相加 if (r.next != null && r.next.exp == exp) { r.next.coef += coef; } else { // 否则插入新的项 Lnode node = new Lnode(coef, exp); node.next = r.next; r.next = node; } p = p.next; } // 删除系数为0的项 Lnode r = newHead; while (r.next != null) { if (r.next.coef == 0) { r.next = r.next.next; } else { r = r.next; } } // 将新链表按照指数从大到小排序 head = newHead.next; sort(); } // 按照指数从大到小排序 private void sort() { if (head == null || head.next == null) { return; } Lnode p = head.next; head.next = null; while (p != null) { Lnode q = p.next; insert(p); p = q; } } // 将节点插入到合适的位置 private void insert(Lnode node) { Lnode p = head; while (p.next != null && p.next.exp > node.exp) { p = p.next; } node.next = p.next; p.next = node; } } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

卦拾伍

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

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

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

打赏作者

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

抵扣说明：

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

余额充值