C语言实现两个多项式加法与乘法

已于 2022-12-01 16:04:49 修改
阅读量3.6k 收藏 33
点赞数 4
文章标签： c语言 链表 开发语言 1024程序员节
于 2021-10-23 22:28:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiexieyuchen/article/details/120927114
版权

加法实现：

先说一下，我用了两种方法实现，一种是顺序表实现，一种是链表实现，所以，为了方便，将两种方法分别写成头文件了，主函数是一样的

方法一（顺序表实现）

直接上代码，头文件"List.h"代码：

//头文件"List.h"
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<Windows.h>
#define MAXSIZE 1005
typedef int ElementType;
typedef struct LNode {//定义结构体
	ElementType Data1[MAXSIZE];
	ElementType Data2[MAXSIZE];//因为后面的第二题要用到两个数组，所以我在第一题就一次定义了两个数组
							   //防止后面贴重复代码
	int Last;//数组Data用来存放数据
				  //Last用来标记存放数据的最后一个位置
				  //Last其实就是Data数组存放的最后一个元素的下标
				  //所以Last+1其实就是线性表的长度
}*List;
List makeEmpty() {//创建线性表
	List L = (List)malloc(sizeof(struct LNode));
	L->Last = -1;
	return L;
}
int Find(List L, ElementType x) {//查找   0
	int i = 0;
	while (i <= L->Last && L->Data1[i] != x)i++;
	if (i > L->Last)return -1;
	return i;
}
List Insert(List L, ElementType x, ElementType y, int i) {//插入   1
	if (L->Last == MAXSIZE - 1) {//表空间已满，不能插入
		printf("表满\n");
		return L;
	}
	if (i<1 || i>L->Last + 2) {
		printf("位数不合法\n");
		return L;
	}
	for (int j = L->Last; j >= i - 1; j--)
		L->Data1[j + 1] = L->Data1[j];//数据后移
	L->Data1[i - 1] = x;
	L->Data2[i - 1] = y;
	L->Last++;//插入成功后，线性表长度+1，并且Last仍指向最后一个元素
	return L;
}
int Length(List L) {//计算线性表的长度   2
	return L->Last + 1;
}
bool Delete(List L, int i) {//删除第i个元素   3
	if (i<0 || i>L->Last + 1) {
		printf("位序%d不存在元素\n", i);
		return false;
	}
	for (int j = i; j <= L->Last; j++) {
		L->Data1[j] = L->Data1[j + 1];
		L->Data2[j] = L->Data2[j + 1];
	}//数据前移就相当于删去了位序i的元素
	L->Last--;//删除成功后，线性表的长度-1，并且Last仍指向最后一个元素

}
ElementType FindKth(List L, int i) {//输出第i位元素   4
	if (i<1 || i>L->Last + 1) {
		printf("位序%d不存在元素\n", i);
		return false;
	}
	return L->Data1[i];
}
void print(List L) {//将线性表中的元素全部打印出来 5
	if (L->Last == -1) {
		printf("0\n");
		return;
	}
	if (L->Data1[0] != 0) printf("%d*X^%d", L->Data1[0], L->Data2[0]);
	else printf("0");
	for (int i = 1; i <= L->Last; i++) {
		if (L->Data1[i] == 0)continue;
		if (L->Data1[i] == 1) {
			if (L->Data2[i] == 0) {
				if (L->Data1[i] < 0) printf("%d", L->Data1[i]);
				else printf("+%d", L->Data1[i]);
			}
			else if (L->Data2[i] == 1) {
				if (L->Data1[i] < 0)printf("X");
				else printf("+X");
			}
			else {
				if (L->Data1[i] < 0)printf("X^%d", L->Data2[i]);
				else printf("+*X^%d", L->Data2[i]);
			}
		}
		else {
			if (L->Data2[i] == 0) {
				if (L->Data1[i] < 0) printf("%d", L->Data1[i]);
				else printf("+%d", L->Data1[i]);
			}
			else if (L->Data2[i] == 1) {
				if (L->Data1[i] < 0)printf("%d*X", L->Data1[i]);
				else printf("+%d*X", L->Data1[i]);
			}
			else {
				if (L->Data1[i] < 0)printf("%d*X^%d", L->Data1[i], L->Data2[i]);
				else printf("+%d*X^%d", L->Data1[i], L->Data2[i]);
			}
		}
	}
	printf("\n");
}
List List_sort(List L) {//将线性表中的数按指数大小进行排列
	//并将表中数组Data1[]的值为0的删除
	if (L->Last == -1) return L;
	else {
		for (int i = 0; i <= L->Last; i++)//去重，防止输入错误使线性表中存在两个指数相同的元素
			for (int j = i + 1; j <= L->Last; j++)
				if (L->Data2[i] == L->Data2[j] && L->Data1[i] != 0 && L->Data1[j] != 0) {
					L->Data1[i] += L->Data1[j];
					L->Data1[j] = 0;
				}
		for (int i = 0; i <= L->Last; i++)
			if (L->Data1[i] == 0) Delete(L, i);
		for (int i = 0; i <= L->Last; i++) //选择排序
			for (int j = i + 1; j <= L->Last; j++)
				if (L->Data2[i] < L->Data2[j]) {
					ElementType t = L->Data1[i];
					L->Data1[i] = L->Data1[j];
					L->Data1[j] = t;
					t = L->Data2[i];
					L->Data2[i] = L->Data2[j];
					L->Data2[j] = t;
				}
	}
	return L;
}
List add(List a, List b) {//将两个多项式相加
	List L = makeEmpty();//用数组Data1储存多项式的系数，用数组Data2储存多项式的指数
	if (a->Last == -1 && b->Last == -1) printf("要相加的两个多项式均为空\n");
	else if (a->Last == -1 && b->Last != -1) L = b;
	else if (a->Last != -1 && b->Last == -1) L = a;
	else if (a->Last != -1 && b->Last != -1) {
		L = a;
		//若是用L来遍历b，我们每次循环后都要将已经处理过的b的元素删掉（避免重复添加）
		//这样就会出现重加（b的这个元素与L的这个元素指数不等，但是可能会有L的其它元素与b的这个元素相等）
		//不好判断是否删除b元素等情况
		for (int i = 0; i <= b->Last; i++) {//用b来遍历L，可以在不用删除b表中的元素就可以相加了，就不会出现误删的情况了
			int flag = 0;
			for (int j = 0; j <= L->Last; j++) {
				if (L->Data2[j] == b->Data2[i]) {
					L->Data1[j] += b->Data1[i];
					flag = 1;
				}
			}
			if (flag == 0) L = Insert(L, b->Data1[i], b->Data2[i], L->Last + 2);
			//Delete(b, i);
		}
	}
	return L;
}

