数据结构一元稀疏多项式简单计数器（课程设计）C语言版

张福特竟然还有重名？

于 2024-06-06 19:46:27 发布

阅读量866

点赞数 11

文章标签：数据结构算法 c语言课程设计

本文链接：https://blog.csdn.net/2301_77516665/article/details/139508005

版权

作者非计算机专业，数据结构算法小白。欢迎各位大佬指正错误！

采用的编译器是Visual Studio 2022

一元稀疏多项式简单计数器

题目内容：

（1）输入并建立多项式

（2）输出多项式，输出形式为整数序列：n，c1，e1，c2，e2……cn，en，其中n是多项式的项数，ci，ei分别为第i项的系数和指数。序列按指数降序排列。

（3）多项式a和b相加，建立多项式a+b，输出相加的多项式。

（4）多项式a和b相减，建立多项式a-b，输出相减的多项式。

用带头结点的单链表存储多项式。

测试数据：

（1）(2x+5x8-3.1x11)+(7-5x8+11x9)

（2）(6x-3-x+4.4x2-1.2x9)-(-6x-3+5.4x2+7.8x15)

（3）(x+x2+x3)+0

（4）(x+x3)-(-x-x-3)

在此课设题目的背景下，添加了两个简单的功能：

1、查看以往的计算结果

2、多个多项式同时参与运算

代码整体简洁介绍：

（1）带头结点的单链表数据结构类型Dlist，其中包含的操作有：初始化操作函数，遍历输出结点信息函数，加法函数，减法函数，计算项数的函数。

（2）int Slen(Dlist L)函数用来求多项式链表的长度，int print(Dlist L)函数用来打印多项式链表。

（3）Dlist initNode(Dlist L)函数进行尾插法建立链表，并进行指数降序排列。

（4）Dlist addPoly(Dlist L1, Dlist L2)函数实现多项式链表的加法，Dlist Subtract(Dlist L1, Dlist L2) 函数实现多项式链表的减法。

（5）int main()，主函数，输入测试数据，建立多项式链表，使用菜单调用上述函数实现问题要求，建立数组保存计算结果，以便查找，把每次建立的多项式链表存到Dlist数组中，输入每次计算的所用的数组下标，实现多个多项式进行运算。

#include<stdio.h>
#include <stdlib.h>
int cnt1 = 0, cnt2 = 0; //cnt1用来记录当前计算的结果数，cnt2用来记录当前一共输入了多少个多项式
typedef struct Node {
	float x;
	float z;
	struct Node* next;
}Node, * Dlist;

//计算多项式的项数
int Slen(Dlist L) {
	int t = 0;
	int i = 1;
	L = L->next;
	if (L == NULL) return 0;
	while (1) {
		if (L == NULL||L->x==0)break;
		L = L->next;
		t++;
	}
	return t;
}

//输出多项式函数
int print(Dlist L) {
	int a, b, ct = 0;
	L = L->next;
	if (L == NULL) return 0;
	while (100) {
		if (L == NULL || L->x == 0)break;
		a = int(L->x); b = int(L->z);
		if (a == 0)  L = L->next;
		else {
			L = L->next;
			printf("%d %d ", a, b);
		}
	}
	return 0;
}

