一元稀疏多项式计算器


别把自己太当回事,要把你做的事当回事!💓💓💓

1、问题描述

问题描述】设计一个一元稀疏多项式得简单计算器。
基本要求】采用带头结点的单链表存储一元稀疏多项式,设计实现简单计算器以下基本功能。
(1)输入并且建立多项式。
(2)一元多项式的相加运算。
(3)一元多项式的相减运算。
(4)一元多项式的相乘运算。
(5)一元多项式的求导运算。

👇👇👇
💘💘💘知识连线时刻(直接点击即可)

  🎉🎉🎉复习回顾🎉🎉🎉
    链表复习回顾

测试数据
输入数据:第一个多项式A,共5项,分别是(6,0)(2,1)(8,7)(4,15)(3,18);第二个多项式B,共3项,分别是(7,1)(2,6)(-8,7)。
输出数据:
A多项式的结果:6 + 2X + 8X ^ 7 + 4X ^ 15 + 3X ^ 18
B多项式的结果:7X + 2X ^ 6 - 8X ^ 7
多项式A + B的结果:6 + 9X + 2X ^ 6 + 4X ^ 15 + 3X ^ 18
多项式A - B的结果:6 - 5X - 2X ^ 6 + 16X ^ 7 + 4X ^ 15 + 3X ^ 18
多项式A * B的结果:42X + 14X ^ 2 + 12X ^ 6 - 44X ^ 7 + 40X ^ 8 + 16X ^ 13 - 64X ^ 14 + 28X ^ 16 + 21X ^ 19 + 8X ^ 21 - 32X ^ 22 + 6X ^ 24 - 24X ^ 25
多项式A的导数结果:2 + 56X ^ 6 + 60X ^ 14 + 54X ^ 17

2、问题分析

这里小编提供一种思路哈:
1、首先我们要清楚这是需要建立带哨兵位头节点的单链表;每个节点里面存两个数据,一个是指数,一个是系数。
2、其次就是需要注意多项式输出的时候需要注意的各种情况,这里需要考虑完整,例如:系数小于0时,指数为1时等等。
3、接下来就到了,多项式计算环节,这里就需要用到数学上计算功底了,这里面需要注意。

3、源代码图解分析

