顺序表实现稀疏多项式 完整代码

最新推荐文章于 2023-03-30 20:24:41 发布
最新推荐文章于 2023-03-30 20:24:41 发布
阅读量1.8k 收藏 36
点赞数 6
分类专栏： 数据结构 文章标签： 数据结构 C语言 顺序表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hpu_yangchen/article/details/107393351
版权

顺序表实现稀疏多项式

原文链接
由于书上给的代码都是只有核心的代码，没法直接实现，所以我就尝试将书上提到的函数都用c语言实现了一下。仅供参考，用来对照一下书中的代码，加深理解。如果有错误的话，希望大家指出来。

注意点

书中说是给的C语言的伪代码，但是给的代码还是用到了一些c++的东西，比如说status InitList(SqList &L),这个地方就是用到了c++的引用。具体c语言的指针和c++的引用的区别，这里就不过多赘述，想要了解可以查其他资料。

书中所有提到的函数基本上我都实现了，亲测可以运行。其中main()函数每一个注释块中都是对某个函数的功能的尝试。想要运行特定函数，直接删除注释就可以直接使用。由于函数太多，下面我直挑重要的讲解。

线性表结构

为了能够更好的说明线性表Sqlist的结构，我画了一个插图来说明。第一次画，画的不好请见谅。请结合稀疏多项式代码理解。

在这里插入图片描述

顺序表结构

在结构体polynomial中存储了每个多项式的系数和指数，在Sqlist结构体中存储了所有的多项式，length存储了多项式的个数。

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

typedef struct
{
    Polynomial *elem;
    int length;
}SqList;

初始化

我们使用C语言的malloc函数为顺序表的Polynomial结构体分配特定大小的空间。

int InitList(SqList *L)
{
    L->elem = (Polynomial *)malloc(MAXSIZE * sizeof(Polynomial));
    if(!L->elem)
        return OVERFLOW;
    L->length = 0;
    return OK;
}

顺序表元素的插入

在顺序表元素的插入这一点，我写了两个函数。ListInput函数是直接在顺序表的末尾插入元素。ListInsert函数是在指定的i元素之前插入新的元素。

int ListInput(SqList *L,Polynomial e)
{
    i=L->length;
    L->elem[i]=e;
    L->length++;
    return OK;
}

int ListInsert(SqList *L, int i, Polynomial e)
{
    if(i<1||i>L->length+1)
        return error;
    if(L->length == MAXSIZE)
        return error;
    for(j=L->length-1;j>=i-1;j--)
        L->elem[j+1] = L->elem[j];
    L->elem[i-1] = e;
    ++L->length;
    return OK;
}

顺序表遍历

为了能够更好的验证我们的每一项的操作是否成功的修改了顺序表。我写了一个遍历函数，将顺序表的所有元素都输出一遍。方便查看顺序表的元素。

int TraverseList(SqList *L)
{
    for(i=0;i<L->length;i++)
        printf("第%d个元素：,系数：%f,指数：%d \n",i,L->elem[i].coef,L->elem[i].expn);
    return OK;
}

顺序表取值

顺序表的取值是为了获得第i个元素的值，并将结果保存在结构体e中。

int GetElem(SqList *L, int i,Polynomial *e)
{
    if(i<1||i>L->length)
        return error;
    e = &(L->elem[i-1]);
    return OK;
}

顺序表的查找

顺序表的查找功能是为了查找第一个等于元素e的元素的位置。

int LocateElem(SqList *L,Polynomial e)
{
    for(i=0;i<L->length;i++)
        if(L->elem[i].coef == e.coef&&L->elem[i].expn == e.expn)
            return i+1;
    return error;
}

顺序表的删除

顺序表的删除功能是删除第i个元素。实现的操作就是从i+1位置的元素统一往前挪一位就行。然后单链表的长度减一位。

int ListDelete(SqList *L,int i)
{
    if(i<1||i>L->length)
        return error;
    for(j=i;j<=L->length-1;j++)
        L->elem[j-1]=L->elem[j];
    --L->length;
    return OK;
}

有序顺序表的合并

由于书中也提到了有序线性表的合并，所以就一并在这个地方写下来了。首先，一定要知道是有序线性表才可以这样写。无序的更加麻烦，在这里就不写了。
有序线性表的合并采用的就是归并排序的思想。创建另一个顺序表L3，然后比较两个指针，分别指向有序线性表L1和L2的首个元素。然后比较大小。选择小的元素进入L3，然后指针挪到下一位，继续比较。

