【数据结构】--一元n次多项式模板

最新推荐文章于 2024-05-24 23:10:34 发布
最新推荐文章于 2024-05-24 23:10:34 发布
阅读量540 收藏 3
点赞数 1
分类专栏： 学习之路
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/QXK_Jack/article/details/108948838
版权

一元n次多项式

我把first开到公有了。

 

实验二：一元多项式的基本运算

实验目的：掌握用线性表实现一元多项式的基本运算。

实验内容：使用链式存储实现一元多项式的加法、减法、乘法和求导。即：

C(x)= A(x)+B(x)；C(x)= A(x)-B(x) C(x)= A(x)*B(x) C(x)= A’(x)

菜单：

1)C ：分别创建两个多项式A(x)和B(x)，其中 输入时按照 指数的升序顺序输入，遇到系数为0则停止。例如：输入 ：

1 2 3 4 5 6 7 8

2 3 4 5 6 7 0 

则生成的多项式分别为：

A(x)=x^2+3x^4+5x^6+7x^8

B(x)=2x^3+4x^5+6x^7

2)P:计算C(x)= A(x)+B(x)，计算完毕后输出C(x)的 结果

3)S: 计算C(x)= A(x)-B(x)，计算完毕后输出C(x)的 结果

4)M: 计算C(x)= A(x)*B(x)，计算完毕后输出C(x)的 结果

5)D: 计算C(x)= A’(x)，计算完毕后输出C(x)的 结果

6)V: 首先输入一个 float型数据，然后计算 A(x)并输出计算的结果。

7)E: 分别清空A(x)、B(x)、C(x)三个多项式。

8)X: 退出程序。

 

 

例如:

输入期望输出实际输出
C
1 2 3 4 5 6 7 8 0
2 3 4 5 6 7 0
S
P
M
D
V
2
X
 
C(x)=x^2-2x^3+3x^4-4x^5+5x^6-6x^7+7x^8
C(x)=x^2+2x^3+3x^4+4x^5+5x^6+6x^7+7x^8
C(x)=2x^5+10x^7+28x^9+52x^11+58x^13+42x^15
C(x)=2x+12x^3+30x^5+56x^7
2164.00
 
C(x)=x^2-2x^3+3x^4-4x^5+5x^6-6x^7+7x^8
C(x)=x^2+2x^3+3x^4+4x^5+5x^6+6x^7+7x^8
C(x)=2x^5+10x^7+28x^9+52x^11+58x^13+42x^15
C(x)=2x+12x^3+30x^5+56x^7
2164.00
C
2 2 0
2 2 3 3 0
P
S
M
D
V
3.1
X
 
C(x)=4x^2+3x^3
C(x)=-3x^3
C(x)=4x^4+6x^5
C(x)=4x
19.22
 
C(x)=4x^2+3x^3
C(x)=-3x^3
C(x)=4x^4+6x^5
C(x)=4x
19.22
C
3 0 2 2 0
-2 2 3 3 0
M
V
2.1
P
S
D
X
 
C(x)=-6x^2+9x^3-4x^4+6x^5
11.82
C(x)=3+3x^3
C(x)=3+4x^2-3x^3
C(x)=4x
 
C(x)=-6x^2+9x^3-4x^4+6x^5
11.82
C(x)=3+3x^3
C(x)=3+4x^2-3x^3
C(x)=4x

通过所有测试 

 
  

 