//尾插法建立链表，并进行指数降序排列
Dlist initNode(Dlist L) {
	Node* head, * s;
	head = (Node*)malloc(sizeof(Node));
	if (head != NULL) {
		s = head;
		float sj[100][2] = { {0,0} };
		printf("请依次输入这个多项式的系数和指数：");
		for (int i = 1; i <= 100; i++) {
			scanf_s("%f %f", &sj[i][0], &sj[i][1]);
			if (sj[i][0] == 0 && sj[i][1] == 0)break;
			sj[0][0] += 1;
		}

		//对序列进行同类相合并
		for (int i = 1; i <= 100; i++) {
			for (int j = i + 1; j <= 100; j++) {
				if (sj[i][1] == sj[j][1] && sj[i][0] != 0 && sj[j][0] != 0) {
					sj[i][0] += sj[j][0]; sj[j][0] = 0; sj[j][1] = 0;
				}
			}
		}

		//对多项式的序列按指数降序排列，使用冒泡排序
		float t1 = 0, t2 = 0;
		for (int i = 1; i <= sj[0][0]; i++) {
			for (int j = i + 1; j <= sj[0][0]; j++) {
				if (sj[j][1] > sj[i][1]) {
					t1 = sj[i][1]; sj[i][1] = sj[j][1]; sj[j][1] = t1;
					t2 = sj[i][0]; sj[i][0] = sj[j][0]; sj[j][0] = t2;
				}
			}
		}

		if (sj[1][1] == 0 && sj[1][0] == 0) {
			Node* p;
			p = (Node*)malloc(sizeof(Node));
			if (p != NULL) {
				p->x = sj[1][0];
				p->z = sj[1][1];
				p->next = NULL;
				s->next = p;
				s = p;
			}
		}
		else {
			for (int i = 1; i <= sj[0][0] + 1; i++) {
				Node* p;
				p = (Node*)malloc(sizeof(Node));
				if (p != NULL && sj[i][0] != 0) {
					p->x = sj[i][0];
					p->z = sj[i][1];
					p->next = NULL;
					s->next = p;
					s = p;
				}
				else break;
			}
		}
		return head;
	}
	return NULL;
}

Dlist addPoly(Dlist L1, Dlist L2) {
	Node* p1 = L1->next;
	Node* p2 = L2->next;
	Dlist result = (Dlist)malloc(sizeof(Node));
	if (result != NULL) {
		result->next = NULL;
		Node* p = result;

		while (p1 && p2) {
			Node* temp = (Node*)malloc(sizeof(Node));
			if (temp != NULL && p != NULL) {
				if (p1->z > p2->z) {
					temp->x = p1->x;
					temp->z = p1->z;
					p1 = p1->next;
				}
				else if (p1->z < p2->z) {
					temp->x = p2->x;
					temp->z = p2->z;
					p2 = p2->next;
				}
				else {
					temp->x = p1->x + p2->x;
					temp->z = p1->z;
					p1 = p1->next;
					p2 = p2->next;
				}
				temp->next = NULL;
				if (temp->x == 0)continue;
				p->next = temp;
				p = temp;
			}
		}

		while (p1) {
			Node* temp = (Node*)malloc(sizeof(Node));
			if (temp != NULL && p != NULL) {
				temp->x = p1->x;
				temp->z = p1->z;
				p1 = p1->next;
				temp->next = NULL;
				p->next = temp;
				p = temp;
			}
		}

		while (p2) {
			Node* temp = (Node*)malloc(sizeof(Node));
			if (temp != NULL && p != NULL) {
				temp->x = p2->x;
				temp->z = p2->z;
				p2 = p2->next;
				temp->next = NULL;
				p->next = temp;
				p = temp;
			}
		}
		return result;
	}
	return NULL;
}
//多项式相减
Dlist Subtract(Dlist L1, Dlist L2) {
	Node* p1 = L1->next;
	Node* p2 = L2->next;

	Dlist result = (Dlist)malloc(sizeof(Node));
	if (result != NULL) {
		result->next = NULL;
		Node* p = result;
		while (p1 && p2) {
			Node* temp = (Node*)malloc(sizeof(Node));
			if (temp != NULL && p != NULL) {
				if (p1->z > p2->z) {

					temp->x = p1->x;
					temp->z = p1->z;
					p1 = p1->next;
				}
				else if (p1->z < p2->z) {
					temp->x = (p2->x) * (-1);
					temp->z = p2->z;
					p2 = p2->next;
				}
				else {
					temp->x = p1->x + (p2->x) * (-1);
					temp->z = p1->z;
					p1 = p1->next;
					p2 = p2->next;
				}
				temp->next = NULL;
				if (temp->x == 0)continue;
				p->next = temp;
				p = temp;
			}
		}
		while (p1) {
			Node* temp = (Node*)malloc(sizeof(Node));
			if (temp != NULL && p != NULL) {
				temp->x = p1->x;
				temp->z = p1->z;
				p1 = p1->next;
				temp->next = NULL;
				p->next = temp;
				p = temp;
			}
		}

		while (p2) {
			Node* temp = (Node*)malloc(sizeof(Node));
			if (temp != NULL && p != NULL) {
				temp->x = p2->x * (-1);
				temp->z = p2->z;
				p2 = p2->next;
				temp->next = NULL;
				p->next = temp;
				p = temp;
			}
		}
		return result;
	}
	return NULL;
}