具体细节操作还得看源码:(小编这里先拿图片对各个分文件里面重要环节做详解,之后再附上完整源代码

首先看头文件中的代码:(Many.h)

在这里插入图片描述

其次来看看源文件:(Many.cpp)

输出打印多项式函数

在这里插入图片描述

插多项式入函数:

在这里插入图片描述

A+B函数:

在这里插入图片描述

A-B函数:

在这里插入图片描述

A*B函数:

在这里插入图片描述

A的导数函数:

在这里插入图片描述

最后是主函数源代码(test.cpp)

在这里插入图片描述

4、完整源代码

上面的图解分析,小编是对该程序分文件操作,然后小编对其每个文件中重点函数进行分析展现,这里为了大家方便看源代码,小编也将其放在一个源文件中并且依然能正确运行:


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

typedef int SLDataType;

typedef struct List
{
	SLDataType data;//存系数
	SLDataType val;//存指数
	struct List* next;
}LS, LN;

LS* ListInit();//链表初始化(实际建立哨兵位头节点)

void ListPushBack(LS* Phead, SLDataType x, SLDataType y);//尾插构建链表

void PrintPloy(LS* Phead);//输出多项式

void AddPloy(LS* Pheada, LS* Pheadb, LS* AddPhead);//A+B

void SubPloy(LS* Pheada, LS* Pheadb, LS* SubPhead);//A-B

void MulPloy(LS* Pheada, LS* Pheadb, LS* MulPhead);//A*B

void DerPloy(LS* Pheada, LS* DerPhead);//A的导数

//创建结点
LS* BuyNode(SLDataType x, SLDataType y)
{
	LS* newnode = (LS*)malloc(sizeof(LS));
	if (newnode == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}
	newnode->data = x;//存系数
	newnode->val = y;//存指数
	newnode->next = NULL;
	return newnode;
}

//初始化建立哨兵位头节点
LS* ListInit()
{
	LS* Phead = BuyNode(0, 0);
	Phead->next = Phead;
	return Phead;
}
//尾插构建链表
void ListPushBack(LS* Phead, SLDataType x, SLDataType y)
{
	assert(Phead);
	LS* newnode = BuyNode(x, y);
	//单向循环,因此找尾部
	LS* tail = Phead->next;
	while (tail->next != Phead)
	{
		tail = tail->next;
	}
	tail->next = newnode;
	newnode->next = Phead;
}
//输出打印多项式
void PrintPloy(LS* Phead)
{
	int count = 1;
	LS* tail = Phead->next;
	assert(Phead);
	while (tail != Phead)
	{
		if (tail->data == 0)//系数为0
		{
			tail = tail->next;
			continue;
		}
		if (tail->val == 0 )//指数为0
		{
			printf("%d", tail->data);
		}
		if (tail->data > 0 && tail->val > 0)//系数大于0输出
		{
			if (count != 1)
				printf(" + ");
			if (tail->val == 1)//指数为1时输出
			{
				if (tail->data == 1.0)
					printf("X");//系数为1时输出
				else
					printf("%dX", tail->data);
			}
			else//指数大于1的时候输出
			{
				if (tail->data == 1.0)
					printf("X^%d", tail->val);
				else
					printf("%dX^%d", tail->data, tail->val);
			}
		}
		if (tail->data < 0 && tail->val > 0)//系数小于0输出
		{
			if (count != 1)
				printf(" - ");
			if (tail->val == 1)//指数为1时输出
			{
				if (tail->data == 1.0)
					printf("X");//系数为1时输出
				else
					printf("%dX", tail->data * (-1));
			}
			else//指数大于1的时候输出
			{
				if (tail->data == 1.0)
					printf("X^%d", tail->val);
				else
					printf("%dX^%d", tail->data * (-1), tail->val);
			}
		}
		count = 0;
		tail = tail->next;
	}
}



int cmp(SLDataType a, SLDataType b)
{
	if (a > b)
		return 1;
	else if (a == b)
		return 0;
	else
		return -1;
}
//将运算后的结果插入
void Insert(LS* AddPhead, SLDataType x, SLDataType y)//x是指数,y是系数
{
	LS* cur = AddPhead;
	assert(AddPhead);
	while (cur->next != AddPhead && cmp(cur->next->val, x) < 0)
	{
		cur = cur->next;
	}
	if (cur->next != AddPhead && cmp(cur->next->val, x) == 0)
	{
		cur->next->data += y;
	}
	else
	{
		LS* newnode = (LS*)malloc(sizeof(LS));
		if (newnode == NULL)
		{
			printf("malloc fail\n");
			exit(-1);
		}
		newnode->data = y;
		newnode->val = x;
		newnode->next = cur->next;
		cur->next = newnode;
	}
}
//实现A+B
void AddPloy(LS* Pheada, LS* Pheadb, LS* AddPhead)
{
	LS* str = Pheadb->next;
	LS* cur = Pheadb->next;
	assert(Pheada && Pheadb && AddPhead);
	for (cur = Pheada->next; cur != Pheada; cur = cur->next)
	{
		Insert(AddPhead, cur->val, cur->data);
	}
	for (str = Pheadb->next; str != Pheadb; str = str->next)
	{
		Insert(AddPhead, str->val, str->data);
	}
}

//A-B
void SubPloy(LS* Pheada, LS* Pheadb, LS* SubPhead)
{
	LS* str = Pheadb->next;
	LS* cur = Pheada->next;
	assert(Pheada && Pheadb && SubPhead);
	for (cur = Pheada->next; cur != Pheada; cur = cur->next)//将A插入
	{
		Insert(SubPhead, cur->val, cur->data);
	}
	for (str = Pheadb->next; str != Pheadb; str = str->next)//将B插入
	{
		str->data = -(str->data);//将B的系数变为负值
		Insert(SubPhead, str->val, str->data);
		str->data = -(str->data);//将B的系数变为原值
	}
}
//A*B
void MulPloy(LS* Pheada, LS* Pheadb, LS* MulPhead)
{
	int a = 0, b = 0;
	LS* cur = Pheada->next;
	LS* str = Pheadb->next;
	LS* prev = Pheada;
	assert(Pheada && Pheadb && MulPhead);
	for (cur = Pheada->next; cur != Pheada; cur = cur->next)
	{
		for (str = Pheadb->next; str != Pheadb; str = str->next)
		{
			a = (cur->data) * (str->data);//系数相乘
			b = (cur->val) + (str->val);//指数相加
			Insert(MulPhead, b, a);//将运算后的结果插入
		}
	}
}
//A的导数
void DerPloy(LS* Pheada, LS* DerPhead)
{
	LS* cur = Pheada->next;
	assert(Pheada);
	for (cur = Pheada->next; cur != Pheada; cur = cur->next)
	{
		if (cur->val == 0)//判断指数是否为0
		{
			cur->data = 0;
		}
		else
		{
			cur->data *= cur->val;//系数与指数相乘
			cur->val = cur->val - 1;
		}
		Insert(DerPhead, cur->val, cur->data);//将结果插入
	}
}

int main()
{
	LS* Pa = ListInit();//存放A多项式
	LS* Pb = ListInit();//存放B多项式
	LS* Add = ListInit();//存放A+B多项式
	LS* Sub = ListInit();//存放A-B多项式
	LS* Mul = ListInit();//存放A*B多项式
	LS* Der = ListInit();//存放A的导数
	size_t n = 0, m = 0;
	int a = 0, b = 0, c = 0, d = 0;
	printf("A多项式的项数:");
	scanf("%d", &n);//A的项数
	for (size_t i = 1; i <= n; i++)
	{
		printf("A多项式的第%d项系数和指数:", i);
		scanf("%d %d", &a, &b);
		ListPushBack(Pa, a, b);
	}
	printf("A多项式的输出:");
	PrintPloy(Pa);
	printf("\n");
	printf("B多项式的项数:");
	scanf("%d", &m);
	for (size_t i = 1; i <= m; i++)
	{
		printf("B多项式的第%d项系数和指数:", i);
		scanf("%d %d", &c, &d);
		ListPushBack(Pb, c, d);
	}
	printf("B多项式的输出:");
	PrintPloy(Pb);
	printf("\n");
	AddPloy(Pa, Pb, Add);
	printf("多项式A+B的输出:");
	PrintPloy(Add);
	printf("\n");
	printf("多项式A-B的输出:");
	SubPloy(Pa, Pb, Sub);
	PrintPloy(Sub);
	printf("\n");
	printf("多项式A*B的输出:");
	MulPloy(Pa, Pb, Mul);
	PrintPloy(Mul);
	printf("\n");
	printf("多项式A的导数输出:");
	DerPloy(Pa, Der);
	PrintPloy(Der);
	printf("\n");
	return 0;
}

运行截图:
在这里插入图片描述

结语

这次也是一个小小的实验,是一元稀疏多项式计算器的实现,能够实现对两个多项式进行简单的计算处理即可。以上只是vince提供的一种方法,当然也还有很多不足之处,也望大家批评指正。
在这里插入图片描述
🎉🎉🎉以上代码均可运行,所用编译环境为 vs2019 ,运行时注意加上编译头文件#define _CRT_SECURE_NO_WARNINGS 1

  • 82
    点赞
  • 219
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 85
    评论

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

<vince>

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值