int margc(SqList *L1,SqList *L2,SqList *L3)
{
    Polynomial x;   //为了跟上边e区别，这里使用x
    i=0,j=0;
    while(i<L1->length&&j<L2->length)
    {
        if(L1->elem[i].expn<L2->elem[j].expn)
        {
            x=L1->elem[i];
            ListInput(L3,x);
            i++;
        }
        else if(L1->elem[i].expn==L2->elem[j].expn)
        {
            x.coef = L1->elem[i].coef+L2->elem[j].coef;
            x.expn = L1->elem[i].expn;
            ListInput(L3,x);
            i++;
            j++;
        }
        else
        {
            x=L2->elem[j];
            ListInput(L3,x);
            j++;
        }
    }
    while(j<L2->length)
    {
        x= L2->elem[j];
        ListInput(L3,x);
        j++;
    }
    while(i<L1->length)
    {
        x = L1->elem[i];
        ListInput(L3,x);
        i++;
    }
    return OK;
}

完整代码

#include <stdio.h>
#include <stdlib.h>

#define MAXSIZE 100
#define OK 1
#define OVERFLOW -1
#define error -2
#define False 0 

int i,j,k;

typedef struct 
{
    float coef;             //稀疏多项式系数
    int expn;               //稀疏多项式指数
}Polynomial;

typedef struct
{
    Polynomial *elem;
    int length;
}SqList;

int InitList(SqList *L);                        //构建一个空的线性表
int DestroyList(SqList *L);                     //销毁一个已经存在的线性表
int ListInput(SqList *L,Polynomial e);          //在线性表末尾添加一个新元素
int ListInsert(SqList *L, int i, Polynomial e); //在指定的i元素之前添加一个新元素
int TraverseList(SqList *L);                    //遍历整个线性表
int ListDelete(SqList *L,int i);                //删除第i个元素
int ClearList(SqList *L);                       //将线性表设为空表
int ListEmpty(SqList *L);                       //检查线性表是不是为空，返回true或者false
int ListLength(SqList *L);                      //返回线性表中的元素个数
int GetElem(SqList *L, int i,Polynomial *e);    //返回第i个元素
int LocateElem(SqList *L,Polynomial e);         //返回第一个与e相同的数据元素的位置
int margc(SqList *L1,SqList *L2,SqList *L3);    //合并两个有序线性表


int main()
{
    int status;
    float f;
    int d;
    int cnt;
    /*  //这一段代码是初始化一个线性表
    SqList L1;
    InitList(&L1);
    */
    /*  //这段代码是在末尾添加数据的方法创建一个线性表
    Polynomial e;
    while(scanf("%f %d",&f,&d)&&(f!=-1&&d!=-1))
    {
        e.coef = f;
        e.expn = d;
        ListInput(&L1,e);

    }
    */

    /*   //这一段代码是在特定位置插入的方法实现一个线性表
    scanf("%d %f %d",&i,&f,&d);
    e.coef = f;
    e.expn = d;
    ListInsert(&L1,i,e);
    */

   /*   //这段代码是为了删除线性表第i个元素
    scanf("%d",&i);
    ListDelete(&L1,i);
    */

    /*  //这段代码是为了判断线性表是否为空
    status = ListEmpty(&L1);
    printf("%d",status);
    */

    /*  //这段代码是为了获得线性表的长度
    status = ListLength(&L1);
    printf("%d",status);
    */

    /*  //这段代码是为了返回线性表第i个元素，并将值保存在结构体e中
    scanf("%d",&i);
    GetElem(&L1, i,&e);
    printf("%f %d",e.coef,e.expn);
    */

    /* //这段代码是为了返回第一个与e相同的数据元素的位置
    scanf("%f %d",&f,&d);
    e.coef=f;
    e.expn = d;
    status = LocateElem(&L1,e);
    printf("%d",status);
    */

    /*  //这段代码是为了合并两个有序线性表，并将结果保存在L3这个线性表中
    SqList L1,L2,L3;
    InitList(&L1);
    InitList(&L2);
    InitList(&L3);
    Polynomial e;
    while(scanf("%f %d",&f,&d)&&(f!=-1&&d!=-1))
    {
        e.coef = f;
        e.expn = d;
        ListInput(&L1,e);

    }
    while(scanf("%f %d",&f,&d)&&(f!=-1&&d!=-1))
    {
        e.coef = f;
        e.expn = d;
        ListInput(&L2,e);
    }
    margc(&L1,&L2,&L3);
    */


    TraverseList(&L3);    //遍历整个线性表
    //printf("%d",status);
    //ClearList(SqList *L)
    //DestroyList(&L1);
    return 0;
}

int InitList(SqList *L)
{
    L->elem = (Polynomial *)malloc(MAXSIZE * sizeof(Polynomial));
    if(!L->elem)
        return OVERFLOW;
    L->length = 0;
    return OK;
}

