【数据结构】第二讲 线性结构（下）&&一元多项式的加法与乘法运算的链表实现

最新推荐文章于 2022-04-24 19:53:23 发布
最新推荐文章于 2022-04-24 19:53:23 发布
阅读量494 收藏 12
点赞数
分类专栏： 数据结构 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dive668/article/details/116395858
版权

第二讲 线性结构（下）

2.3 队列及实现

队列是具有一定操作约束的线性表
插入和删除操作，只能在一端插入，另一端输出


Queue CreatQueue(int MaxSize)//生成长度为MaxSize的空队列
int IsFullQ(Queue Q,int MaxSize)//判断队列Q是否已满
void AddQ(Queue Q,int item)//将元素item入队
int IsEmptyQ(Queue Q)//判断队列Q是否为空
int DeleteQ(Queue Q)//将队头元素从队列中删除并返回

队列的顺序存储实现

一个一维数组，一个记录队列头元素位置的变量front以及一个记录队列尾元素位置的变量rear组成。
在这里插入图片描述
刚开始空：rear和front都是-1
插入一个元素：rear+1
删除一个元素：front+1

循环队列

放满了，还可以往回放！
在这里插入图片描述
用front和rear的差值记录满不满。但实际上flag和rear的差值有n种情况。
队列装载情况有n+1种：没有元素，一个元素，两个元素，…，n个元素。
解决方法：
（1）使用额外标记，Size或Tag(插入一个元素Tag设为1，删除一个元素Tag设为0)域。
（2）仅使用n-1个数组空间

一：入队

void AddQ(Queue PtrQ,int item)
{
	if((PtrQ->rear+1)%MaxSize==PtrQ->front)
	{
		cout<<"队列满";
		return;
	}
	PtrQ->rear = (PtrQ->rear + 1) % MaxSize;
	PtrQ->Data[PtrQ->rear] = item;
}

二：出队
返回出队元素，front指向的是队列头元素钱一个位置。所以+1的位置就是头元素位置。

int DeleteQ(Queue PtrQ)
{
	if(PtrQ->front==PtrQ->rear)
	{
		cout << "队列空";
		return NULL;
	}
	else 
	{
		PtrQ->front = (PtrQ->front + 1) % MaxSize;
		return PtrQ->Data[PtrQ->front];
	}
}

队列的链式存储实现

队列front是要做删除操作，只能在链表头
front在链表头，rear在链表尾

struct Node//结点结构
{
	int Data;
	struct Node *Next;
};
struct QNode//代表队列
{
	struct Node *rear;//指向队尾结点
	struct Node *front;//指向队头结点
};

typedef struct QNode *Queue;
Queue PtrQ;

二：出队
不带头结点的链式队列出队操作

int DeleteQ(Queue PtrQ)
{
	struct Node *FrontCell;
	int FrontElem;

	if(PtrQ->front==NULL)
	{
		cout << "队列空";
		return NULL;
	}
	FrontCell = PtrQ->front;
	if(PtrQ->front==PtrQ->rear)//只有一个元素时，要同时修改front和rear的值，否则rear的值不变
		PtrQ->front = PtrQ->rear = NULL;
	else
		PtrQ->front = PtrQ->front->Next;
	FrontElem = FrontCell->Data;
	free(FrontCell);
	return FrontElem;
}

三：两个堆栈实现一个队列

  • 1、可以用两个堆栈实现一个队列。队列的容量为较小堆栈n的2n+1。
  • 2、已知条件：m>n，栈m和栈n初始为空。
  • 3、实现步骤——天龙八部：
  • 第一步：检查m>n，栈m和栈n初始化为空；
  • 第二步：n个数据入栈m；
  • 第三步：n个数据从栈m出栈并入栈n；
  • 第四步：n+1个数据入栈m，至此已经有2n+1数据入栈；
  • 第五步：栈n的数据全部出栈输出，即为队列输出；
  • 第六步：栈m的数据出栈n个并入栈n，此时栈m中剩1个元素；
  • 第七步：栈m中的1个元素出栈输出，即为队列输出；
  • 第八步：栈n数据全部出栈输出，即为队列输出。
  • 按以上步骤即可完成两个堆栈模拟一个队列。队列的容量即2n+1。