int main()
{
	int i = 0, j = 0, c, pre = 0;
	Dlist L[100] = { 0 };
	Dlist p[100] = { 0 };

	while (1) {
		printf("-------菜单-------\n");
		printf("1:建立多项式\n");
		printf("2:多项式相减\n");
		printf("3:多项式相加\n");
		printf("4:返回之前的计算结果\n");
		printf("5:退出程序\n");
		printf("请选择你要进行的操作：");
		scanf_s("%d", &c);
		if (c == 5)break;
		int idx[100] = { 0,0,0,0 };
		if (c == 2 || c == 3) {
			printf("请输入需要参与运算的多项式的数组下标:");
			int j = 0;
			for (int i = 1; i < 100; i++) {
				scanf_s("%d", &j);
				if (j == 0)break;
				idx[i] = j;
			}
		}

		switch (c) {

		case 1:
			int n;
			printf("请输入需要建立的多项式个数：");
			scanf_s("%d", &n);
			for (int i = cnt2 + 1; i <= cnt2 + n; i++) {
				printf("正在建立第%d个多项式链表", i);
				L[i] = initNode(L[i]);
				printf("多项式链表建立成功\n");
			}
			cnt2 += n;
			break;
		case 2:

			cnt1 += 1;
			Dlist re;
			re = (Dlist)malloc(sizeof(Node));
			re = Subtract(L[idx[1]], L[idx[2]]);
			for (int i = 3; i <= 100; i++) {
				if (idx[i] == 0)break;
				re = Subtract(re,L[idx[i]]);
			}
			printf("结果为：");
			printf("%d ", Slen(re));
			print(re);
			p[cnt1] = re;
			printf("\n");
			break;

		case 3:
			cnt1 += 1;
			Dlist ree;
			ree = (Dlist)malloc(sizeof(Node));
			ree = addPoly(L[idx[1]], L[idx[2]]);
			for (int i = 3; i <= 100; i++) {
				if (idx[i] == 0)break;
				ree = addPoly(ree, L[idx[i]]);
			}
			printf("结果为：");
			printf("%d ", Slen(ree));
			print(ree);
			p[cnt1] = ree;
			printf("\n");
			break;

		case 4:
			printf("你需要返回第几次的计算结果：");
			scanf_s("%d", &pre);
			printf("%d ", Slen(p[pre]));
			print(p[pre]);
			printf("\n");
			break;
		default:break;
		}
	}
	return 0;
}

测试数据运行结果

（1）(2x+5x8-3.1x11)+(7-5x8+11x9)

（2）(6x-3-x+4.4x2-1.2x9)-(-6x-3+5.4x2+7.8x15)

（3）(x+x2+x3)+0

（4）(x+x3)-(-x-x-3)

这个课设无法进行加减混合运算，按照作者的思路，在输入参与运算的多项式的数组下标时，会涉及字符的判断，以我这个小白的知识储量，建立一个字符串数组类型，输入参与运算的多项式下标和运算符，然后使用循环进行判断。

特判：

（1）当第一个字符和最后一个字符为运算符

（2）连续多个运算符输入

（3）连续多个多项式下标输入

再来测试一下新增的功能

1、查看之前计算的结果

2、多个多项式同时参与运算

张福特竟然还有重名？

关注

11
点赞
踩
19

收藏

觉得还不错? 一键收藏
0
评论
数据结构一元稀疏多项式简单计数器（课程设计）C语言版

（5）int main()，主函数，输入测试数据，建立多项式链表，使用菜单调用上述函数实现问题要求，建立数组保存计算结果，以便查找，把每次建立的多项式链表存到Dlist数组中，输入每次计算的所用的数组下标，实现多个多项式进行运算。这个课设无法进行加减混合运算，按照作者的思路，在输入参与运算的多项式的数组下标时，会涉及字符的判断，以我这个小白的知识储量，建立一个字符串数组类型，输入参与运算的多项式下标和运算符，然后使用循环进行判断。cn，en，其中n是多项式的项数，ci，ei分别为第i项的系数和指数。
复制链接

扫一扫