int DestroyList(SqList *L)
{
    free(L->elem);
    L->length = 0;
    return 1;
}

int ClearList(SqList *L)
{
    L->length == 0;
    return 0;
}

int ListEmpty(SqList *L)
{
    if(L->length==0)
        return False;
    return OK;

}

int ListLength(SqList *L)
{
    return L->length;
}

int GetElem(SqList *L, int i,Polynomial *e)
{
    if(i<1||i>L->length)
        return error;
    e = &(L->elem[i-1]);
    return OK;
}

int LocateElem(SqList *L,Polynomial e)
{
    for(i=0;i<L->length;i++)
        if(L->elem[i].coef == e.coef&&L->elem[i].expn == e.expn)
            return i+1;
    return error;
}

int ListInput(SqList *L,Polynomial e)
{
    i=L->length;
    L->elem[i]=e;
    L->length++;
    return OK;
}

int ListInsert(SqList *L, int i, Polynomial e)
{
    if(i<1||i>L->length+1)
        return error;
    if(L->length == MAXSIZE)
        return error;
    for(j=L->length-1;j>=i-1;j--)
        L->elem[j+1] = L->elem[j];
    L->elem[i-1] = e;
    ++L->length;
    return OK;
}

int ListDelete(SqList *L,int i)
{
    if(i<1||i>L->length)
        return error;
    for(j=i;j<=L->length-1;j++)
        L->elem[j-1]=L->elem[j];
    --L->length;
    return OK;
}

int TraverseList(SqList *L)
{
    for(i=0;i<L->length;i++)
        printf("%d,%f,%d \n",i,L->elem[i].coef,L->elem[i].expn);
    return OK;
}