方法二（链表实现）

头文件"List.c"代码：

//头文件"List.c"代码
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<Windows.h>
typedef struct LNode* PtrToLNode;
typedef int ElementType;
struct LNode {
	ElementType Data1, Data2;
	//Data1用来存系数，Data2用来存指数
	PtrToLNode Next;
};
typedef PtrToLNode List;
List makeEmpty() {//创建一个空链表并且将第一个节点空置
	List L = (List)malloc(sizeof(struct LNode));
	L->Next = NULL;
	return L;
}
int Length(List L) {//计算链表的长度
	//因为第一个节点是没有数据的，所以要从第二个节点开始计数
	List p = L->Next;
	int cut = 0;
	while (p != NULL) {
		cut++;
		p = p->Next;
	}
	return cut;
}
void Findkth(List L, int k) {//在链表中查找第k个元素
	List p = L->Next;
	int cnt = 1;
	while (p != NULL && cnt < k) {
		p = p->Next;
		cnt++;
	}
	if (cnt == k) {
		printf("第%d个元素为：", k);
		if (p->Data2 == 0)printf("%d\n", p->Data1);
		else printf("%dX^%d\n", p->Data1, p->Data2);
	}
	else 
		printf("在链表中没有第%d个元素\n", k);
}
List Find(List L, ElementType x) {//在链表中查找元素x的位置
	//因为在多项式中，指数才是唯一的，所以x应该是为指数
	List p = L->Next;
	while (p && p->Data2 != x) p = p->Next;
	if (p)return p;
	else return NULL;
}
List Insert(List L, ElementType x, ElementType y, int i) {//插入函数
	List tmp = (List)malloc(sizeof(struct LNode));
	tmp->Data1 = x; tmp->Data2 = y;
	int cnt = 0;
	List p = L;
	while (p && cnt < i - 1) {
		p = p->Next;
		cnt++;
	}
	if (p == NULL || cnt != i - 1) 
		printf("插入位置的参数错误\n!");
	else {
		tmp->Next = p->Next;
		p->Next = tmp;
	}
	return L;
}
List Delete(List L, int i) {//将第i个元素删除
	List tmp, p = L;
	int cnt = 0;
	while (p && cnt < i - 1) {
		p = p->Next;
		cnt++;
	}
	if (p == NULL || cnt != i - 1 || p->Next == NULL)printf("删除位置参数错误！\n");
	else {
		tmp = p->Next;
		p->Next = tmp->Next;
		free(tmp);
	}
	return L;
}
void print(List L) {//打印相加之后的多项式
	if (L->Next == NULL) {//如果链表中没有数据，直接退出函数
		printf("0\n");
		return;
	}
	List p = L->Next;
	if (p->Data1 != 0) printf("%d*X^%d", p->Data1, p->Data2);
	else printf("0");
	p = L->Next->Next;
	while (p != NULL) {
		if (p->Data1 == 0) {
			p = p->Next;
			continue;
		}
		if (p->Data1 == 1) {
			if (p->Data2 == 0) {
				if (p->Data1 < 0) printf("%d", p->Data1);
				else printf("+%d", p->Data1);
			}
			else if (p->Data2 == 1) {
				if (p->Data1 < 0)printf("X");
				else printf("+X", p->Data1);
			}
			else {
				if (p->Data1 < 0)printf("X^%d", p->Data1, p->Data2);
				else printf("+X^%d", p->Data1, p->Data2);
			}
		}
		else {
			if (p->Data2 == 0) {
				if (p->Data1 < 0) printf("%d", p->Data1);
				else printf("+%d", p->Data1);
			}
			else if(p->Data2==1){
				if (p->Data1 < 0)printf("%d*X", p->Data1);
				else printf("+%d*X", p->Data1);
			}
			else {
				if (p->Data1 < 0)printf("%d*X^%d", p->Data1, p->Data2);
				else printf("+%d*X^%d", p->Data1, p->Data2);
			}
		}
		p = p->Next;
	}
	printf("\n");
}
List List_sort(List L) {
	if (L->Next == NULL)return L;//如何链表中没有有效的元素，直接返回L
	List p, q;
	p = L->Next;
	int i = 0;
	for (p = L->Next; p!= NULL; p = p->Next) //见链表中的元素按指数大小进行排序
		for (q = p->Next; q!= NULL; q = q->Next) //选择排序
			if (p->Data2 < q->Data2) {
				ElementType t = p->Data2;
				p->Data2 = q->Data2;
				q->Data2 = t;
				t = p->Data1;
				p->Data1 = q->Data1;
				q->Data1 = t;
			}
	return L;
}
List add(List a, List b) {
	List p = b->Next;
	while (p != NULL) {
		List q = a->Next;
		int flag = 0;
		while (q != NULL) {
			if (p->Data2 == q->Data2) {//如果两个链表的指数相等，就将两个链表中的对应系数相加
				q->Data1 += p->Data1;
				flag = 1;
			}
			q = q->Next;
		}
		if (flag == 0)Insert(a, p->Data1, p->Data2, Length(a) + 1);
		p = p->Next;
	}
	return a;
}