如果把两个堆栈规划为同样大小，则队列的容量为两个堆栈容量之和。处理步骤也可以简化去掉第七步。

2.4应用实例：多项式加法运算

主要思路：相同指数的项系数相加，其余部分进行拷贝。

在这里插入图片描述

多项式加法运算

采用不带头结点的单项链表，按照指数递减的顺序排列各项。

struct PolyNode
{
	int coef;//系数
	int expon;//指数
	struct PolyNode *link;//指向下一个结点的指针
};
typedef struct PolyNode *Polynomial;
Polynomial P1, P2;

算法思路：
两个指针P1和P2分别指向这两个多项式第一个结点，不断循环。

P1->expon==P2->expon;//系数相加，结果不为0，则结果作为多项式对应项的系数。同时P1,P2指向下一项
P1->expon>P2->expon;//将P1的当前项存入结果多项式，使P1指向下一项
P2->expon<P2->expon;//将P2的当前项存入结果多项式，并使P2指向下一项

当某一多项式处理完之后，将零一个多项式的所有结点一次复制存到结果多项式中去。

Compare()函数对比两个数，第一个数大，返回1，第二个数大，返回-1，两个值相等，返回0；

Compare()函数
int Compare(Polynomial P1,Polynomial P2)
{
	if(P1->expon>P2->coef)
		return 1;
	else if(P1->expon<P2->expon)
		return -1;
	else
		return 0;
}
Attach()函数
void Attach(int c,int e,Polynomial *pRear)
{
	Polynomial P;
	P = (Polynomial)malloc(sizeof(struct PolyNode));
	P->coef = c;
	P->expon=e;
	P->link = NULL;
	(*pRear)->link = P;
	*pRear = P;//修改pRear的值
}
求和函数
Polynomial PolyAdd(Polynomial P1,Polynomial P2)
{
	Polynomial front, rear, temp;
	int sum;
	rear = (Polynomial)malloc(sizeof(struct PolyNode));
	front = rear;//构造一个临时的空结点front作为表头
	while(P1&&P2)//当两个多项式都有非零项待处理时
	{
		switch(Compare(P1->expon,P2->expon))
		{
			case 1:
				Attach(P1->coef, P1->expon, &rear);
				P1 = P1->link;
				break;
			case -1:
				Attach(P2->coef, P2->expon, &rear);
				P2 = P2->link;
				break;
			case 0:
				sum = P1->coef + P2->coef;
				if(sum)
					Attach(sum, P1->expon, &rear);
				P1 = P1->link;
				P2 = P2->link;
				break;
		}
	}
	//将未处理完的另一个多项式的所有结点依次复制到结果多项式中去
	for (; P1;P1=P1->link)
		Attach(P1->coef, P1->expon, &rear);
	for (; P2;P2=P2->coef)
		Attach(P2->coef, P2->expon, &rear);
	rear->link = NULL;
	temp = front;
	front = front->link;//令front指向结果多项式
	free(temp);//释放临时表头结点
	return front;
}

⭐2.5 小白专场：一元多项式的加法与乘法运算

题意理解：
设计函数分别计算两个一元多项式的乘积与和
已知两个多项式：
在这里插入图片描述

求解思路

  • 1.多项式表示
  • 2.程序框架
  • 3.读多项式
  • 4.加法实现
  • 5.乘法实现
  • 6.多项式输出
多项式表示

关键：表示关键信息
数组：编程简单，调试容易。事先需要确定数组大小。
链表：动态性小。编程复杂。

此题告诉了数目个数。

链表设计方法：

typedef struct PolyNode *Polynomial;
struct PolyNode
{
    int coef;//系数
    int expon;//指数
    Polynomial link;//指针
};
程序框架搭建