#include <iostream>
#include<bits/stdc++.h>
using namespace std;
class List;
class LinkNode
{
    friend class List;
private:
    int a,p;
    LinkNode *link;
public:
    LinkNode(const int & item1,const int& item2, LinkNode *ptr = NULL)
    {
        a=item1;
        p=item2;
        link=ptr;
    }
    LinkNode (LinkNode *ptr = NULL)
    {
        link=ptr;
    }
    ~LinkNode() { };
};
class List
{
private:

public:
    LinkNode *first;
    List ()
    {
        first = new LinkNode ();
    }
    ~List ()
    {
        MakeEmpty(first);   //析构函数
    }
    void MakeEmpty (LinkNode *first);      //链表置空
    int Remove ( int i );     //需要补充的成员函数
    void input( LinkNode *first);
    void output( LinkNode *aa);      //需要补充的成员函数
    void Sort( LinkNode *aa);
    void Insert(int val);
    void add(LinkNode *aa,LinkNode *b);
    void jian(LinkNode *aa,LinkNode *b);
    void mult(LinkNode *aa,LinkNode *b);
    void devide(LinkNode *aa);
    double caculate(LinkNode *aa,double val);
};
void List:: MakeEmpty (LinkNode *first)
{
    LinkNode *q;
    while (first->link != NULL )
    {
        q = first->link;
        first->link = q->link;
        delete q;
    }
}
void List:: input(  LinkNode *first)
{
    int n,val,cnt;
    LinkNode *newnode;
    for(int i=1; ; i++)
    {
        cin>>val;
        if(val==0)
            break;
        cin>>cnt;
        newnode=new LinkNode(val,cnt);
        newnode->link=first->link;
        first->link=newnode;

    }
}
void List::Sort(LinkNode *first)
{
    LinkNode *i=first->link,*j;
    while (i!= NULL )
    {
        j=i->link;
        while(j!=NULL)
        {
            if(i->p>j->p)
            {
                int temp;
                temp=j->p;
                j->p=i->p;
                i->p=temp;
                temp=j->a;
                j->a=i->a;
                i->a=temp;
                ///改成结构体存ap的话，就很简单了，但是我不想改了hhh
            }
            j=j->link;
        }
        i=i->link;
    }
}
void List::output( LinkNode *first)
{
    cout<<"C(x)=";
    LinkNode *q=first->link;
    int cnt=0;
    while (q!= NULL )
    {
        if(q->a>0&&cnt>0)printf("+");
        if(q->a==0)
        {
        }
        else
        {

            if(q->p==0&&q->a==1) printf("1"),cnt++;
            if(q->a!=1)printf("%d",q->a),cnt++;
            if(q->p==0) {cnt++;}
            else if(q->p!=1) {
                    printf("x^%d",q->p);
                    cnt++;
            }
            else if(q->p==1)
            {
                printf("x");
                cnt++;
            }
        }
        q =q->link;
    }
    if(cnt==0) cout<<"0"<<endl;
    cout<<endl;
}
void List::add(LinkNode *aa,LinkNode *b)
{
    LinkNode *i=aa,*newnode,*temp=first;
    //cout<<aa->link->a<<endl;
    while(i->link!=NULL)
    {
        int f=0;
        LinkNode *j=b;
        while(j->link!=NULL)
        {
            if((i->link->p)==(j->link->p))
            {
                f=1;
                int val=i->link->a+j->link->a;
                //int cnt=i->link->p+j->link->p;
                newnode=new LinkNode(val,i->link->p);
                newnode->link=first->link;
                first->link=newnode;
            }
            j=j->link;
        }
        if(f==0)
        {
            newnode=new LinkNode(i->link->a,i->link->p);
            newnode->link=first->link;
            first->link=newnode;
        }
        i=i->link;
    }
    ///
    ///
    i=b;///*i=b是错误写法
    while(i->link!=NULL)
    {
        int f=0;
        LinkNode *j=aa;
        while(j->link!=NULL)
        {
            if((i->link->p)==(j->link->p))
            {
                f=1;
            }
            j=j->link;
        }
        if(f==0)
        {
            newnode=new LinkNode(i->link->a,i->link->p);
            newnode->link=first->link;
            first->link=newnode;
        }
        i=i->link;
    }
}
void List::jian(LinkNode *aa,LinkNode *b)
{
    LinkNode *i=aa,*newnode,*temp=first;
    //cout<<aa->link->a<<endl;
    while(i->link!=NULL)
    {
        int f=0;
        LinkNode *j=b;
        while(j->link!=NULL)
        {
            if((i->link->p)==(j->link->p))
            {
                f=1;
                int val=i->link->a-j->link->a;
                //int cnt=i->link->p+j->link->p;
                newnode=new LinkNode(val,i->link->p);
                newnode->link=first->link;
                first->link=newnode;
            }
            j=j->link;
        }
        if(f==0)
        {
            newnode=new LinkNode(i->link->a,i->link->p);
            newnode->link=first->link;
            first->link=newnode;
        }
        i=i->link;
    }
    ///
    ///
    i=b;///*i=b是错误写法
    while(i->link!=NULL)
    {
        int f=0;
        LinkNode *j=aa;
        while(j->link!=NULL)
        {
            if((i->link->p)==(j->link->p))
            {
                f=1;
            }
            j=j->link;
        }

        if(f==0)
        {
            newnode=new LinkNode(-i->link->a,i->link->p);
            newnode->link=first->link;
            first->link=newnode;
        }
        i=i->link;
    }
}
void List::mult(LinkNode *aa,LinkNode *b)
{
    LinkNode *i=aa,*j=b,*newnode;
    while(i->link!=NULL)
    {
        j=b;///前面已经定义过了
        while(j->link!=NULL)
        {
            newnode=new LinkNode(i->link->a*j->link->a,i->link->p+j->link->p);
            newnode->link=first->link;
            first->link=newnode;
            j=j->link;
        }
        i=i->link;
    }
    LinkNode *temp=first->link;
    Sort(first);
    //output(first);
    while(temp!=NULL)
    {
        LinkNode *tt=temp;
        if(temp->link!=NULL)
        {
            while(tt->p==tt->link->p&&tt->link!=NULL)
            {
                temp->a+=tt->link->a;
                temp->link=tt->link;
                tt=tt->link;
            }
            temp->link=tt->link;
        }
        temp=tt->link;
    }

}
void List::devide(LinkNode *aa)
{
    LinkNode *newnode,*i=aa->link;
    while(i!=NULL)
    {
         newnode=new LinkNode(i->a*i->p,i->p-1);
         newnode->link=first->link;
         first->link=newnode;
         i=i->link;
         //cout<<newnode->a<<" "<<newnode->p<<endl;
    }
}
double  List::caculate(LinkNode *aa,double val)
{
    double ans=0;
    LinkNode *i=aa->link;
    while(i!=NULL)
    {
        ans+=i->a*pow(val,i->p);
        i=i->link;
    }
    return ans;
}
int main()
{
    List La,Lb,Lc;
    string s;
    cin>>s;
    if(s[0]=='C')
    {
        La.input(La.first);
        La.Sort( La.first);
        Lb.input(Lb.first);
        Lb.Sort( Lb.first);
    }
//    La.output(La.first);
//    cout<<endl;
//    Lb.output(Lb.first);
    while(1)
    {
        cin>>s;
        if(s[0]=='X')
            return 0;
        else if(s[0]=='S')
        {
            Lc.MakeEmpty(Lc.first);
            Lc.jian(La.first,Lb.first);
            //Lc.output(Lc.first);
            Lc.Sort(Lc.first);
            Lc.output(Lc.first);
        }
        else if(s[0]=='P')
        {
            Lc.MakeEmpty(Lc.first);
            Lc.add(La.first,Lb.first);
            //Lc.output(Lc.first);
            Lc.Sort(Lc.first);
            Lc.output(Lc.first);
        }
        else if(s[0]=='M')
        {
            Lc.MakeEmpty(Lc.first);
            Lc.mult(La.first,Lb.first);
            //Lc.output(Lc.first);
            Lc.Sort(Lc.first);
            Lc.output(Lc.first);
        }
        else if(s[0]=='D')
        {
            //La.output(La.first);
            Lc.MakeEmpty(Lc.first);
            Lc.devide(La.first);
            Lc.Sort(Lc.first);
            Lc.output(Lc.first);
        }
        else if(s[0]=='V')
        {
            double data;
            cin>>data;
            printf("%.2f\n",La.caculate(La.first,data));
        }
        else if(s[0]=='E')
        {
            La.MakeEmpty(La.first);
            Lb.MakeEmpty(Lb.first);
            Lc.MakeEmpty(Lc.first);
        }
    }


    return 0;
}

 