最后是主函数代码：

#include"List.h"//导入头文件，这个文件是用顺序存储实现的
//#include"List.c"//这个头文件是用链表实现的
//分别用两个头文件运行得到的结果是一样的（亲自调试过）
//在使用其中一个头文件是应将另一个头文件注释掉
int main() {
	List a = makeEmpty();
	List b = makeEmpty();
	int na, nb;
	printf("请分别输入多项式a与多项式b的非0系数的个数：\n");
	scanf("%d %d", &na, &nb);
	printf("请输入多项式a的各项系数与指数：\n");
	ElementType x, y;
	if (na != 0) {//输入应确保每个多项式的指数没有相同的
		//因为在多项式中指数相同的元素应该已经相加好了
		while (na--) {
			scanf("%d %d", &x, &y);
			a = Insert(a, x, y, Length(a) + 1);//将新加入的元素插到表尾
		}
	}
	if (nb != 0) {
		printf("请输入多项式b的各项系数与指数：\n");
		while (nb--) {
			scanf("%d %d", &x, &y);
			b = Insert(b, x, y, Length(b) + 1);//将新加入的元素插到表尾
		}
	}
	List L = add(a, b);//多项式相加
	List_sort(L);//将相加后的线性表去除0系数的元素并进行按指数大小的从大到小的排序
	printf("两个多项式相加后得到的结果为：\n");
	print(L);//直接输出相加完之后的多项式
	return 0;
}

