线性表的应用——多项式的计算

最新推荐文章于 2023-10-27 09:45:26 发布
最新推荐文章于 2023-10-27 09:45:26 发布
阅读量1k 收藏 9
点赞数 2
分类专栏： 数据结构（C语言） 文章标签： 线性表 c语言 多项式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/engerla/article/details/78305061
版权

应用顺序表计算多项式，把多项式存储在顺序表里，顺序表的下标对应多项式的系数
这里写图片描述

#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 100
#define OK 1
#define ERROR -1
typedef int Status;
typedef int Elemtype;

多项式的结构体

typedef struct polynomial
{
    float coef;//系数
    int expn;//指数
}Polyn;

顺序表的的结构体

typedef struct SqList
{
    Polyn *array;
    int length;
}SqList;

顺序线性表初始化

Status Init_SqList(SqList *L)
{
    L->array=(Polyn *)malloc(MAX_SIZE * sizeof(Polyn)) ;
    if(!L->array)
        return ERROR;
    else
    {
        L->length = 0;
        return OK;
    }
}

创建一个多项式

void CreatPolyn(SqList *L)
{
    int i;//循环变量
    int m;//多项式的项数
    SqList *q;
    q = L;

    printf("请输入多项式数：");
    scanf("%d", &m);

    if(m <= 0 || m > MAX_SIZE)
    {
        printf("Item unsecification!\n");
    }

    for(i = 0; i < m; i++)
    {
        float c;//多项式的系数
        printf("请输入%d次项的系数：", i);
        scanf("%f", &c);
        q->array[i].coef = c;
        q->array[i].expn = i;//顺序表达下表和指数是相同的，所以把下标赋给指数
        q->length++;
    }
    if(q->length == m)
        printf("创建成功\n");
}

求多项式的项数

Status PolynLength(SqList *L)
{
    int length = 0;
    int i;
    SqList *p;

    p = L;

    for(i = 0; i < p->length; i++)
    {
        length++;
    }

    return length;
}

多项式相加

Status AddPolyn(SqList *L1, SqList *L2, SqList *L3)
{   //L1+L2=L3
    int i;//循环变量
    SqList *p;
    SqList *q;
    SqList *r;

    p = L1;
    q = L2;
    r = L3;

    //若L1和L2不一样长，先把前面的部分相加
    for(i = 0; i < p->length && i < q->length; i++)
    {
        r->array[i].coef = p->array[i].coef + q->array[i].coef;
        r->array[i].expn = p->array[i].expn;
        r->length++;
    }
    //把长的直接加在L3后面
    if((i == p->length) && (i != q->length))
    {
        int j;

        for(j = i; j < q->length; j++)
        {
            r->array[j].coef = q->array[j].coef;
            r->array[j].expn = q->array[j].expn;
            r->length++;
        }
    }
    else if((i != p->length) && (i == q->length))
    {
        int j;

        for(j = i; j < p->length; j++)
        {
            r->array[j].coef = p->array[j].coef;
            r->array[j].expn = p->array[j].expn;
            r->length++;
        }
    }

    printf("项数为：%d\n", r->length);

    return OK;
}

两个多项式（L1-L2）相减

Status SubractPolyn(SqList *L1, SqList *L2, SqList *L3)
{
    int i;//循环变量
    SqList *p;
    SqList *q;
    SqList *r;

    p = L1;
    q = L2;
    r = L3;
    //若L1和L2不一样长，先把前面的部分相减
    for(i = 0; i < p->length && i < q->length; i++)
    {
        r->array[i].coef = p->array[i].coef - q->array[i].coef;
        r->array[i].expn = p->array[i].expn;
        r->length++;
    }
    //两个多项式不一样长
    //若被减数多项式长，则把剩下的直接加在L3后面
    //若减数多项式长，则把剩下的变成负的加在L3后面
    if((i == p->length) && (i != q->length))
    {
        int j;

        for(j = i; j < q->length; j++)
        {
            r->array[j].coef = -(q->array[j].coef);
            r->array[j].expn = q->array[j].expn;
            r->length++;
        }
    }
    else if((i != p->length) && (i == q->length))
    {
        int j;

        for(j = i; j < p->length; j++)
        {
            r->array[j].coef = p->array[j].coef;
            r->array[j].expn = p->array[j].expn;
            r->length++;
        }
    }

    return OK;
}

