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

最新推荐文章于 2024-03-30 16:59:36 发布
最新推荐文章于 2024-03-30 16:59:36 发布
阅读量1.6k 收藏 14
点赞数 1
文章标签： 数据结构 算法 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63148076/article/details/129390630
版权
该代码实现了一元多项式的链式存储表示，包括创建链表、排序、相加及输出功能。通过输入两个多项式，程序能完成对它们的合并，并遵循指数相同的项系数相加，指数不同的项分别保留的规则。最后，展示了多项式相加的结果。
摘要由CSDN通过智能技术生成

一元多项式的表示和相加

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);                                                          //输出多项式链表
}
卦拾伍
关注
数据结构之一元多项式相加
学无止境
03-06 2万+
问题 采用链式存储结构，将两个线性链表表示的一元多项式相加，并输出。 算法设计 1、程序结构设计 1）数据结构 typedef struct node { floatcoef; //序数 intexpn; //指数 struct node *next; //指向下一个结点的指针 }......
数据结构（11）线性表之一元多项式表示及相加
YuYunTan的专栏
03-16 5064
导言 一元多项式介绍 抽象数据类型一元多项式定义 相加如何实现 结语导言符号多项式处理，是表处理的典型范例。而这章就是主要就本经典案例进行讨论。一元多项式介绍数学上，一个一元多项式pn(x)p_n(x)可以按照升幂写成pn(x)=p0+p1x+p2x2+...+pnxnp_n(x)=p_0+p_1x+p_2x^2+...+p_nx^n 它由n+1个系数唯一确定。因此在计算机里面，它可以由一个线性表
数据结构（c语言）一元多项式的表示相加级实现
10-24
数据结构（C语言版）严蔚敏版的内容，用C语言写的一元多项式的表示相加操作的实现，用vc6和其他的C语言运行软件都能运行
【数据结构】一元多项式的表示及相加
程序员好冰的博客
03-27 5925
一元多项式的表示与相加
数据结构 一元多项式相加
夜雨柠檬
03-22 3192
做一个豁达而努力的自己。相加的部分也就是用一个新的链表存储，，，和单链表尾插的方法差不多，，，也就是分了3种情况，，，代码：#include &lt;iostream&gt; using namespace std; //一元多项式的存储结构 typedef struct Node { int coe; //系数 int exp; //指数 Node *nex...
【数据结构】一元多项式的表示与相加（无序输入 有序输出）
ChenZHIHAO_y的博客
03-30 1485
数据结构第二章，用线性表表示一元多项式。实现一元多项式的相加、求导、求值、相减等运算
数据结构算法C语言实现（六）---2.4一元多项式的表示及相加
diancha6978的博客
06-07 1453
　　一.简述 　　利用链表表示稀疏多项式，并基于之前的一些操作（编程实现上还是有所不同的）组合新的操作实现一元多项式的表示及相加。 　　二.ADT 1 抽象数据类型一元多项式的定义 2 ADT Polyomail{ 3 数据对象：D = {a[i]|a[i]属于TermSet, i = 1,2,3...,m,m>=0 4 ...
数据结构 实验1——一元多项式的表示与相加
热门推荐
m0_57587757的博客
09-16 1万+
一、实验名称：多项式相加 二、实验学时：4学时 三、实验目的 1.理解单链表的结构特性和基本操作算法； 2.掌握利用单链表实现两个多项式相加算法。 四、实验内容(步骤) 1.创建两个一元多项式； 2.输出一元多项式； 3.实现两个一元多项式相加； 4.输出相加后的一元多项式。 实验代码 #include<iostream> #include<stdlib.h> #define flag -1 // 定义数据输入结束的标志数据 using
数据结构——一元多项式加法.zip
09-18
一元多项式加法是数学中的基本运算，而在编程和算法设计中，这种运算可以通过利用数据结构，尤其是线性表来实现。这篇内容将深入探讨如何使用线性表来实现一元多项式加法。 首先，理解一元多项式。一元多项式是由...
数据结构——一元多项式乘法与加法
Bridge3的博客
09-09 1968
02-线性结构2 一元多项式的乘法与加法运算（20 分） 设计函数分别求两个一元多项式的乘积与和。 输入格式: 输入分2行，每行分别先给出多项式非零项的个数，再以指数递降方式输入一个多项式非零项系数和指数（绝对值均为不超过1000的整数）。数字间以空格分隔。 输出格式: 输出分2行，分别以指数递降方式输出乘积多项式以及和多项式非零项的系数和指数。数字间以空格分隔，但结尾不能有多余空格。零...
一元多项式的表示及相加
11-07
数据结构中用c++编写一元多项式的表示及相加。
一元多项式表示及相加
10-17
数据结构第二章实验一元多项式求和，c语言链式结构实现
数据结构——一元多项式加法、减法、乘法运算的实现
07-13
### 数据结构——一元多项式加法、减法、乘法运算的实现 #### 设计内容及要求 本节详细介绍了如何使用不同的数据结构来实现一元多项式的加法、减法以及乘法运算。 ##### 1.1 设计内容 1. **使用顺序存储结构实现...
Day 4：线性表——一元多项式的表示及相加
交交的土拨鼠的博客
07-06 1036
了解一元多项式的表示方法和基本运算的实现方法。
一元多项式的表示和相加
m0_59073956的博客
11-05 1126
多项式相加
[数据结构]一元多项式的表示与相加
代码中枢：软件工程理论与实践的桥梁
03-08 343
/* * @Author: * @Date: 2019-12-03 20:48:51 * @Last Modified by: * @Last Modified time: 2019-12-03 21:05:06 */ #include <iostream> #include <cstdio> using namespace std; typedef ...
一元多项式的表示及相加（c语言实现）
talentxiaolin的博客
04-05 3500
一元多项式顾名思义就是好多个式子相加减，显然想到的就是利用单链表来实现，我在此处只讨论一元多项式相加的情况，相减也是一样的做法。首先，两个一元多项式相加，可以把它转化为两个单链表的合并，这是首要，然后就是将相同指数的项合并，将不同指数的项从小到大的顺序排列，使得相加后的一元多项式更加美观。具体代码及注释如下： #include<stdio.h> #include<stdlib.h> #define LEN sizeof(poly) typedef struct term{ ..
编写一个程序用单链表存储多项式，并实现两个一元多项式A与B相加的函数。A，B刚开始指数是递增有序的，A与B之和按降序排列。
最新发布
10-11
为了编写一个程序，我们可以首先定义一个`Node`类表示多项式的项，包括系数和指数。然后创建一个`PolynomialList`类用于管理单链表结构，其中包含一个头部节点和相关的操作方法，如添加项、合并两个多项式等。 ```python class Node: def __init__(self, coefficient=0, exponent=0): self.coefficient = coefficient self.exponent = exponent self.next = None class PolynomialList: def __init__(self): self.head = None # 添加项到链表 def add_term(self, coefficient, exponent): new_node = Node(coefficient, exponent) if not self.head: self.head = new_node else: current = self.head while current.next and current.next.exponent >= exponent: current = current.next new_node.next = current.next current.next = new_node # 合并两个多项式 def merge_polynomials(self, other): combined_list = PolynomialList() current_a = self.head current_b = other.head while current_a and current_b: a_coeff = current_a.coefficient b_coeff = current_b.coefficient if current_a.exponent > current_b.exponent: combined_list.add_term(a_coeff, current_a.exponent) current_a = current_a.next elif current_a.exponent < current_b.exponent: combined_list.add_term(b_coeff, current_b.exponent) current_b = current_b.next else: # 当两项指数相同时，取较大系数 combined_list.add_term(max(a_coeff, b_coeff), current_a.exponent) current_a = current_a.next current_b = current_b.next # 如果还有剩余的项，则逐个添加 while current_a: combined_list.add_term(current_a.coefficient, current_a.exponent) current_a = current_a.next while current_b: combined_list.add_term(current_b.coefficient, current_b.exponent) current_b = current_b.next return combined_list # 示例： polynomial_A = PolynomialList() polynomial_B = PolynomialList() # 分别为A和B添加项... # ... sum_poly = polynomial_A.merge_polynomials(polynomial_B) ``` 这个程序首先定义了单链表中的节点，并实现了多项式链表的基本操作。`merge_polynomials`函数负责合并两个多项式，按照题目要求将结果按降序排列。你可以根据实际需求，补充添加项到`polynomial_A`和`polynomial_B`的具体代码。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

卦拾伍

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

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

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

打赏作者

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

抵扣说明：

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

余额充值