main()函数

int main()
{
    //读入多项式1
    //读入多项式2
    //乘法运算并输出
    //加法运算并输出
    return 0;
}

需要设计的函数：

  • 读一个多项式
  • 两个多项式相乘
  • 两个多项式相加
  • 多项式输出
int main()
{
    //读入多项式1
    P1 = ReadPoly();
    //读入多项式2
    P2 = ReadPoly();
    //乘法运算并输出
    PP = Mult(P1, P2);
    PrintPoly(PP);
    //加法运算并输出
    PS = Add(P1, P2);
    PrintPoly(PS);
    return 0;
}
怎么读多项式

先读入一个数目，然后n–，循环，读入系数指数，添加到链表里。
Rear 初值为多少？
两种处理方式

  • 1.Rear初值为NULL，需要额外一步if判断处理
  • 2.先申请空结点。Rear指向一个空结点。最后空结点删掉。
    在这里插入图片描述
void Attach(int c,int e,Polynomial *pRear)
{
    Polynomial P;
    P = (Polynomial)malloc(sizeof(struct PolyNode));
    P->coef = c;//对新结点赋值
    P->expon = e;
    P->link = NULL;
    (*pRear)->link = P;
    *pRear = P;//修改pRear的值
}

读入多项式

Polynomial ReadPoly()
{
    Polynomial P, Rear,t;
    int c, e, N;
    cin >> N;
    //链表头空结点
    P = (Polynomial)malloc(sizeof(struct PolyNode));
    P->link = NULL;
    Rear = P;
    while(N--)
    {
        int c;
        int e;
        cin >> c;
        cin >> e;
        //将当前项插入多项式尾部
        Attach(c, e, &Rear);//Rear在函数里面值改变，参数值传递 
    }
    //删除临时生成的头节点
    t = P;
    P = P->link;
    free(t);
    return P;
}
如何将两个多项式相加
Polynomial Add(Polynomial P1,Polynomial P2)
{
    Polynomial t1,t2;
    t1 = P1;
    t2 = P2;
    Polynomial P,Rear;
    P = (Polynomial)malloc(sizeof(struct PolyNode));
    P->link = NULL;
    Rear = P;
    while(t1&&t2)
    {
        if(t1->expon==t2->expon)
        {
            if(t1->coef+t2->coef)
                Attach(t1->coef+t2->coef,t1->expon,&Rear);
            t1=t1->link;
            t2=t2->link;
        }
        else if(t1->expon>t2->expon)
        {
            Attach(t1->coef,t1->expon,&Rear);
            t1=t1->link;
        }
        else
        {
            Attach(t2->coef,t2->expon,&Rear);
            t2=t2->link;
        }
    }
    while(t1)
    {
        Attach(t1->coef,t1->expon,&Rear);
        t1=t1->link;
    }
    while(t2)
    {
        Attach(t2->coef,t2->expon,&Rear);
        t2=t2->link;
    }
    //剔除空的头节点
    Polynomial t;
    t=P;
    P=P->link;
    free(t);
    return P; 
}
如何将两个多项式相乘
步骤1：将乘法运算转换为加法运算

将乘法运算转换为加法运算

将P1当前项(ci,ei)乘P2多项式，再加到结果多项式里。

t1 = P1;t2=P2;
P = (Polynomial)malloc(sizeof(struct PolyNode));
P->link = NULL;
Rear = P;
while(t2)
{
    Attach(t1->coef * t2->coef, t1->expon * t2->expon, &Rear);
    t2 = t2->link;
}
步骤2： 逐项插入

将P1当前项( c l i cl_i cli​, e l i el_i eli​)乘P2当前项 ( c 2 i c2_i c2i​， e 2 i e2_i e2i​)，并插入到结果多项式中。关键是要找到插入位置。
初始结果多项式可由P1第一项乘P2获得（如上）。