两个多项式相乘

Status MultiplyPolyn(SqList *L1, SqList *L2, SqList *L4)
{   //L1*L2 = L4
    int i;
    int j;
    SqList *p;
    SqList *q;
    SqList *r;

    p = L1;
    q = L2;

    //根据L1和L2相乘后的项数给L4申请空间
    //若L1有n项  L2有m项   则L4有（n-1）+（m-1）+ 1项
    L4->array=(Polyn *)malloc(((p->length - 1) + (q->length - 1) + 1) * sizeof(Polyn)) ;
    if(!L4->array)
        printf("初始化失败！\n");
    else
    {
        //L4的长度为：（n-1）+（m-1）+ 1
        L4->length = (p->length - 1) + (q->length - 1) + 1;
        printf("初始化成功！\n");
        printf("长度为：%d\n", L4->length);
    }

    r = L4;
    //先把L4所有的系数和指数赋为0
    for(i = 0; i < L4->length; i++)
    {
        r->array[i].coef = 0;
        r->array[i].expn = 0;
    }
    //系数相乘，指数相加，在和计算出来的位置上原有的系数相加  
    for(i = 0; i < p->length; i++)
    {
        for(j = 0; j < q->length; j++)
        {
            int a = p->array[i].expn + q->array[j].expn;
            r->array[a].expn = a;
            r->array[a].coef = p->array[i].coef * q->array[j].coef + r->array[a].coef;
        }
    }

    return OK;
}

打印多项式

void OutPut(SqList *L)//打印多项式
{
    SqList *q;
    int i;
    int j;

    q = L;

    printf("P = ");
    for(i = 0; i < q->length; i++)
    {
        if(i == 0)//若是常数项
        {
            if(!q->array[i].coef == 0)//不为0，打印
            {
                printf("%f", q->array[i].coef);
                for(j = i + 1; j < q->length; j++)
                {
                    if((q->array[j].coef != 0) && (q->array[j].coef > 0))
                    {
                        printf(" + ");
                        break;
                    }
                    else if((q->array[j].coef != 0) && (q->array[j].coef < 0))
                    {
                        printf(" ");
                        break;
                    }
                }
            }
        }
        else//若不是常数项
        {
            if(!q->array[i].coef == 0)//系数不为0 打印
            {
                printf("%fX^", q->array[i].coef);
                printf("%d", q->array[i].expn);
                for(j = i + 1; j < q->length; j++)
                {
                    if((q->array[j].coef != 0) && (q->array[j].coef > 0))
                    {
                        printf(" + ");
                        break;
                    }
                    else if((q->array[j].coef != 0) && (q->array[j].coef < 0))
                    {
                        printf(" ");
                        break;
                    }
                }
            }
        }
    }
    printf("\n");
}

主方法

int main()
{
    int i;
    int res1 = 0;//L1初始化返回结果
    int res2 = 0;//L2初始化返回结果
    int res3 = 0;//L3初始化返回结果
    int res4 = 0;//L4初始化返回结果
    int res5 = 0;//L1+L2返回的结果
    int res6 = 0;//L1-L2的结果
    int res7 = 0;//L1*L2的结果
    SqList L1;//第一个多项式
    SqList L2;//第二个多项式
    SqList L3;//相加后的多项式
    SqList L4;//相减后的多项式
    SqList L5;//L1*L2后的多项式

    res1 = Init_SqList(&L1);//初始化L1
    res2 = Init_SqList(&L2);//初始化L2
    res3 = Init_SqList(&L3);//初始化L3
    res4 = Init_SqList(&L4);//初始化L4
    printf("%4d%4d%4d%4d\n", res1, res2, res3, res4);

    CreatPolyn(&L1);//创建多项式L1
    OutPut(&L1);//打印多项式L1

    printf("--------------------------------\n");

    CreatPolyn(&L2);//创建多项式L2
    OutPut(&L2);//打印多项式L2

    printf("*******************************\n");
    printf("L1为：");
    OutPut(&L1);
    printf("\n");
    printf("L2为：");
    OutPut(&L2);
    printf("\n");

    printf("************L1+L2后************\n");//多项式L1+L2赋值给L3
    printf("\n");
    res5 = AddPolyn(&L1, &L2, &L3);
    OutPut(&L3);
    printf("\n");
    printf("%d\n", res5);
    printf("\n");

    printf("************L1-L2后************\n");
    printf("\n");
    res6 = SubractPolyn(&L1, &L2, &L4);
    OutPut(&L4);
    printf("\n");
    printf("%d\n", res6);
    printf("\n");

    printf("************L1*L2后************\n");
    printf("\n");
    res7 = MultiplyPolyn(&L1, &L2, &L5);

    for(i = 0; i < L5.length; i++)
    {
        printf("系数：%4f | 指数：%4d\n", L5.array[i].coef, L5.array[i].expn);
    }

    OutPut(&L5);
    printf("\n");
    printf("%d\n", res7);

    return 0;
}