运行结果：（两个文件的运行结果相同）

 乘法实现：

乘法的实现我只写了一种方法，就是用链表实现

嗯，头文件和前面的加法实现代码"List.c"是一样的，就不再贴了

只是在主函数中加了两个自定义函数

主函数代码：

#include "List.c"
List Multiplication(List a, List b) {//将两个多项式相乘的函数
	List c = makeEmpty();//重新创建一个链表来存相乘之后的数据
	List p = a->Next;
	List d = c;
	while (p != NULL) {//两层循环把连个链表遍历
		List q = b->Next;
		while (q != NULL) {
			List s = (List)malloc(sizeof(struct LNode));
			s->Data1 = p->Data1 * q->Data1;
			s->Data2 = p->Data2 + q->Data2;
			//多项式相乘，系数相乘，指数相加
			d->Next = s;
			s->Next = NULL;
			d = s;
			q = q->Next;
		}
		p = p->Next;
	}
	return c;
}
List new_List_sort(List L) {//进行查重，将相同的指数数据相加
	List p = L->Next;
	while (p != NULL) {
		List q = p->Next;
		while (q != NULL) {
			if (p->Data2 == q->Data2) {
				p->Data1 += q->Data1;
				q->Data1 = 0;
			}
			q = q->Next;
		}
		p = p->Next;
	}
	return L;
}
int main() {
	List a = makeEmpty();
	List b = makeEmpty();
	int na, nb;
	printf("请分别输入多项式a与多项式b的非0系数的个数：\n");
	scanf("%d %d", &na, &nb);
	printf("请输入多项式a的各项系数与指数：\n");
	ElementType x, y;
	if (na != 0) {//输入应确保每个多项式的指数没有相同的
		//因为在多项式中指数相同的元素应该已经相加好了
		while (na--) {
			scanf("%d %d", &x, &y);
			a = Insert(a, x, y, Length(a) + 1);//将新加入的元素插到表尾
		}
	}
	if (nb != 0) {
		printf("请输入多项式b的各项系数与指数：\n");
		while (nb--) {
			scanf("%d %d", &x, &y);
			b = Insert(b, x, y, Length(b) + 1);//将新加入的元素插到表尾
		}
	}
	List c = Multiplication(a, b);//多项式相乘
	List_sort(c);//将相乘后的线性表去除0系数的元素并进行按指数大小的从大到小的排序
	new_List_sort(c);//将相乘后的链表进行查找，防止出现有指数相同的两个结点
	printf("两个多项式相乘后得到的结果为：\n");
	print(c);//直接输出相乘完之后的多项式
	return 0;
}

