【数据结构】PTA C++顺序存储结构实现多项式存储与处理

最新推荐文章于 2024-06-10 15:19:14 发布
最新推荐文章于 2024-06-10 15:19:14 发布
阅读量1.1k 收藏 12
点赞数 4
文章标签： 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/page1rank/article/details/127741635
版权

一元n次多项式的存储和处理

【前言】

这是我写的第一篇博客，如有错误请指正，共同进步。下面的程序代码实现了一元n次多项式的创建，输出，加法，减法，乘法，求函数值，如果没有读者想要实现的功能，可以节约时间离开了。当然如果想要直接借用代码，翻到【最终代码】查阅即可（平时自己在CSDN上查找资料的时候，效率总是很慢，笔者也希望用此提示告诉大家以下代码可以实现什么）。最后笔者作为一个小白，我相信读者稍花时间，一定能明白下面的代码。

【题目详细】

一元n次多项式定义如下：


其中Ai​为实数，i为不小于0的整数。定义一元n次多项式操作包括:
(1）输入各个系数Ai​和指数i，创建一个多项式；
(2) 输出多项式：将一元n次多项式输出为：F(X)=An​X^n+...+A1​X+A0​
(3) 两个多项式相加：输入两个多项式，求出并输出两个多项式的和；
(4) 两个多项式相减：输入两个多项式，求出并输出两个多项式的差；
(5) 两个多项式相乘：输入两个多项式，求出并输出两个多项式的积；
(6) 求函数值：输入X，求出并输出一元n次多项式的值。

输入格式：

有两个一元n次多项式，分别为：
f(X)=3X^2+ X+1
g(X)=−2X^2−X-1
其中系数为实数,指数取不小于0的整数，求x=10时f(x)的值。则输入分为3行，第1行为第一个一元n次多项式，第1个一元n次多项式按照第1项系数,指数 第2项系数,指数 .... 的格式输入，系数和指数以“,”分割，各项的系数和指数之间以空格分割，输入一元n次多项式不要求由高次项到低次项排列，最后以 0,0（即系数=0,指数=0）表示结束，输入多项式可以为空。第2行为第二个一元n次多项式，输入格式与第一个一元n次多项式相同。第3行为X的值。对上面的两个一元n次多项式：

输入样例:

3,2 1,1 1,0 0,0
-2,2 -1,1 -1,0 0,0
10

输出格式:

输出分为以下几行：第1行输出第1个一元n次多项式，第2行输出第2个一元n次多项式，第3行输出两个一元n次多项式的和，第4行输出两个一元n次多项式的差，第5行输出两个一元n次多项式的乘积，第6行输出第1个一元n次多项式带入X后求出的值。输出要求一元n次多项式的高次项在前，低次项在后，实数保留小数点后面1位数，一元多项式为空时输出为空，即：若g(x)输入为空，输为g(x)=。对上面2个一元n次多项式的输出为：

输出样例:

f(x)=3.0X^2+X+1.0
g(x)=-2.0X^2-X-1.0
f(x)+g(x)=X^2
f(x)-g(x)=5.0X^2+2.0X+2.0
f(x)*g(x)=-6.0X^4-5.0X^3-6.0X^2-2.0X-1.0
f(10.0)=311.0

 【分步代码展示】

开头部分

#include<bits/stdc++.h>
using namespace std;

笔者的建议是直接万能头文件，省时好记，写代码前直接敲上去，管他三七二十一。

------------------------------------------------------我是分割线---------------------------------------------------------

main函数部分

int main()
{
    poly pl1[1000];
    poly pl2[1000];
    int i = 0,j = 0;
    double value;
    int end_flag1 = 0,end_flag2 = 0;
    do
    {
        i++;
        scanf("%lf,%lf",&pl1[i].xishu,&pl1[i].zhishu);
        end_flag1 = i;

    }
    while(pl1[i].xishu != 0 || pl1[i].zhishu != 0);
    int a;
    while ((a=getchar()) != '\n' && a != EOF);
    do
    {
        j++;
        scanf("%lf,%lf",&pl2[j].xishu,&pl2[j].zhishu);
        end_flag2 = j;

    }
    while(pl2[j].xishu != 0.0 || pl2[j].zhishu != 0.0);
    int b;
    while ((b=getchar()) != '\n' && b != EOF);
    cin >> value;
    //标准化多项式，指数降序排列
    sort(pl1+1,pl1+end_flag1+1,cmp);
    sort(pl2+1,pl2+end_flag2+1,cmp);
}

首先定义了两个结构体数组（poly pl1，pl2）用于记录两多项式的系数、指数。结构体创建如下：

typedef struct feature
{
    double zhishu;
    double xishu;
} poly;

然后定义了两个循环用的万年常客i、j变量。一个双精度浮点数Double类型的用于读入输出函数值部分的自变量x的值。定义了两个记录结构体数组结束位置的变量（定义结构体数组的时候，我大手一挥，干了个1000，说白了这两个变量来收拾我的残局）。

后面便是循环输入两个多项式的系数，指数（遇见0，0停止）。scanf有个特殊的地方，他会把我本来转行输入的回车给读进去，导致输入后存储环节出问题。为了避免，笔者直接派a，b给读走了。

sort函数排序按照cmp规则，按照指数降序排序。cmp函数如下：

int cmp(poly a,poly b)
{
    return a.zhishu > b.zhishu;
}

------------------------------------------------------我是分割线--------------------------------------------------------- 

函数部分

output输出

传入两个参数，记载着一个多项式系数、指数的结构体数组、该数组结束位置。

num：遍历结构体数组所记录的系数，如果为零，num++。如果num==end_flag说明改多项式系数都为零，即该多项式为0。

showpos：输出数值前的正负号。

noshowpos：不输出数值前的正负号。

fixed << setpresicion(x)：控制输出x位小数。

这一块函数笔者可能处理的比较复杂，考虑到0，1在系数指数中的存在规则。笔者把第一项与其他项分开讨论，而在每一情况中又分开讨论了系数为0/1，不为0/1，指数为0/1，不为0/1。（系数为0这一项不用输出，系数为1要省去系数，指数为1要省去指数，指数为0要省去x）仔细想一想可以想明白应该。

void output(poly x[],int end_flag)
{
    int i,num=0;
    for(i=1; i<=end_flag; i++)
    {
        if(x[i].xishu == 0)
        {
            num++;
        }
    }
    if(num == end_flag)
    {
        cout << "0";
    }
    else
    {
        if(x[1].xishu != 0.0)
        {
            if(x[1].xishu == 1.0)
            {
                if(x[1].zhishu == 1)
                {
                    cout << "X" ;
                }
                else
                {
                    cout << "X^" << noshowpos << fixed << setprecision(0) << x[1].zhishu;
                }
            }
            else if(x[1].xishu > 0 && x[1].xishu != 1)
            {
                if(x[1].zhishu == 1)
                {
                    cout << fixed << setprecision(1) << noshowpos << x[1].xishu << "X";
                }
                else
                {
                    cout << fixed << setprecision(1) << noshowpos << x[1].xishu << "X^" ;
                    cout << noshowpos << fixed << setprecision(0) << x[1].zhishu;
                }
            }
            else
            {
                if(x[1].zhishu == 1)
                {
                    cout << fixed << setprecision(1) << showpos << x[1].xishu << "X";
                }
                else
                {
                    cout << fixed << setprecision(1) << showpos <<  x[1].xishu << "X^" ;
                    cout << noshowpos << fixed << setprecision(0) << x[1].zhishu;
                }
            }
        }
        for(i = 2; i <=end_flag; i++)
        {
            if(x[i].xishu != 0.0)
            {
                if(x[i].xishu == 1.0)
                {
                    if(x[i].zhishu == 1)
                    {
                        cout << "+" << "X" ;
                    }
                    else if(x[i].zhishu == 0)
                    {
                        cout << "+1.0";
                    }
                    else
                    {
                        cout << "+" << "X^" << noshowpos << x[i].zhishu;
                    }
                }
                else if(x[i].xishu == -1.0)
                {
                    if(x[i].zhishu == 1)
                    {
                        cout << "-" << "X" ;
                    }
                    else if(x[i].zhishu == 0)
                    {
                        cout << "-1.0";
                    }
                    else
                    {
                        cout << "-" << "X^" <<  noshowpos << x[i].zhishu;
                    }
                }
                else
                {
                    if(x[i].zhishu == 1)
                    {
                        cout << showpos << fixed << setprecision(1) << x[i].xishu << "X";
                    }
                    else if(x[i].zhishu == 0)
                    {
                        cout << showpos << fixed << setprecision(1) << x[i].xishu;
                    }
                    else
                    {
                        cout << showpos << fixed << setprecision(1) << x[i].xishu << "X^" ;
                        cout << noshowpos << fixed << setprecision(0) << x[i].zhishu;
                    }
                }
            }
        }
    }
}

加法

传入四个参数，两个记载着一个多项式系数、指数的结构体数组、两个该数组结束位置。

end_flag==1：说明多项式1=0，直接输出多项式2。

poly pl_add[1000]：定义一个新的结构体数组用来储存加法运算后的多项式系数、指数。首先把两个多项式接在一起，多项式2接在多项式1的后面。排序。然后合并同类项。

void add(poly x[],poly y[],int end_flag1,int end_flag2)
{
    if(end_flag1 == 1)
    {
        output(y,end_flag2);
    }
    else if(end_flag2 == 1)
    {
        output(x,end_flag1);
    }
    else
    {
        int i,j,cnt;
        cnt = end_flag1 + end_flag2;
        poly pl_add[1000];
        for(i=1; i<=end_flag1; i++)
        {
            pl_add[i].xishu = x[i].xishu;
            pl_add[i].zhishu = x[i].zhishu;
        }
        for(j=end_flag1+1; j<=end_flag1+end_flag2; j++)
        {
            pl_add[j] .xishu = y[j-end_flag1].xishu;
            pl_add[j].zhishu = y[j-end_flag1].zhishu;
        }
        sort(pl_add+1,pl_add+cnt+1,cmp);
        for(i=1; i<=end_flag1+end_flag2; i++)
        {
            for(j=1; j<=end_flag1+end_flag2-1; j++)
            {
                if(pl_add[i].zhishu == pl_add[i+j].zhishu)
                {
                    pl_add[i].xishu = pl_add[i].xishu + pl_add[i+j].xishu;
                    pl_add[i+j].xishu = 0;

                }
            }
        }
        output(pl_add,cnt);
    }
}

减法

传入四个参数，两个记载着一个多项式系数、指数的结构体数组、两个该数组结束位置。

end_flag==1：说明多项式1=0，直接输出-多项式2。

poly pl_sub[1000]：定义一个新的结构体数组用来储存加法运算后的多项式系数、指数。

void sub(poly x[],poly y[],int end_flag1,int end_flag2)
{
    if(end_flag1 == 1)
    {
        for(int k=1; k<=end_flag2; k++)
        {
            y[k].xishu = -1 * y[k].xishu;
        }
        output(y,end_flag2);
    }
    else if(end_flag2 == 1)
    {
        output(x,end_flag1);
    }
    else
    {
        int i,j,k,cnt;
        cnt = end_flag1 + end_flag2;
        poly pl_sub[1000];
        for(i=1,j=1,k=1; k<=cnt;)
        {
            if(x[i].zhishu == y[j].zhishu)
            {
                pl_sub[k].zhishu = x[i].zhishu;
                pl_sub[k].xishu = x[i].xishu - y[i].xishu;
                i++;
                j++;
                k++;
            }
            else
            {
                if(x[i].zhishu > y[j].zhishu)
                {
                    pl_sub[k].zhishu = x[i].zhishu;
                    pl_sub[k].xishu = x[i].xishu;
                    i++;
                    k++;
                }
                else
                {
                    if(y[i].xishu < 0)
                    {
                        pl_sub[k].zhishu = y[i].zhishu;
                        pl_sub[k].xishu = -1 * y[i].xishu;
                        j++;
                        k++;
                    }
                    else
                    {
                        pl_sub[k].zhishu = y[i].zhishu;
                        pl_sub[k].xishu = y[i].xishu;
                        j++;
                        k++;
                    }
                }
            }
        }
        output(pl_sub,cnt);
    }
}

乘法

传入四个参数，两个记载着一个多项式系数、指数的结构体数组、两个该数组结束位置。

poly pl_multi[1000]：定义一个新的结构体数组用来储存加法运算后的多项式系数、指数。

乘法与加法有着很大的相似性，乘法双层循环相乘后得出的数组，排序，然后合并同类项。

void multi(poly x[],poly y[],int end_flag1,int end_flag2)
{
    int i,j,cnt=0;
    poly pl_multi[1000];
    poly pl_multi_[1000];
    for(i=1; i<=end_flag1; i++)
    {
        for(j=1; j<=end_flag2; j++)
        {
            cnt++;
            pl_multi[cnt].xishu = x[i].xishu * y[j].xishu;
            pl_multi[cnt].zhishu = x[i].zhishu + y[j].zhishu;
        }
    }
    for(i=1; i<=cnt; i++)
    {
        for(j=1; j<=cnt; j++)
        {
            if(pl_multi[i].zhishu == pl_multi[i+j].zhishu)
            {
                pl_multi[i].xishu = pl_multi[i].xishu + pl_multi[i+j].xishu;
                pl_multi[i+j].xishu = 0;
            }
        }
    }
    output(pl_multi,cnt);
}

输出函数值

传入三个参数，记载着一个多项式系数、指数的结构体数组、自变量值、该数组结束位置。

很简单看看就懂。

void output_value(poly x[],double value,int endflag)
{
    int ans = 0;
    double temp;
    for(int i = 1; i<endflag-1; i++)
    {
        temp = value;
        for(int j=2; j<=x[i].zhishu; j++)
        {
            temp = temp * value;
        }
        ans = ans + x[i].xishu * temp;
    }
    if(ans ==0)
    {
        cout << "0";
    }
    else
    {
        cout << fixed << setprecision(1) << ans + x[endflag - 1].xishu;
    }
}

调用函数 

在main函数里调用写的函数，只不过要加入一些补充输出的成分。具体在最终代码部分展示。

------------------------------------------------------我是分割线---------------------------------------------------------

【最终代码展示】

#include<bits/stdc++.h>
using namespace std;
typedef struct feature
{
    double zhishu;
    double xishu;
} poly;

int cmp(poly a,poly b)
{
    return a.zhishu > b.zhishu;
}

void output(poly x[],int end_flag)
{
    int i,num=0;
    for(i=1; i<=end_flag; i++)
    {
        if(x[i].xishu == 0)
        {
            num++;
        }
    }
    if(num == end_flag)
    {
        cout << "0";
    }
    else
    {
        if(x[1].xishu != 0.0)
        {
            if(x[1].xishu == 1.0)
            {
                if(x[1].zhishu == 1)
                {
                    cout << "X" ;
                }
                else
                {
                    cout << "X^" << noshowpos << fixed << setprecision(0) << x[1].zhishu;
                }
            }
            else if(x[1].xishu > 0 && x[1].xishu != 1)
            {
                if(x[1].zhishu == 1)
                {
                    cout << fixed << setprecision(1) << noshowpos << x[1].xishu << "X";
                }
                else
                {
                    cout << fixed << setprecision(1) << noshowpos << x[1].xishu << "X^" ;
                    cout << noshowpos << fixed << setprecision(0) << x[1].zhishu;
                }
            }
            else
            {
                if(x[1].zhishu == 1)
                {
                    cout << fixed << setprecision(1) << showpos << x[1].xishu << "X";
                }
                else
                {
                    cout << fixed << setprecision(1) << showpos <<  x[1].xishu << "X^" ;
                    cout << noshowpos << fixed << setprecision(0) << x[1].zhishu;
                }
            }
        }
        for(i = 2; i <=end_flag; i++)
        {
            if(x[i].xishu != 0.0)
            {
                if(x[i].xishu == 1.0)
                {
                    if(x[i].zhishu == 1)
                    {
                        cout << "+" << "X" ;
                    }
                    else if(x[i].zhishu == 0)
                    {
                        cout << "+1.0";
                    }
                    else
                    {
                        cout << "+" << "X^" << noshowpos << x[i].zhishu;
                    }
                }
                else if(x[i].xishu == -1.0)
                {
                    if(x[i].zhishu == 1)
                    {
                        cout << "-" << "X" ;
                    }
                    else if(x[i].zhishu == 0)
                    {
                        cout << "-1.0";
                    }
                    else
                    {
                        cout << "-" << "X^" <<  noshowpos << x[i].zhishu;
                    }
                }
                else
                {
                    if(x[i].zhishu == 1)
                    {
                        cout << showpos << fixed << setprecision(1) << x[i].xishu << "X";
                    }
                    else if(x[i].zhishu == 0)
                    {
                        cout << showpos << fixed << setprecision(1) << x[i].xishu;
                    }
                    else
                    {
                        cout << showpos << fixed << setprecision(1) << x[i].xishu << "X^" ;
                        cout << noshowpos << fixed << setprecision(0) << x[i].zhishu;
                    }
                }
            }
        }
    }
}

void add(poly x[],poly y[],int end_flag1,int end_flag2)
{
    if(end_flag1 == 1)
    {
        output(y,end_flag2);
    }
    else if(end_flag2 == 1)
    {
        output(x,end_flag1);
    }
    else
    {
        int i,j,cnt;
        cnt = end_flag1 + end_flag2;
        poly pl_add[1000];
        for(i=1; i<=end_flag1; i++)
        {
            pl_add[i].xishu = x[i].xishu;
            pl_add[i].zhishu = x[i].zhishu;
        }
        for(j=end_flag1+1; j<=end_flag1+end_flag2; j++)
        {
            pl_add[j] .xishu = y[j-end_flag1].xishu;
            pl_add[j].zhishu = y[j-end_flag1].zhishu;
        }
        sort(pl_add+1,pl_add+cnt+1,cmp);
        for(i=1; i<=end_flag1+end_flag2; i++)
        {
            for(j=1; j<=end_flag1+end_flag2-1; j++)
            {
                if(pl_add[i].zhishu == pl_add[i+j].zhishu)
                {
                    pl_add[i].xishu = pl_add[i].xishu + pl_add[i+j].xishu;
                    pl_add[i+j].xishu = 0;

                }
            }
        }
        output(pl_add,cnt);
    }
}

void sub(poly x[],poly y[],int end_flag1,int end_flag2)
{
    if(end_flag1 == 1)
    {
        for(int k=1; k<=end_flag2; k++)
        {
            y[k].xishu = -1 * y[k].xishu;
        }
        output(y,end_flag2);
    }
    else if(end_flag2 == 1)
    {
        output(x,end_flag1);
    }
    else
    {
        int i,j,k,cnt;
        cnt = end_flag1 + end_flag2;
        poly pl_sub[1000];
        for(i=1,j=1,k=1; k<=cnt;)
        {
            if(x[i].zhishu == y[j].zhishu)
            {
                pl_sub[k].zhishu = x[i].zhishu;
                pl_sub[k].xishu = x[i].xishu - y[i].xishu;
                i++;
                j++;
                k++;
            }
            else
            {
                if(x[i].zhishu > y[j].zhishu)
                {
                    pl_sub[k].zhishu = x[i].zhishu;
                    pl_sub[k].xishu = x[i].xishu;
                    i++;
                    k++;
                }
                else
                {
                    if(y[i].xishu < 0)
                    {
                        pl_sub[k].zhishu = y[i].zhishu;
                        pl_sub[k].xishu = -1 * y[i].xishu;
                        j++;
                        k++;
                    }
                    else
                    {
                        pl_sub[k].zhishu = y[i].zhishu;
                        pl_sub[k].xishu = y[i].xishu;
                        j++;
                        k++;
                    }
                }
            }
        }
        output(pl_sub,cnt);
    }
}
void multi(poly x[],poly y[],int end_flag1,int end_flag2)
{
    int i,j,cnt=0;
    poly pl_multi[1000];
    poly pl_multi_[1000];
    for(i=1; i<=end_flag1; i++)
    {
        for(j=1; j<=end_flag2; j++)
        {
            cnt++;
            pl_multi[cnt].xishu = x[i].xishu * y[j].xishu;
            pl_multi[cnt].zhishu = x[i].zhishu + y[j].zhishu;
        }
    }
    for(i=1; i<=cnt; i++)
    {
        for(j=1; j<=cnt; j++)
        {
            if(pl_multi[i].zhishu == pl_multi[i+j].zhishu)
            {
                pl_multi[i].xishu = pl_multi[i].xishu + pl_multi[i+j].xishu;
                pl_multi[i+j].xishu = 0;
            }
        }
    }
    output(pl_multi,cnt);
}

void output_value(poly x[],double value,int endflag)
{
    int ans = 0;
    double temp;
    for(int i = 1; i<endflag-1; i++)
    {
        temp = value;
        for(int j=2; j<=x[i].zhishu; j++)
        {
            temp = temp * value;
        }
        ans = ans + x[i].xishu * temp;
    }
    if(ans ==0)
    {
        cout << "0";
    }
    else
    {
        cout << fixed << setprecision(1) << ans + x[endflag - 1].xishu;
    }
}

int main()
{
    poly pl1[1000];
    poly pl2[1000];
    int i = 0,j = 0;
    double value;
    int end_flag1 = 0,end_flag2 = 0;
    do
    {
        i++;
        scanf("%lf,%lf",&pl1[i].xishu,&pl1[i].zhishu);
        end_flag1 = i;

    }
    while(pl1[i].xishu != 0 || pl1[i].zhishu != 0);
    int a;
    while ((a=getchar()) != '\n' && a != EOF);
    do
    {
        j++;
        scanf("%lf,%lf",&pl2[j].xishu,&pl2[j].zhishu);
        end_flag2 = j;

    }
    while(pl2[j].xishu != 0.0 || pl2[j].zhishu != 0.0);
    int b;
    while ((b=getchar()) != '\n' && b != EOF);
    cin >> value;
    //标准化多项式，指数降序排列
    sort(pl1+1,pl1+end_flag1+1,cmp);
    sort(pl2+1,pl2+end_flag2+1,cmp);
    //下面输出第一个多项式
    cout << "f(x)=";
    if(end_flag1 != 1)
    {
        output(pl1,end_flag1);
    }
    cout << endl;
    cout << "g(x)=";
    if(end_flag2 != 1)
    {
        output(pl2,end_flag2);
    }
    cout << endl;
    //下面输出两个多项式的加法
    cout << "f(x)+g(x)=";
    if(end_flag1 != 1 || end_flag2 !=1)
    {
        add(pl1,pl2,end_flag1,end_flag2);
    }
    cout << endl;
    //下面输出两个多项式减法
    cout << "f(x)-g(x)=";
    if(end_flag1 != 1 || end_flag2 !=1)
    {
        sub(pl1,pl2,end_flag1,end_flag2);
    }
    cout << endl;
    //下面输出两个多项式相乘
    cout << "f(x)*g(x)=";
    if(end_flag1 != 1 && end_flag2 !=1)
    {
        multi(pl1,pl2,end_flag1,end_flag2);
    }
    cout << endl;
    //下面输出多项式的值
    cout << "f(" << noshowpos << fixed << setprecision(1) << value << ")=";
    output_value(pl1,value,end_flag1);
    return 0;
}

博客代码编写不易，如有错误请指正，如赞同还请点赞关注。

------------------------------------------------------我是分割线--------------------------------------------------------- 

【效果展示】

 

UPCzyf
关注
  • 4
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
一元多项式计算器.zip_C++_attentionyhs_单链表实现一元多项式_数据结构_表达式 计算器
07-14
(1)建立含有若干个元素的带表头的单链表； 要求从键盘输入和文件读入两个多项式，显示并保存。 （2）设有一元多项式Am(x)和Bn(x). Am(x)=A0+A1x1+A2x2+A3x3+...+Amxm Bn(x)=B0+B1x1+B2x2+B3x3+...+Bnxn 请实现求M(x)=Am(x)+Bn(x)、M(x)=Am(x)-Bn(x)、M(x)=Am(x)×Bn(x)以及计算M(x)=0的根，计算多项式在x处的值，求多项式M的导函数M，并将结果保存在文本文件中。 （3）多项式的输出形式为类数学表达式。例如，多项式-3x8+6x3-18的输出形式为-3x^8+6x^3-18，x15+(-8)x7-14的输出形式为x^15+8x^7-14。注意，数值为1的非零次项的输出形式中略去系数1，如项1x8的输出形式为x8，项-1x3的输出形式为-x3。
数据结构 C++实现一元多项式运算（顺序存储结构实现）
qq_54388490的博客
03-12 7269
实验目的 1、 了解线性表的特性,以及它在实际问题中的应用。 2、掌握线性表的顺序存储的实现方法以及它的基本操作，学会运用线性表来解决问题。 实验内容 用顺序存储结构实现一元多项式的加法、减法和乘法。具体要求为：用五个函数分别实现一元多项式的创建、输出、加法、减法和乘法；然后在主函数中调用这些函数实现这些功能的展示。 代码内容 #include<iostream> using namespace std; #define maxdegree 100 //多项式最大项数 //定义多项式结构体 t
【校队+实验班】萌新训练赛【1】
m0_65508678的博客
08-28 152
【校队+实验班】萌新训练赛【1】
数据结构基础：P2-线性结构----编程作业02：一元多项式的乘法与加法运算
InnerPeaceHQ的博客
12-20 1408
本系列文章为浙江大学陈越、何钦铭数据结构学习笔记，前面的系列文章链接如下： 数据结构基础：P1-基本概念 数据结构基础：P2.1-线性结构—＞线性表 数据结构基础：P2.2-线性结构—＞堆栈 数据结构基础：P2.3-线性结构—＞队列 数据结构基础：P2.4-应用实例—＞多项式加法运算 文章目录一、题意理解与多项式表示1.1 题意理解1.2 多项式表示二、程序框架及读入多项式2.1 程序框架2.2 读入多项式三、加法、乘法运算及多项式输出3.1 加法运算3.2 乘法运算3.3 多项式输出四、整体代码与测试结
洛谷P1067多项式输出 题解
zhang14369的博客
10-28 598
洛谷P1067多项式输出 题解 ——作者：岸芷汀兰 一、题目 题目描述 一元 n 次多项式可用如下的表达式表示： 其中，aixi称为 i 次项，ai 称为 i 次项的系数。给出一个一元多项式各项的次数和系数，请按照如下规定的格式要求输出该多项式： 多项式中自变量为 x，从左到右按照次数递减顺序给出多项式。 多项式中只包含系数不为 0 的项。 如果多项式 n 次项系数为...
C/C++ PTA 6-2 另类堆栈---数据结构
敲代码嘞~的博客
09-29 613
其中Stack/* 存储元素的数组 *//* 栈顶指针 *//* 堆栈最大容量 */注意：如果堆栈已满，Push函数必须输出“Stack Full”并且返回false；如果队列是空的，则Pop函数必须输出“Stack Empty”，并且返回ERROR。
PTA c++部分预备知识
vanadiumv2o3的博客
08-31 1190
总结做题时学到的知识点，思路仅供参考
数据结构 C++实现一元多项式运算（链式存储）
热门推荐
qq_54388490的博客
03-20 1万+
文章目录一、实验目的二、实验内容三、代码内容1、多项式创建2、输出函数3、多项式加减法4、冒泡排序5、多项式乘法四、运行结果五、总结 一、实验目的 1、 了解线性表的特性,以及它在实际问题中的应用。 2、掌握线性表的链式存储的实现方法以及它的基本操作，学会运用单链表来解决问题。 二、实验内容 题目：用带头节点的单链表存储一元多项式的每一项，实现求一元多项式的加法、减法和乘法。具体要求为：用五个函数分别实现一元多项式的创建、输出、加法、减法和乘法；然后在主函数中调用这些函数实现这些功能的展示，以菜单的形式呈现
c++数据结构实验：多项式相加
07-11
实现了A=7+3x+9x^8+5x^17与B=8x+22x^7+(-9)x^8相加的和，内含算法详细讲解，运行结果与源代码
数据结构课程设计大数相乘与多项式相乘.doc
12-14
数据结构课程设计大数相乘与多项式相乘.doc
数据结构多项式加法C语言实现
10-27
严蔚敏 《数据结构》C语言版本第二章链表应用中有多项式加法的应用。本程序能对两个输入的多项式相加，并输出相加的结果。多项式可以一次性输入完成，并用（0，0）表示结束。
数据结构实验源码（C++实现）
11-18
本资源包里的数据结构实验内容如下： 一、顺序表基础 1、建立一个顺序表，利用一维数组来存储，含有n个数据元素； 2、输出顺序表； 3、找到顺序表中第i个元素并输出，在顺序表中查找e并返回它的位置； 4、完成在第...
c++实现的数据结构-DataStructure.zip
05-23
c++实现的数据结构（数组二叉树、链式二叉树、线索化二叉树、集合、图遍历DFA\BFS、约瑟夫环、多项式操作） c++实现的数据结构（数组二叉树、链式二叉树、线索化二叉树、集合、图遍历DFA\BFS、约瑟夫环、多项式操作...
数据结构多项式--加法、乘法、减法（C语言）友好界面
qq_56108311的博客
12-27 3339
问题重述 一元稀疏多项式简单计算器的基本功能是： (1)输入并建立多项式； (2)输出多项式，输出形式为整数序列：n,c1,e1,c2,e2,…,cn,en, 其中n是多项式的项数，ci,ei分别是第i项的系数和指数，序列按指数降序排列； (3)多项式a和b相加，建立多项式a+b； (4)多项式a和b相减，建立多项式a-b； (5)计算多项式在x处的值；即给定x值，计算多项式值。 拓展:多项式乘法；多项式系数的合并和排序（无论是指数大的在前面还是指数小的在前面，都可以，或者指数相同的...
利用单链表存储一元多项式_用C++实现<<大话数据结构>>单链表（上）...
weixin_39711959的博客
11-28 510
佛祖保佑，祝福各位1.什么是单链表对于数据结构的解释我不想套用复杂的详尽的说明方式，因为这一部分的内容相对基础，我更希望用图片和自己的一些理解来进行解释，这样也方便于我记忆：以往我们使用array来创建数组储存数据时，我们通常会初始化一个具体的数组大小的数据，比如说5。如此一来，计算机就会在我们的内存中预留出一个能够存储5个相同类型的内存空间。值得注意的是，这一部分的内存空间通常是连续的...
PTA-简单一元多项式的基本运算（不含除法）
moreerom的博客
09-22 445
题目类型 输入多项式，进行一系列运算后输出。 输入样式 第一行输入项数，第二行以（系数，指数）的方式输入数据。 ·4 (6,0)(2,1)(-8,70)(4,150) 输出样式 6+2X-8X^70+4^150 通用代码 注意看注释 /* 多项式的运算器 */ /* 使用手册在主函数中以注释方式给出，目前求导有问题，只能对一半 */ /* 本程序只针对pta平台的本次作业，如若需要其他用途，请自行修改 */ #include <stdio.h> #include <stdlib.h
PTA 一元多项式的乘法与加法运算
LYQ_YXQ的博客
01-09 459
PTA 一元多项式的乘法与加法运算
一元多项式输入、输出、运算（基于链表）
qq_34771124的博客
03-21 4061
题目描述 测试程序 #include <stdlib.h> #include <stdio.h> #define MAXLINE 1024 // 交换 a, b，以t为中间变量 #define SWAP(a,b,t) (t)=(a),(a)=(b),(b)=(t) // 单项式结构 typedef struct MonomialStruct{ int coef; // 系数 int expo; // 幂次 struct MonomialSt
数据结构逻辑
最新发布
qq_42129915的博客
06-10 316
1、线性关系2：树型关系3：图像关系。
使用递归方法求n阶勒让德多项式的值，递归公式为： image.png 其中：n和x为int型；Pn(x)为float型
04-09
好的，我可以回答这个问题。使用递归方法求n阶勒让德多项式的值的方法如下： ``` float legendre(int n, float x) { if (n == 0) { return 1.0; } if (n == 1) { return x; } float Pn1 = x; float Pn2 = 1.0; float Pn = 0.0; for (int i = 2; i <= n; i++) { Pn = ((2.0 * i - 1.0) * x * Pn1 - (i - 1.0) * Pn2) / (i * 1.0); Pn2 = Pn1; Pn1 = Pn; } return Pn; } ``` 这个函数的输入是n和x，其中n表示阶数，x表示自变量。输出则是对应的勒让德多项式Pn(x)的值。 使用递归的方式实现勒让德多项式需要考虑到递归公式中的n-1项和n-2项，因此需要用一个循环语句来计算递推值，这个循环从n=2开始，一直计算到n的值为输入n。 希望这个回答对您有所帮助。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值