若有汉字的编译错误，请把汉字改成英文就OK了
运行结果：
这里写图片描述

布丁吖
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线性表基础&线性表应用：多项式
richlaji的专栏
09-28 887
概念 线性表（亦作顺序表）是最基本、最简单、也是最常用的一种数据结构。线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的。 实际应用中，线性表都是以栈、对列、字符串等特殊线性表的形式中来使用的 结构特点 有序性：集合中必存在唯一的一个“第一元素”；集合中必存在唯一的一个 “最后元素”；除最后一个元素之外，均有唯一的后继；除第一个元素之外，均有唯一
线性表（一元多项式四则运算）
03-14
线性表多项式
数据结构:线性表应用-多项式计算
04-14
利用双向链表实现了多项式的加、减、乘及排序计算，可以很好的完成两个任意最高次数的多项式计算
利用线性表实现一个一元多项式
12-07
可以使用链表实现，也可以使用顺序表实现 具体要求如下： 能够实现一元多项式的输入和输出 能够进行一元多项式相加 能够进行一元多项式相减 能够计算一元多项式在x处的值 能够计算一元多项式的导数（选作） 能够进行一元多项式相乘 编写main ()函数测试算法的正确性
【数据结构（10）】2.8 线性表的案例分析与实现
shangguanxiu的博客
12-28 711
严蔚敏版【数据结构】1. 一元多项式的运算。 2. 稀疏多项式的运算： 多项式创建、 多项式的相加。 3. 图书信息管理系统。
数据结构实验2 线性表的应用
xiaoana_139的博客
05-17 3065
背景 在数学上，一个一元n次多项式Pn(x)可按降序写成： 它是由n＋1个系数唯一确定。因此，在计算机里它可以用一个线性表P来表示： P=（Pn, Pn-1, …, P1, Po）一元多项式的运算包括加法、减法和乘法，而多项式的减法和乘法都 可以用加法来实现。 实验目的 线性表ADT的应用，基于线性表设计和实现两个一元多项式的加法运算。 提示：用有序线性表表示一元多项式。表内元素按照多项式...
如何利用线性表？完成一元多项式运算【内容丰富，简单易懂】
qq_54169998的博客
01-11 3111
如何利用线性表完成一元多项式运算。多项式每项coef是该项系数，exp是变元x的指数单循环链表、结构体模板、类模板、友元函数以及运算符重载、程序设计思路、项结点实现 多项式类、多项式的输入和输出、多项式相加、多项式相乘 、重载运算符 将一个多项式看成一个线性表，线性表的元素就是多项式的项。对多项式算术运算而言，连接存储方式更合适。一般来来说，多项式的项数和指数变化较大，难以确定，若采用顺序存储方式，需要先分配足够空间，容易造成空间浪费；而采取链接存储方式，动态创建新结点以存储多项式的项，就十分灵活。
线性表的基本运算及多项式的算术运算
Ne0的博客
10-10 3462
线性表的基本运算： template voidSeqList::Reverse(){   T* t= new T[maxLength];   int j=0;   for (int i = 0; i   {     t[i] = elements[i];   }   for (int a = n; a>=0; a--)   {     elements[j++] = t
数据结构线性表的应用（集合；多项式）
充满好奇的threecat
10-14 900
前言： *今天老师提到了集合的运算，我就想起来需要用线性表来进行集合的运算（虽然数组也可），前不久写了多项式运算的代码，但是核心部分的加减还是有点模糊，决定细致的再看一下（again）。 1.我们先来说一般的集合并集的问题。即A、B表，将B中A不存的在元素插入A中，就得到合并的集合。* 算法有： void MergeList(List &LA, List&LB) { //将所有...
线性表在一元多项式运算中的应用
weixin_30786657的博客
04-08 358
实验题1-1 多项式运算 【问题描述】有两个指数递减的一元多项式，写一程序先求这两个多项式的和，再求它们的积。 【提示】 用带表头结点的单链表作为多项式的存储表示；要建立两个单链表；多项式相加就是要把一个单链表中的结点插入到另一个单链表中去，要注意插入、删除操作中指针的正确修改。 #include <iostream> using namespace std; ...
线性表应用 多项式加法
RubiscoI的博客
05-06 1074
"路漫漫其修远兮， 吾将上下而求索"
用线性表实现一个一元多项式Polynomial
11-22
该源程序是数据结构的代码实现：用线性表实现一个一元多项式Polynomial
线性表+应用+多项式+dev c++
03-27
线性表+应用+多项式+dev c++程序运行正常 程序可移植性强
数据结构课件：第2章 线性表2一元多项式的表示及相加.pptx
06-16
数据结构课件：第2章 线性表2一元多项式的表示及相加.pptx
线性表-多项式的加法.c
04-13
中国大学MOOC上浙大的《数据结构》课程 。用链表实现多项式加法，包括多项式的输入创建、多项式的加法、多项式的输出
利用线性表实现多项式的算术运算
xyy_ywqs的博客
06-12 626
#include <iostream> #include <string> using namespace std; class Term { public: Term(int c, int e); Term(int c, int e, Term* nxt); Term* InsertAfter(int c, int e);//在this指针指示的结点后抓人新结点 int coef; int exp; Term* link; private: friend ostrea
【数据结构】3话：线性表2
最新发布
m0_73973059的博客
10-27 130
笔记整理
线性表的应用（线性表、有序表的合并，多项式运算）
lesileqin的博客
03-09 1968
友情提示： 本博客所有代码均有使用链表、顺序表预编译的函数，有了算法，后续写程序自主调用就可以了。 友情链接： 顺序表的基本操作函数：https://blog.csdn.net/lesileqin/article/details/88075259 单链表的基本操作函数：https://blog.csdn.net/lesileqin/article/details/88088051 线性表的...
线性表的应用----多项式操作
欢迎来到Sylinx_yqg的博客
11-05 804
/**********************************************线性表的应用----多项式操作BY YQG.06.3.9 (网页排版较乱，可下载源码(点击右键，目标另存为）)(注：可将输入转为多项式整体输入)***********************************************/#include "stdio.h" #i
数据结构用链式线性表实现一元多项式求导
10-11
链式线性表实现一元多项式的结构体可以定义如下： ``` typedef struct PolyNode *Polynomial; struct PolyNode { int coef; // 系数 int expon; // 指数 Polynomial next; }; ``` 其中，`coef`表示系数，`expon`表示指数，`next`表示下一个节点的指针。 求导的过程可以通过遍历链表，对每一项进行求导，然后构造新的链表来实现。具体实现可以参考下面的代码： ``` Polynomial Derivative(Polynomial P) { Polynomial dP, pre, cur; dP = (Polynomial)malloc(sizeof(struct PolyNode)); dP->next = NULL; pre = dP; cur = P->next; while (cur) { if (cur->expon != 0) { Polynomial tmp = (Polynomial)malloc(sizeof(struct PolyNode)); tmp->coef = cur->coef * cur->expon; tmp->expon = cur->expon - 1; tmp->next = NULL; pre->next = tmp; pre = tmp; } cur = cur->next; } return dP; } ``` 该函数返回的是求导后的链表。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值