下面是运行结果展示（因为数据太大不好验算，所以就造了一些比较简单的数据）：

嗯，就到这里了，比较简单，也没什么好讲解的。 

xiaoyuer2815
关注
顺序链式-元多项式加法减法乘法运算实现.docx
11-05
该文档主要涉及的是使用C语言实现顺序链式存储结构的多项式加、减、乘运算。首先，我们来详细解析一下这个设计内容。 1.1 设计内容及要求： (1) 使用顺序存储结构实现多项式加、减、乘运算。例如，给定两个多项式f...
数据结构__两个多项式乘法运算
My Struggle
10-29 4669
这个，也是第一次数据结构课程设计的题目 一共四个文件，分别命名为main.cpp head.h list.h cal.h。作用分别是main函数主程序，基本头文件卷入，单链表和其基本操作的定义，计算并合并同类项目操作 注释就不写了，因为没啥好写的，我也不知道该写些什么。 main.cpp #include"cal.h" int main(void) { cal(); ...
C语言 多项式乘法 算法
m0_52313753的博客
01-13 6480
多项式乘法 什么是多项式？ 由若干个单项式相加组成的代数式叫做多项式（若有减法：减一个数等于加上它的相反数）。 多项式中的每个单项式叫做多项式的项，这些单项式中的最高项次数，就是这个多项式的次数。 多项式中不含字母的项叫做常数项。 在C语言中怎么表示？ 最简单直观的方式就是： 将多项式对应的系数储存在数组中，而数组下标就是项的指数 最后写出相应的代码 #include <stdio.h> int main() { int i, j, m, n; scanf("%d"
c语言n元多项式乘法,小白专场-多项式乘法与加法运算-c语言实现-Go语言中文社区...
weixin_33413839的博客
05-17 709
一、题意理解设计函数分别求两个一元多项式的乘积与和，例：[text{已知以下两个多项式：} \begin{align}& 3x^4-5x^2+6x-2 \& 5x^{20}-7x^4+3xend{align}][text{多项式和为：} \begin{align}5x^{20}-4x^4-5x^2+9x-2end{align}]假设多项式的乘积为((a+b)(c+d)=ac+ad+...
C语言实现两个多项式相加&相减&相乘运算
Miss Z的博客
11-15 6834
1
【数据结构】——多项式乘法
qq_41932198的博客
08-01 6627
题目要求 从字符文件输入两个多项式的非零系数及对应的指数，建立多项式的链式存储结构，计算这两个多项式的乘积，输出乘积多项式的全部非零系数及对应的指数到另一字符文件中。 算法原理 两个多项式的乘法，可以借助两个多项式的加法的算法来实现。 设： ...
C语言-一元稀疏多项式计算器
03-27
本项目“C语言-一元稀疏多项式计算器”专注于利用C语言来处理一元稀疏多项式运算，包括加法、减法、乘法和除法。在本文中，我们将详细探讨这一主题，以及如何用C语言实现这些功能。 一元稀疏多项式是指多项式中大...
顺序链式-元多项式加法减法乘法运算实现.pdf
11-05
该文档涉及的是使用C语言实现顺序链式存储结构来处理一元多项式的加、减、乘运算。在本文档中，我们首先看到设计内容包括使用顺序存储结构和链式存储结构来实现这些基本的数学运算。顺序存储结构是通过数组实现，而...
多项式加法和乘法C代码
12-14
本文将深入解析一个用C语言编写的多项式加法与乘法程序。该程序主要利用链表结构来表示多项式，并通过栈的方式来处理多项式的运算。程序不仅实现了多项式的加法运算，还实现了乘法运算。 #### 主要功能 1. **多项式...
任意两个高次多项式的加法和乘法运算.doc
11-27
"任意两个高次多项式的加法和乘法运算" 本设计是关于任意两个高次多项式的加法和乘法运算的课程设计报告。该设计的目的是使用C++语言和数据结构思想解决任意两个高次多项式的加法和乘法运算问题。 首先，本设计中...
【多项式相乘C语言实现】
最新发布
2301_76560014的博客
09-22 369
数据结构c语言版
两个多项式的相加&相乘
hj_503218859的博客
10-04 863
两个多项式的相加&相乘 #include <stdio.h> #include <stdlib.h> typedef struct polynomial //建立表示多项式的结构体 { int x[2]; struct polynomial *next; }POL; POL *creatlist (int n); POL *addition (POL*head1, POL*head2,int n); void output (POL *head); P
多项式乘法 c语言,多项式相乘.cpp
weixin_36444484的博客
05-17 992
#include#include # define MAX 100 //多项式最多项数typedef struct{ double coef; //系数int exp; //指数} PolyArray; //存放多项式的数组类型typedef struct pnode{double coef; //系数int exp; ...
用C语言写出多项式的乘法
weixin_35751194的博客
02-12 465
下面是C语言实现多项式乘法的示例代码： ``` #include <stdio.h> #include <stdlib.h> #define MAX_TERMS 101 /* 最多项数 */ typedef struct { float coef; /* 系数 / int expn; / 指数 */ } term; term a[MAX_TERMS]; /*...
c语言 一元多项式乘法,一元多项式的加法、减法、乘法和微分运算的C语言链表结构算法实现...
weixin_36151775的博客
05-17 1059
问题描述：利用链表实现一元多项式的数学运算。如一元多项式可以利用其系数????和指数????组合的方式实现链式存储。通过对线性表的基本操作，例如插入，删除，查找等可以实现一元多项式的复杂运算，比如加，减，乘，除等运算。基本要求：利用链表存储一元多项式，通过对链表的操作实现多项式的运算。测试数据：对于多项式：????(????) = 7 + 3???? + 9???? + 5????，????(????) = 8???? + 22???? − 9????，实现加，减，乘...
2.2 多项式乘法与加法运算（线性结构，C）
吃鱼从来不吐刺的博客
03-18 2913
设计函数分别求两个一元多项式的乘积与和 已知两个多项式 （1）3x4-5x2+6x-2 （2）5x20-7x4+3x 输入样例： 4 3 4 -5 2 6 1 -2 0 3 5 20 -7 4 3 1 输出样例： 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
C语言链表求解多项式乘法问题
DarkSide_的博客
02-03 1786
C语言链表求解多项式乘法问题 解决多项式乘法问题最容易想到的就是将乘法运算转换为加法运算。从p1的第一项开始，依此乘以p2的每一项，合并同类项后放入结果多项式中。然而项数太多时，合并同类项的过程过于复杂…… 此处采用的是一种逐项插入的算法，即将p1的当前项与p2的当前项相乘，并插入结果多项式中。关键是要找对插入位置。该算法中，用p1的第一项乘以p2得到初始结果多项式。 由于是按照指数递减的顺序输入...
C语言实现一元多项式的加法与乘法
C3171073487的博客
04-06 4854
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录问题描述一、程序结果二、实现步骤与程序说明1.问题分析2.代码结构主函数：链表的插入多项式的创建多项式加法多项式乘法多项式的输出三、总结 问题描述 题目来源：PTA 数据结构与算法题目集（中文）7-2 一元多项式的乘法与加法运算 (20 分) 一、程序结果 二、实现步骤与程序说明 1.问题分析 题目涉及稀疏多项式的运算，相较于顺序存储结构，采用链式存储结构更为灵活。 对应的数据结构定义为（同严蔚敏教材）： typedef.
同时进行简单是加减乘除的方法C语言
醉蕤的博客
05-02 1717
浅玩一下，按自己想要的顺序同时进行简单的加减乘除运算
C++实现高次多项式加法与乘法运算设计报告
设计题目为"任意两个高次多项式的加法和乘法运算"，学生需要使用C++语言，结合数据结构的原理，如单链表和动态链表，来设计并实现这两个基本的数学运算。设计目标明确，不仅要实现算法功能，还要注重程序的效率，即...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

xiaoyuer2815

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

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

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

打赏作者

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

抵扣说明：

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

余额充值