一元稀疏多项式计算器

别把自己太当回事，要把你做的事当回事！

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 
#include 
#include 

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 && tail->data > 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)
					printf("X");//系数为1时输出
				else
					printf("%dX", tail->data);
			}
			else//指数大于1的时候输出
			{
				if (tail->data == 1)
					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)
					printf("X");//系数为1时输出
				else
					printf("%dX", tail->data * (-1));
			}
			else//指数大于1的时候输出
			{
				if (tail->data == 1)
					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