int margc(SqList *L1,SqList *L2,SqList *L3)
{
    Polynomial x;   //为了跟上边e区别，这里使用x
    i=0,j=0;
    while(i<L1->length&&j<L2->length)
    {
        if(L1->elem[i].expn<L2->elem[j].expn)
        {
            x.coef = L1->elem[i].coef;
            x.expn = L1->elem[i].expn;
            ListInput(L3,x);
            i++;
        }
        else if(L1->elem[i].expn==L2->elem[j].expn)
        {
            x.coef = L1->elem[i].coef+L2->elem[j].coef;
            x.expn = L1->elem[i].expn;
            ListInput(L3,x);
            i++;
            j++;
        }
        else
        {
            x.coef = L2->elem[j].coef;
            x.expn = L2->elem[j].expn;
            ListInput(L3,x);
            j++;
        }
    }
    while(j<L2->length)
    {
        x.coef = L2->elem[j].coef;
        x.expn = L2->elem[j].expn;
        ListInput(L3,x);
        j++;
    }
    while(i<L1->length)
    {
        x.coef = L1->elem[i].coef;
        x.expn = L1->elem[i].expn;
        ListInput(L3,x);
        i++;
    }
    return OK;
}
].coef;
            x.expn = L2->elem[j].expn;
            ListInput(L3,x);
            j++;
        }
    }
    while(j<L2->length)
    {
        x.coef = L2->elem[j].coef;
        x.expn = L2->elem[j].expn;
        ListInput(L3,x);
        j++;
    }
    while(i<L1->length)
    {
        x.coef = L1->elem[i].coef;
        x.expn = L1->elem[i].expn;
        ListInput(L3,x);
        i++;
    }
    return OK;
}
烂烂三三
关注
  • 6
    点赞
  • 踩
  • 36
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于顺序表实现的一元稀疏多项式的基本操作
12-20
这个是自己编写的用顺序表实现一元稀疏多项式的基本操作
顺序表实现稀疏矩阵
OnlyLove_KD的博客
09-21 665
继一元稀疏式之后，再写了顺序表的第二个应用：稀疏矩阵
c++单链表 一元多项式求和_顺序表实现稀疏多项式完整代码
weixin_33296185的博客
01-01 713
顺序表实现稀疏多项式由于书上给的代码都是只有核心的代码，没法直接实现，所以我就尝试将书上提到的函数都用c语言实现了一下。仅供参考，用来对照一下书中的代码，加深理解。如果有错误的话，希望大家指出来。注意点书中说是给的C语言的伪代码，但是给的代码还是用到了一些c++的东西，比如说status InitList(SqList &L),这个地方就是用到了c++的引用。具体c语言的指针和c...
【数据结构】稀疏多项式的运算--顺序表实现
jianbiao1483的博客
03-09 2441
算法： 1、建立空表Lc 2、遍历La、Lb表（未到末尾）： （1）如果系数相同，系数相加 （2）如果系数不同：若La的系数小，把La加入Lc中；若Lb系数小，把Lb加入Lc中 3、有一个表已经遍历结束，把还有元素的表加入到Lc中 #include<iostream> using namespace std; #define MAXSIZE 100 #define OK 1 #define OVERFLOW -2 typedef struct{ float coef; in.
c语言链表实现稀疏多项式之间的加减（顺序结构链表）
weixin_44818115的博客
12-04 1392
#include <stdio.h> #include <stdlib.h> // 顺序多项式的合并 typedef struct node{ int coef;//系数 int pow;//指数 struct node *next; }POLYNOMIAL; POLYNOMIAL *polyRcreate() { // 尾插入法创建链表 int coef,pow,num = 1; POLYNOMIAL *head,*last,*p; head = (POLYN
一元稀疏多项式运算代码
12-20
设计程序，输入两个一元稀疏多项式， 分别完成二者的加法、减法、乘法运算，输出和多项式、差多项式、乘积... 1、分别以顺序表和单链表为存储结构实现多项式的加法和减法运算。 2、乘法运算的实现使用单链表为存储结构
基于Java实现的一元稀疏多项式计算器.zip
07-04
通过输入限制确保符合一元稀疏多项式的格式； 通过按钮组选择输出结果：多项式计算结果、在某点的值、多项式的导数(扩展功能)； 多项式的计算功能；多项式的求值功能；多项式的求导功能。 详细介绍参考：...
数据结构_实验_课程设计_一元稀疏多项式Polynomial_代码&报告
12-10
数据结构_实验_课程设计_一元稀疏多项式Polynomial_代码&报告
一元稀疏多项式加法运算实验报告
12-07
本实验报告主要介绍了一元稀疏多项式加法运算的实验实现，包括需求分析、输入输出、测试数据、概要设计、详细设计等方面的内容。 一、需求分析 1.1 程序的主要功能： * 输入两个稀疏的一元 n 次多项式 * 计算两个...
线性表-稀疏多项式运算
咩咩的博客
06-22 532
一元稀疏多项式 数据结构 C++
04-04
数据结构链表的使用实例，C++编写，实现一元多项式的加减法。
一元稀疏多项式C++实现
11-29
自己做的！心血！！！ #include using namespace std; #define TURE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 typedef int status; typedef struct term { float coef; int expn; term *next; }term,*Link; typedef struct { Link head; int len; }polyn; status MakeTerm(Link &p, float c, int e, Link q)//建立项 { p=(Link)malloc(sizeof(term)); if(!p) exit(OVERFLOW); p->coef=c; p->expn=e; p->next=q; return OK; }
一元稀疏多项式的计算
03-05
【问题描述】实现两个多项式的运算（相加、相减）。 【基本要求】 （1）按照指数降序排列建立并输出多项式； （2）完成两个多项式的相加、相减，并将结果输出； （3）以顺序存储或链式存储结构实现多项式。
一元多项式的稀疏计算c语言代码
11-17
用链式存储结构实现稀疏一元多项式运算器 功能基本要求：创建、显示、求和（求差）、求值；销毁、清空、修改（添加项、删除项、改系数指数）
利用单链表创建多项式，并实现多项式的加减乘法运算，以及对多项式根据指数进行递增排序
05-25
利用单链表创建多项式，创建的多项式的每一项的第一个元素表示对应项的系数，第二个元素表示对应项的指数，实现多项式的加减乘法运算，以及对多项式根据指数进行递增排序
c++稀疏多项式，应该是c和c++语法合在一起写了
m0_55083785的博客
03-19 710
//凑合着看吧 #include<iostream> #include<string> using namespace std; typedef struct PNode { float coef; int expn; struct PNode* next; }PNode, * Polynomial; //多项式的创建 void CreatePolyn(Polynomial& P, int n) { P = new PNode; P->next = NU
线性表的案例实现--多项式、稀疏多项式
yyldeh的博客
04-02 667
目录 一、案例内容​ 二、代码实现 三、结果输出 一、案例内容 二、代码实现 public class Main { } 三、结果输出
案例：稀疏多项式的运算
m0_53679998的博客
03-30 384
本文学自王卓老师的视频。
多项式混沌展开法
weixin_44606558的博客
08-20 4745
关于多项式混沌展开法求解结构可靠度的基本原理和流程
c语言用单链表实现了稀疏多项式求和的程序编码
最新发布
06-07
好的，以下是用单链表实现稀疏多项式求和的C语言代码示例： ```c #include #include // 定义链表节点 typedef struct Node { int coef; // 系数 int exp; // 指数 struct Node* next; // 指向下一个节点的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值