Polynomial Mult(Polynomial P1,Polynomial P2)
{
    //... 
    Polynomial P,Rear,t1,t2,t;
    int c, e;
    if(!P1||!P2)
        return NULL;
    t1 = P1;
    t2 = P2;
    //...
    P = (Polynomial)malloc(sizeof(struct PolyNode));
    P->link = NULL;
    Rear = P;
    while(t2)//先用P1的第一项乘以P2,得到P*
    {
        //....怎么构造初始多项式
        Attach(t1->coef * t2->coef, t1->expon + t2->expon, &Rear);
        t2 = t2->link;
    }
    t1 = t1->link;
    while(t1)//t1的每一项乘以t2每一项
    {
        t2 = P2;
        Rear = P;
        while(t2)
        {
            e = t1->expon + t2->expon;
            c = t1->coef * t2->coef;
            //...知道了c和e,怎么找到该插入的位置去插入
            while(Rear->link&&Rear->link->expon>e)
                Rear = Rear->link;
            if(Rear->link&&Rear->link->expon==e)
            {
                if(Rear->link->coef+c)//系数不等于0
                    Rear->link->coef += c;
                else//系数等于0还要擦除
                {
                    t = Rear->link;
                    Rear->link = t->link;
                    free(t);
                }
            }
            else//系数小于了，准备插入了
            { 
                t = (Polynomial)malloc(sizeof(struct PolyNode));
                t->coef = c;
                t->expon=e;
                t->link = Rear->link;
                Rear->link=t;
                Rear = Rear->link;
            } 
            t2 = t2->link;
        }
        t1 = t1->link;
    }
    //....最后结果如何处理
    t2 = P;//删除掉空头节点
    P = P->link;
    return P;
}
如何将多项式输出
void PrintPoly(Polynomial P)
{
    int flag = 0;//调整输出格式，第一项之前没有空格，后面的每一项之前都有空格
    if(!P)
    {
        cout <<"0 0"<<endl;
        return;
    }
    while(P)
    {
        if(!flag)
            flag = 1;
        else
            cout << " ";
        cout << P->coef << " " << P->expon;
        P = P->link;
    }
	cout<<endl;
}
⭐题目及完整代码

7-2 一元多项式的乘法与加法运算 (20 分)

输入格式:
输入分2行，每行分别先给出多项式非零项的个数，再以指数递降方式输入一个多项式非零项系数和指数（绝对值均为不超过1000的整数）。数字间以空格分隔。

输出格式:
输出分2行，分别以指数递降方式输出乘积多项式以及和多项式非零项的系数和指数。数字间以空格分隔，但结尾不能有多余空格。零多项式应输出0 0。

#include <iostream>
using namespace std;

typedef struct PolyNode *Polynomial;
struct PolyNode
{
    int coef;//系数
    int expon;//指数
    Polynomial link;//指针
};
void Attach(int c,int e,Polynomial *pRear)
{
    Polynomial P;
    P = (Polynomial)malloc(sizeof(struct PolyNode));
    P->coef = c;//对新结点赋值
    P->expon = e;
    P->link = NULL;
    (*pRear)->link = P;
    *pRear = P;//修改pRear的值
}