QXK_Jack
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构的应用——一元N次多项式的加法
山顶冻人的专栏
03-23 2004
<br /><br /><br /> <br />采用ArrayList来实现多项式，为免要求输入时按升幂输入，可以调用Collections的sort方法。<br />建立每个项的类PolyItem，实现Comparable接口以便ArrayList的排序，代码如下：<br />/** * 多项式的项，并实现了项的大小比较 * @author Bao Yiming */ class PolyItem implements Comparable<PolyItem> { Integer
C++数据结构课程设计-一元稀疏多项式
12-08
在本项目中，我们关注的是"C++数据结构课程设计-一元稀疏多项式"，这是一个针对大学生在数据结构课程中的实践项目。数据结构是计算机科学的重要组成部分，它研究如何在计算机中有效地组织和存储数据，以便进行高效的...
一元n次多项式
01-10
一元n次多项式的加减乘 (1) 界面友好，函数功能要划分好 (2) 总体设计应画一流程图 (3) 程序要加必要的注释 (4) 要提供程序测试方案 (5) 程序一定要经得起测试，宁可功能少一些，也要能运行起来，不能运行的程序是没有价值的。
一元n次多项式(polynomial)数据结构的（实现利用重载的）
11-25
两个头文件、一个cpp文件，基于数据结构的思想，文件比较小，可以直接运行。
一千题，No.0022（一元多项式求导）
最新发布
2301_76783671的博客
05-24 300
以与输入相同的格式输出导数多项式非零项的系数和指数。数字间以空格分隔，但结尾不能有多余空格。注意“零多项式”的指数和系数都是 0，但是表示为。输入形式为F(x) = 3*x^4 + (-5)*x^2 + 6*x^1 + (-2)*x^0;以指数递降方式输入多项式非零项系数和指数（绝对值均为不超过 1000 的整数）。大佬用一个标志位就解决了空格和空输入的问题，如果为输入就需要输出0 0，如果输入就输出空格。设计函数求一元多项式的导数。（注：xn（n为整数）的一阶导数为nxn−1。输出的为求导后的结果;
数据结构——一元n次多项式加法
君陌的博客
11-20 1183
此为本人在学习数据结构时所写的，各个功能能够实现，有main.cpp，link.h，list.h，list.cpp四个文件 使用说明： 请按照输入提示输入多项式的次数和各项系数，； 输入请按照提示要求！ 请不要输入数字之外的其他文字 例： 3 3 2 2 3 1 1 0 0 表示最高级数为3的多项式：2x3+3x2+1*x1+0x0 5 5 1 0 0 表示最高级数为5的多项式：1x^5 main...
一元 n 次多项式运算程序
张小艾博客
11-28 1732
前言：个人实现的一个用带头结点的链表实现的一元多项式运算程序。该程序支持多项式的创建、打印、加、减、乘以及取反操作。并且具备相应的用户操作菜单，用户提示菜单。其中针对多项式的各种操作已经模块化，并且每一个函数的功能都做了非常详细的注释。话不多说，开始讲解代码。 存储结构 链表结点结构体 采用单链表的结点形式来存储多项式的每一个单项式。结构体中定义了单项式的系数和次数，以及指向下一个结点的指针。...
数据结构_实验_课程设计_一元稀疏多项式Polynomial_代码&报告
12-10
数据结构是计算机科学中的核心课程，它探讨了如何有效地...通过实现一元稀疏多项式的操作，学生能够掌握数据结构优化的技巧，了解如何在实际问题中选择合适的数据结构和算法，为后续的软件开发和研究打下坚实的基础。
数据结构：一元稀疏多项式计算器（含图形界面）
10-08
设计一个C++模板类Polynomial，其中T给出了系数的类型。类Polynomial应该带有一个私有成员degree，它是多项式的阶数。当然，它还可能包含其他的私有成员。...采用适当的多项式测试一元稀疏多项式简单计算器的基本功能。
北邮数据结构上机一元多项式.pdf
11-06
"数据结构实验报告-一元多项式" 本实验报告的主要目的是为了熟悉 C++ 语言的基本编程方法，掌握集成编译环境的测试方法，学习指针、模板类、异常处理的使用，掌握线性表的操作实现方法，并培养使用线性表解决实际...
cpp代码-一元多项式2
07-16
一元多项式是数学中的基础概念，它由常数、变量及其各次幂组合而成，如 \( ax^n + bx^{n-1} + ... + c \)，其中 \( a, b, ..., c \) 是系数，\( n \) 是非负整数。在编程中，我们通常会用类（class）来表示这种数据...
一元多次（一元一次，两次，三次）方程求解
04-12
这个是类库来的，另外一个才是，不好意思，传错了！。
一元多项式的实现 使用类
05-18
通过节点类实现一元多项式 无结构体 完善加减乘法
一元多项式的加法、减法、乘法
06-17
使用链表来实现单元多项式的加法、减法、乘法。其中，加法是其它运算的基础，减法：poly1-poly2=poly1+(-poly2)，乘法：poly1*poly2，可用poly1乘以poly2的每一项，相加其乘积结果。
c 一元多项式 课程设计
06-01
能够按照指数降序排列建立并输出多项式； 能够完成两个多项式的相加、相减，并将结果输入； 在上交资料中请写明：存储结构、多项式相加的基本过程的算法（可以使用程序流程图） 、源程序、测试数据和结果、算法的时间复杂度、另外可以提出算法的改进方法；
C++语言用于数据结构 求一元n次多项式的值
01-07
一个n次多项式如： 其中被称为系数。在本题中使用LinkedList类，其数据记录项Term中包含每一项的系数 及x的幂次。 struct Term { double coeff; int power; }; 在程序中以（系数、幂次）对的序列输入一个多项式。在输入的幂次为0时终止程序，将每对系数/幂次存储到按幂次排序的链表中。 （a）按以下形式输出结果多项式中的每一项 ai*x^i （b）输入x的3个值并调用函数 double poly(LinkedList&f, double x); 求出多项式的值并输出结果。
用直接计算法和秦九韶算法求解一元n次多项式
weixin_46302044的博客
11-21 2099
用直接计算法和秦九韶算法求解一元n次多项式 一、实验目的 掌握秦九韶算法求解多项式的基本原理； 分别编程实现用直接计算法和秦九韶算法求解一元n次多项式 f(x)=3x6+4x4-2x3-7x2+x-8在x=2.5时的值； 比较两种算法求解多项式的时间。 二、实验设备 编程语言：C； 实验环境：已安装相关编程环境的计算机1台。 三、算法实现及结果分析 #include<stdio.h> #include<math.h> #include<time.h> #defin
用php 实现一元多次线性回归模型 matlab 中 polyfit
weixin_30822451的博客
06-15 344
一元多次线性回归模型公式： y = b0 + b1* x + b2 * x^2 + b3 * x^3 + ..... + bn * x^n; 这个matlab中已经给出了方法polyfit(); 下面是用php代码实现的： public function polyfit($n, $x, $y, $poly_n, &$a) { for ($i = 0; $i &lt...
【系列】【模板】 多项式
weixin_30505225的博客
12-11 76
【模板】 多项式乘法 学习一波NTT 放弃FFT 1 #include<iostream> 2 #include<cstdio> 3 #include<cstdlib> 4 #include<cmath> 5 #include<algorithm> 6 #include<cstring> ...
数据结构--绪论--求解多项式的值
09-08
1. 给定一个多项式，例如 P(x) = a_n * x^n + a_{n-1} * x^{n-1} + ... + a_1 * x^1 + a_0，其中 a_i 表示系数，x 表示变量。 2. 给定变量 x 的值。 3. 将 x 的值代入多项式中的每一项，计算得到每一项的值。 4. 将...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值