Polynomial ReadPoly()
{
    Polynomial P, Rear,t;
    int N;
    cin >> N;
    //链表头空结点
    P = (Polynomial)malloc(sizeof(struct PolyNode));
    P->link = NULL;
    Rear = P;
    while(N--)
    {
        int c;
        int e;
        cin >> c;
        cin >> e;
        //将当前项插入多项式尾部
        Attach(c, e, &Rear);//Rear在函数里面值改变，参数值传递 
    }
    //删除临时生成的头节点
    t = P;
    P = P->link;
    free(t);
    return P;
}
Polynomial Add(Polynomial P1,Polynomial P2)
{
    Polynomial t1,t2;
    t1 = P1;
    t2 = P2;
    Polynomial P,Rear;
    P = (Polynomial)malloc(sizeof(struct PolyNode));
    P->link = NULL;
    Rear = P;
    while(t1&&t2)
    {
        if(t1->expon==t2->expon)
        {
            if(t1->coef+t2->coef)
                Attach(t1->coef+t2->coef,t1->expon,&Rear);
            t1=t1->link;
            t2=t2->link;
        }
        else if(t1->expon>t2->expon)
        {
            Attach(t1->coef,t1->expon,&Rear);
            t1=t1->link;
        }
        else
        {
            Attach(t2->coef,t2->expon,&Rear);
            t2=t2->link;
        }
    }
    while(t1)
    {
        Attach(t1->coef,t1->expon,&Rear);
        t1=t1->link;
    }
    while(t2)
    {
        Attach(t2->coef,t2->expon,&Rear);
        t2=t2->link;
    }
    Polynomial t;
    t=P;
    P=P->link;
    free(t);
    return P; 
}

Polynomial Mult(Polynomial P1,Polynomial P2)
{
    //... 
    Polynomial P,Rear,t1,t2,t;
    int c, e;
    if(!P1||!P2)
        return NULL;
    t1 = P1;
    t2 = P2;
    //...
    P = (Polynomial)malloc(sizeof(struct PolyNode));
    P->link = NULL;
    Rear = P;
    while(t2)//先用P1的第一项乘以P2,得到P*
    {
        //....怎么构造初始多项式
        Attach(t1->coef * t2->coef, t1->expon + t2->expon, &Rear);
        t2 = t2->link;
    }
    t1 = t1->link;
    while(t1)//t1的每一项乘以t2每一项
    {
        t2 = P2;
        Rear = P;
        while(t2)
        {
            e = t1->expon + t2->expon;
            c = t1->coef * t2->coef;
            //...知道了c和e,怎么找到该插入的位置去插入
            while(Rear->link&&Rear->link->expon>e)
                Rear = Rear->link;
            if(Rear->link&&Rear->link->expon==e)
            {
                if(Rear->link->coef+c)//系数不等于0
                    Rear->link->coef += c;
                else//系数等于0还要擦除
                {
                    t = Rear->link;
                    Rear->link = t->link;
                    free(t);
                }
            }
            else//系数小于了，准备插入了
            { 
                t = (Polynomial)malloc(sizeof(struct PolyNode));
                t->coef = c;
                t->expon=e;
                t->link = Rear->link;
                Rear->link=t;
                Rear = Rear->link;
            } 
            t2 = t2->link;
        }
        t1 = t1->link;
    }
    //....最后结果如何处理
    t2 = P;//删除掉空头节点
    P = P->link;
    return P;
}


void PrintPoly(Polynomial P)
{
    int flag = 0;//调整输出格式，第一项之前没有空格，后面的每一项之前都有空格
    if(!P)
    {
        cout <<"0 0"<<endl;
        return;
    }
    while(P)
    {
        if(!flag)
            flag = 1;
        else
            cout << " ";
        cout << P->coef << " " << P->expon;
        P = P->link;
    }
    cout << endl;
}

int main()
{
    Polynomial P1,P2,PP,PS;
    //读入多项式1
    P1 = ReadPoly();
    //读入多项式2
    P2 = ReadPoly();
    //乘法运算并输出
    PP = Mult(P1, P2);
    PrintPoly(PP);
    //加法运算并输出
    PS = Add(P1, P2);
    PrintPoly(PS);
    return 0;
}
TIGER1693
关注
  • 0
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法基础-线性表习题-两个多项式相加运算（顺序表）
”好的程序员不应该花大量时间在程序调试上，bug从一开始就不该被引入“
03-01 1999
题目 编写代码，实现两个一元多项式之间的相加，相减，相乘运算 TIP：没有除法，但是在我的代码基础上很好改，加一个判断分母为0报错即可 思路 将多项式看成线性表，每一项的指数隐藏在下标中 如果多项式连续，使用数组（顺序表）是最方便的 运算时，对应位置按顺序逐个相加/相减/相乘，直到存在空表时，将非空表内剩余元素填入即可 个人代码 王老师没有演示代码，于是我自己敲了，当作练习题 #include <iostream> using namespace std; #de
用链表表示多项式，并实现多项式的加法运算
m0_64005272的博客
12-05 1392
输入在第一行给出第一个多项式POLYA的系数和指数，并以0,0 结束第一个多项式的输入；在第二行出第一个多项式POLYB的系数和指数，并以0,0 结束第一个多项式的输入。对每一组输入，在一行中输出POLYA+POLYB和多项式的系数和指数。 输出样例: 本题主要思路；1.建立两个头指针分别为head1和head2链表，链表每一个节点分别记录每一个多项式的系数coef和指数exp.2.preA遍历链表head1,preB遍历链表head2.3.建立一个只有一个头节点的链表head,逐步遍历链表he
如何利用线性表？完成一元多项式运算【内容丰富，简单易懂】
qq_54169998的博客
01-11 3187
如何利用线性表完成一元多项式运算。多项式每项coef是该项系数，exp是变元x的指数单循环链表、结构体模板、类模板、友元函数以及运算符重载、程序设计思路、项结点实现 多项式类、多项式的输入和输出、多项式相加、多项式相乘 、重载运算符 将一个多项式看成一个线性表，线性表的元素就是多项式的项。对多项式算术运算而言，连接存储方式更合适。一般来来说，多项式的项数和指数变化较大，难以确定，若采用顺序存储方式，需要先分配足够空间，容易造成空间浪费；而采取链接存储方式，动态创建新结点以存储多项式的项，就十分灵活。
线性表：两个一元多项式相加的算法
qq_43661234的博客
09-23 3301
网上搜了一下大家的算法，发现以我的脑袋瓜子好像看不太懂。。。于是自己尝试着搞了一下，发现其实并不难嘻嘻嘻 #include<stdio.h> #include <stdlib.h> typedef int ElemType; typedef struct LNode { float coef; //系数 int expn; //指数 stru...
用链式存储的方式实现多项式的加法。
10-08
不多说，程序运行的测试结果，以及运行的环境都有说明，同时也对关键部分写有注释，多项式加法，不过如此。
数据结构——一元多项式加法.zip
09-18
一元多项式加法是数学中的基本运算，而在编程和算法设计中，这种运算可以通过利用数据结构，尤其是线性表来实现。这篇内容将深入探讨如何使用线性表来实现一元多项式加法。 首先，理解一元多项式。一元多项式是由...
pta题库答案c语言之线性结构2一元多项式的乘法与加法运算.zip
最新发布
05-01
在本压缩包中，我们关注的是C语言...总之，这个压缩包提供的内容涉及C语言编程、线性数据结构（链表）、一元多项式运算（加法和乘法）以及算法设计。掌握这些知识对于学习计算机科学，尤其是编程和算法设计至关重要。
一元多项式加法运算
08-26
在此篇文章中，我们将探讨一元多项式加法运算的实现，使用线性链表存储一元多项式，并实现多项式的加法运算。 一元多项式加法运算的实现步骤： 1. 首先，我们需要定义一元多项式的数据结构，使用线性链表存储每个...
双向链表及其应用——实现多项式的加法及乘法
10-23
本文将深入探讨双向链表的实现以及它在一项特殊应用中的体现：一元多项式的加法与乘法运算。 首先，我们要理解双向链表的概念。双向链表是一种线性数据结构，每个节点包含两个指针，分别指向其前一个节点和后一个...
多项式的存储加法c语言,C语言多项式加法
weixin_42530570的博客
05-17 214
《C语言多项式加法》由会员分享，可在线阅读，更多相关《C语言多项式加法(6页珍藏版)》请在人人文库网上搜索。1、C 语言题目 - 多项式加法 多项式加法( 10 分) 题目内容： 一个多项式可以表达为 x 的各次幂与系数乘积的和，比如： 2x6+3x5+12x3+6x+20 现在，你的程序要读入两个多项式，然后输出这两个多项式的和，也就是把对应的幂上的系数相加然后输 出。 程序要处理的幂最大为 1...
C语言用链表写大数乘法,关于C语言链表的问题
weixin_42298878的博客
05-17 223
这个程序主要作用是高精度算法中的加法与乘法，但是由于大小限制，我只能吧乘法的删掉，给大家粗劣地看一下，我主要想问，这里使用了链表了么，因为他每个函数都是结构体指针，这样做有什么用呢，作用是什么，有什么好处?typedef struct number NUMBER;这个程序主要作用是高精度算法中的加法与乘法，但是由于大小限制，我只能吧乘法的删掉，给大家粗劣地看一下，我主要想问，这里使用了链表了么，...
链表实现多项式的加法和乘法
InsZVA的专栏
04-08 999
基本思路是做一个链表，然后给个add函数，add函数用于相加，同时也可以用来插入新元素，相乘即系数相乘，次数相加add到新的链表即可： LinkList.h: #include #define TYPE1 int #define TYPE2 int struct _lnode { TYPE1 data1; TYPE2 data2; struct _lnode * next;
给出两个链表形式表示的数字,写一个函数得到这两个链表相乘乘积
weixin_44296113的博客
11-10 268
package com.lxg.algorithm; import java.util.Arrays; public class Solution06 { /** * @param l1: the first list * @param l2: the second list * @return: the product list of l1 and l2 */ public static long multiplyLists(ListNode l
链表实现大数相加和大数相乘
flowhat的专栏
12-20 4559
全部c代码如下#include #include #define ElemType int#define HUNTHOU 10000typedef struct LNode  //链表节点{ ElemType data; struct LNode *next;}ListNode, *LinkedList;int InitList(LinkedList &list) //构造一个空的线形表list{
链表表示一元多项式，实现一元多项式的相加相乘。c++
weixin_43744883的博客
10-01 1574
代码： // // main.cpp // polynomiallink // // Created by Hmq Hmq on 2019/9/18. // Copyright © 2019年 Hmq Hmq. All rights reserved. // #include <iostream> using namespace std; typedef struct { ...
C语言链表实现简单多项式加法
DFGOMC的博客
10-10 1538
基于C语言实现简单的一元多项式加法 本文参考自《大话数据结构》，有错漏的地方欢迎指点。 ​ 正在复习数据结构，因为还没有复习到树结构，所以这里只是用链表对一元多项式加法做简单的实现，待后面复习到树结构，会对多项式加法进行重构。 1.算法思路 一元多项式的结构固定为Ax^n，因为x是固定的，所以结构体里只需要存储系数A和指数n就行； 一元多项式Ax^n的结构分为4种： A=0，n!=0时，多项式为x^n，此时系数coef=0，指数exp=n； A!=0，n=0时，多项式为A，此时系数coef=A，指数e
链表实现一元多项式加法和乘法
_计算机好苦
04-05 394
输入：4 3 4 -5 2 6 1 -2 0（4为系数和指数的总对数） 3 5 20 -7 4 3 1（3为系数和指数的总对数） 输出： 15 24 -25 22 30 21 -10 20 -21 8 35 6 -33 5 14 4 -15 3 18 2 -6 1 5 20 -4 4 -5 2 9 1 -2 0 #include<iostream> using namesp...
C++利用单链表实现一元多项式的加、乘操作
henry594xiaoli的博客
04-24 4049
C++利用单链表实现一元多项式的加、乘操作，提示：一元多项式中的数据项含有两个数据分别是系数与指数，为了简单起见，系数与指数都为整数。
C++实现高次多项式加法与乘法运算
学生需要使用C++语言和数据结构的方法来实现这一运算，特别强调了数据输入的顺序以及利用单链表和动态链表等数据结构技术。设计目标是创建一个既节省存储空间又能在运行时间上优化的解决方案。报告还引用了几本关于...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值