多项式的 加法 与 乘法（C语言 单链表）

最新推荐文章于 2022-08-23 02:44:55 发布
最新推荐文章于 2022-08-23 02:44:55 发布
阅读量579 收藏 2
点赞数 1
分类专栏： C语言 # 大一下学期基础算法题 文章标签： 算法 链表 单链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45773503/article/details/105499948
版权
  1. 感觉被我写的复杂了，不过还是写出来了；（）
  2. 自我感觉合并同类项的函数还是不错滴（因为我改了一下午从o(2^n) -> o(n^2) -> o(n)）；
  3. 还有就是偷了个懒需要输入两个多项式的项数。
  4. 好好学习，天天向上！Yes

输入

4 5
5 3 4 2 3 1 2 0
6 5 3 4 4 3 7 2 2 1
在这里插入图片描述

/* 单链表 */
#include <stdio.h>
#include <stdlib.h>
struct nape{/* 项 */
	int coefficient;/* 系数 */
	int exponent;/* 指数 */
	struct nape *next;
};
struct nape *creatList();/* 创建表头 */
struct nape *inputNape();/* 输入一项 */
struct nape *attach(struct nape *head, struct nape *p);/* 连接输入项 */
struct nape *search(struct nape *head, int i); /* 寻找第i项 */
int empty(struct nape *head); /* 判断是否为空 */
void delate(struct nape *head, int i);/* 删除第 i 个节点 */

void inSert(struct nape *head, struct nape *p);/* 插入到链表的末尾 */
void sertIn(struct nape *head, int i, struct nape *p); /* 插入到链表中某个节点后面，辅助插入排序 */
struct nape *waitNape(struct nape *head, int i); /* 寻找，删除，并返回第 i 项，辅助插入排序 */
void sort(struct nape *head, int len); /* 按照系数的大小排序,就是传入输入的项数（偷懒了） */
int Max(int a, int b); /* 求两数中的大的那个 */
int count(struct nape *head);/* 计算链表项数 */

struct nape *addList(struct nape *head_1, struct nape *head_2);/* 相加 */
struct nape *multiplyList(struct nape *head_1, struct nape *head_2, int n, int m);/* 相乘 */


void print(struct nape *head) { /* 打印链表 */
	struct nape *p = head->next;
	while(p) {
		printf("%d-%d ", p->coefficient, p->exponent);
		if( p->next ) {
			printf(" ");
		}
		p = p->next;
	}
	printf("\n");
}


int main(void)
{
	int n, m;
	printf("请分别输入第一个多项式和第二个多项式的项数：");
	scanf("%d %d", &n, &m); 
	/* 确定两个多项式的项数，图方便了 */
	
	struct nape *head_1, *head_2, *head_add, *head_mul;
	head_1 = creatList();/* 创建第一个链表的表头 */
	head_2 = creatList();/* 创建第二个链表的表头 */
	
	/* 输入第一个多项式的项 */
	printf("请输入第一个多项式每个项的系数与指数：\n");
	for( int i = 0; i < n; ++i){
		struct nape *p = inputNape();
		head_1 = attach(head_1, p);
	} 	
	/* 输入第二个多项式的项 */
	printf("请输入第二个多项式每个项的系数与指数：\n");
	for( int i = 0; i < m; ++i){
		struct nape *p = inputNape();
		head_2 = attach(head_2, p);
	} 

	/* 排序 */
	sort(head_1, n);
	sort(head_2, m);
	/* 计算 */
	printf("......\n"); 
	head_add = addList(head_1->next, head_2->next);
	head_mul = multiplyList(head_1->next, head_2->next, n, m);

	/* 打印 */
	printf("两式相加等于:\n"); 
	print(head_add);
	printf("两式相乘等于:\n");
	print(head_mul);
	
	return 0;
}

/* 寻找链表中的第 i 项*/ 
struct nape *search(struct nape *head, int i){
	struct nape *tail = head;
	int j = 0;
	while( j != i) {
		tail = tail->next;
		j++;
	}
	return tail;
}

/* 判断链表是否为空 */
int empty(struct nape *head){
	if( head->next == NULL ) {
		return 0;
	}
	return 1;
} 

/* 删除链表中第 i 个节点 */
void delate(struct nape *head, int i){
	if( empty(head) ) {/* 判断是否为空 */
		struct nape *pre = search(head, i - 1);/* 被删除的前一项 */
		struct nape *del = search(head, i);/* 被删除的那一项 */
		pre->next = del->next;
		free(del);
	}
}

/* 创建头结点 */ 
struct nape *creatList() {
	struct nape *head = (struct nape*)malloc(sizeof(struct nape));
	head->coefficient = 0;
	head->exponent = 0;
	head->next = NULL;
	return head;
} 

/* 输入一项 */
struct nape *inputNape() {
	struct nape *p = (struct nape*)malloc(sizeof(struct nape));
	scanf("%d %d", &p->coefficient, &p->exponent);
	p->next = NULL;
	return p;
}

/* 连接输入项，在main函数中用到，返回head。与insert（无返回值）区分 */ 
struct nape *attach(struct nape *head, struct nape *p) {
	struct nape *tail = head;
	while( tail->next ) {
		tail = tail->next;
	}
	tail->next = p;
	p->next = NULL;/* 保证结尾是NULL */
	return head;
}
 
/* 结构体中的数据拷贝 */
struct nape *copy(struct nape *a){
	struct nape *p = (struct nape*)malloc(sizeof(struct nape));
	p->coefficient = a->coefficient;
	p->exponent = a->exponent;
	p->next = NULL;
	return p;
}

/* 插入到链表中某个节点后面，辅助插入排序 */
void sertIn(struct nape *head, int i, struct nape *p) {
	struct nape *tail = search(head, i);/* 要插到这一项后面 */
	p->next = tail->next;
	tail->next = p;
} 

/* 寻找，删除，并返回第 i 项，辅助插入排序 */
struct nape *waitNape(struct nape *head, int i) {
	int t = i;
	struct nape *tail = search(head, t);
	struct nape *p = (struct nape*)malloc(sizeof(struct nape));
	p = copy(tail);/* 拷贝 */
	delate(head, t);/* 删除 */
	return p;
}

/* 这里我用的插入排序 */
void sort(struct nape *head, int len) {
	int i;
	for( i = 2; i <= len; ++i ) {
		struct nape *wait = waitNape(head, i);/* 等待插入的项 */
		for( int j = i - 1; j >= 0; --j ) {
			struct nape *judge = search(head, j);/* 正在与wait比较的那一项 */
			/* 如果找到插入位置，便插在其后面 */ 
			if( (judge->coefficient == 0 && judge->exponent == 0) || wait->exponent < judge->exponent ) {/* 如果在最前面那插入到head后面，或者插在系数第一个比他大的后面 */
				sertIn(head, j, wait);
				break;
			}
		}
	}
}

/* 插入到链表的末尾，与attach（返回插入的头结点）区分 */
void inSert(struct nape *head, struct nape *p) {
	struct nape *tail = head;
	while(tail->next) {
		tail = tail->next; 
	}
	tail->next = p;
	p->next = NULL;
} 

/* 加法运算 ,三个循环*/
struct nape *addList(struct nape *head_1, struct nape *head_2) {
	struct nape *p = head_1, *q = head_2, *head_add, *temp;
	head_add = creatList();/* 创建头结点 */
	while( p && q ) {/* 当 p 或 q 都不等于空时 */
		struct nape *temp = (struct nape*)malloc(sizeof(struct nape));
		if( p->exponent > q->exponent ) {/* 若 p 的指数大则插入 q */
			temp = copy(p);
			inSert(head_add, temp) ;
			p = p->next;
		}
		else if( p->exponent < q->exponent ) {/* 若 p 的指数大则插入 q */
			temp = copy(q);
			inSert(head_add, temp);
			q = q->next;
		}
		else{/* 若相等那么合并后插入 */
			temp->coefficient = q->coefficient + p->coefficient;
			temp->exponent = q->exponent;
			temp->next = NULL;
			inSert(head_add, temp);
			p = p->next;
			q = q->next;
		}
	}
	
	if(p) {/* 如果 p 不为空，把 p 的项全部都插入到后面 */
		while(p) {
			struct nape *temp = (struct nape*)malloc(sizeof(struct nape));
			temp = copy(p);
			inSert(head_add, temp);
			p = p->next;
		}
	}
	else{/* 如果 q 不为空，把 q 的项全部都插入到后面 */
		while(q) {
			struct nape *temp = (struct nape*)malloc(sizeof(struct nape));
			temp = copy(q);
			inSert(head_add, temp);
			q = q->next;
		}		
	}
	return head_add;
}

/* 合并同类项，有点像用在线处理 */
struct nape *mergeSimilarItems(struct nape *head){
	int counts = count(head) - 1;/* 计算链表项数 */
	sort(head, counts);/* 排序 */
	struct nape *head_merge = creatList(), 
				*p = head->next, 
				*temp = (struct nape*)malloc(sizeof(struct nape)),
				*toFree = head, 
				*pre = toFree->next;
	int c;/* 用于判断下一个与这一个是否为同类项 */
	
	/* 初始化temp，与c */
	temp->coefficient = p->coefficient;
	temp->exponent = p->exponent;
	temp->next ==NULL;
	while(counts--) {
		c = p->next->exponent;
		if(counts != 1) {/* 解决循环结束的问题 */
			if( c == p->exponent ) { /* 判断下一个是否与这一个的指数相同 */
				temp->coefficient += p->next->coefficient;	/* 相同则相加 */	
				temp->exponent = temp->exponent;
			}
			else{/* 不同则插入并创建新的结点 */
				inSert(head_merge, temp);
				temp = (struct nape*)malloc(sizeof(struct nape));
				temp->coefficient = p->next->coefficient;
				temp->exponent = p->next->exponent;
				temp->next ==NULL;
			}
		}
		else{/* 若遍历到倒数第二个 */
			if( c == p->exponent ) {/* 如果最后一个的指数等于倒数第二个，那么系数相加后插入 */
				temp->coefficient += p->next->coefficient;		
				temp->exponent = temp->exponent;
				temp->next = NULL;
				inSert(head_merge, temp);
			}
			else{/* 否则说明最后一个是单独的一项，需要单独的插入 */
				inSert(head_merge, temp);/* 先把跟倒数第二项的指数相同的项相加后插入 */
				temp = (struct nape*)malloc(sizeof(struct nape));			
				temp->coefficient = p->next->coefficient;
				temp->exponent = p->next->exponent;
				temp->next = NULL;
				inSert(head_merge, temp);/* 将最后一个单独插入 */
			}
			break; 
		}
		p = p->next;
	}
	
	/* 将原先的空间释放掉，避免内存泄漏 */
	while(toFree) {
		pre = toFree->next;
		free(toFree);
		toFree = pre;
	}
	return head_merge;/* 返回新的头结点 */
}

/* 计算链表项数，算头结点 */
int count(struct nape *head) {
	int count=0;
	struct nape *p = head;
	while(p) {
		count++;
		p = p->next;
	}
	return count;
}

/* 乘法运算 */
struct nape *multiplyList(struct nape *head_1, struct nape *head_2, int n, int m) {
	struct nape *p, *q, *head_less, *head_more, *head_mul, *temp;
	head_mul = creatList();
	
	if( n < m ) {/* 让项数少的在外层循环，提高性能 */
		head_less = head_1;
		head_more = head_2;
	}
	else{
		head_less = head_2;
		head_more = head_1;
	}
	p = head_less;
	q = head_more;
	int min = n<m?n:m;
	int max = n>m?n:m;
	
	for( int i = 0; i < min; i++ ) {/* 有头结点，让项数少的在外层循环 */
		struct nape *nape_i = search(head_less, i);/* 寻找项少的链表的第i项 */
		for( int j = 0; j < max; j++ ) {
			temp = (struct nape*)malloc(sizeof(struct nape));
			struct nape *nape_j = search(head_more, j);/* 寻找项多的链表的第j项 */
			temp->coefficient = nape_i->coefficient * nape_j->coefficient;/* 系数相乘 */
			temp->exponent = nape_i->exponent + nape_j->exponent;/* 指数相加 */
			temp->next = NULL;
			inSert(head_mul, temp);/* 插入 */
		}
	}
	head_mul = mergeSimilarItems(head_mul);/* 合并同类项 */
	return head_mul; 	
}
~嘘~禁止想象~
关注
专栏目录
多项式加法(单链表 c语言)
smartboysboys的专栏
03-31 1018
#include #include #include typedef struct pnode { float coef; int expn; struct pnode *next; } pnode; pnode * creat() { float input_coef; int input_expn; pnode *head=NULL;
C语言实现一元多项式的加法与乘法
C3171073487的博客
04-06 4975
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录问题描述一、程序结果二、实现步骤与程序说明1.问题分析2.代码结构主函数：链表的插入多项式的创建多项式加法多项式乘法多项式的输出三、总结 问题描述 题目来源：PTA 数据结构与算法题目集（中文）7-2 一元多项式的乘法与加法运算 (20 分) 一、程序结果 二、实现步骤与程序说明 1.问题分析 题目涉及稀疏多项式的运算，相较于顺序存储结构，采用链式存储结构更为灵活。 对应的数据结构定义为（同严蔚敏教材）： typedef.
链表实现多项式加法和乘法（C语言实现）
12-03
使用链表实现多项式的加法和乘法，数据结构常见问题的C语言实现
多项式乘法 c语言,C语言单链表实现多项式的相乘
weixin_35949264的博客
05-17 1537
此次写该程序的时候费了不少劲，主要是在调试代码上，但是也花费了不少时间在构思代码的方法上，我做该程序时的思路如下：1.首先构出两个多项式head1=3 + 4x + 7x^2 +7x^9head2=1 + 4x^2 + 8x^3 + 4x^6人为计算的时候是head1中的每一项依次和head2中的每一项进行计算的，所以我用结构体数组存储该新形成的链表p[0]=3*(1 + 4x^2 + 8x^3 ...
数据结构（C语言）——多项式的加法和乘法，链表解答
qq_39953607的博客
08-23 255
数据结构、链表、算法、C语言
链表实现多项式加法_使用数组或链表对多项式进行加法和乘法的C程序
culing2941的博客
09-12 242
链表实现多项式加法 Polynomial addition, multiplication (8th degree polynomials) using arrays #include<math.h> #include<stdio.h> #include<conio.h> #define MAX 17 void init(int p[]); void rea...
《数据结构》C语言——多项式的加法与乘法实现（带表头的单链表）
Lavener_Love的博客
05-18 604
加法的算法我采用的书上的代码，应该没有错误。 乘法是我自己写的，经过几种测试发现正常的输入是不会有问题的，如果在运行过程中有错误欢迎留言分享交流。 注：p3链表创建时需要输入 0，-1才算创建成功。 #include<stdio.h> #include<stdlib.h> typedef struct PNode { int coef; int exp; struct PNode* link; } PNode; typedef struct { struct P
链表实现一元多项式的乘法与加法运算（C语言）
qq_42200813的博客
12-17 1024
求两个一元多项式的乘积与和。 输入格式: 输入分2行，每行分别先给出多项式非零项的个数，再以指数递降方式输入一个多项式非零项系数和指数（绝对值均为不超过1000的整数）。数字间以空格分隔。 输出格式: 输出分2行，分别以指数递降方式输出乘积多项式以及和多项式非零项的系数和指数。数字间以空格分隔，但结尾不能有多余空格。零多项式应输出0 0。 输入样例: 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 3
C语言实现多项式加法与乘法操作
1. 多项式及其表示方法：在数学中，多项式是由变量（也称未知数）和系数通过有限次加法、减法、乘法及非负整数次幂的运算所组成的代数表达式。在计算机程序中，多项式通常可以通过数组或者链表来表示。数组中的每一...
多项式加法和乘法C代码
12-14
本文将深入解析一个用C语言编写的多项式加法与乘法程序。该程序主要利用链表结构来表示多项式，并通过栈的方式来处理多项式的运算。程序不仅实现了多项式的加法运算，还实现了乘法运算。 #### 主要功能 1. **多项式...
c语言链表实现多项式相加
05-03
在visual c++6.0环境中 链表 动态链表 多项式相加
C语言版链表合并 多项式
10-16
一元多项式合并 C语言实现 Compiling... shujunjiegou1.cpp E:\程序\shujunjiegou1\shujunjiegou1.cpp(22) : warning C4715: 'compare' : not all control paths return a value Linking...
多项式相乘（C语言实现）
08-22
通过C语言实现多项式的相加，相乘等操作
C语言实现多项式相乘
11-05
编程实现若干个多项式相乘。多项式的输入输出格式为：系数在前，指数在后，各项按指数递增排列，每个多项式输入时以两个0结束。系数为0的项不输出。例如：1+4X3-9X5输入格式为：1 0 0 1 0 2 4 3 0 4 -9 5 0 0或者 1 0 4 3 -9 5 0 0，其输出只能是： 1 0 4 3 -9 5
链表多项式加法与乘法(c语言)
XXXX的博客
12-22 515
Input:(第一个数字表示个数) 4 3 4 -5 2  6 1  -2 0 3 5 20  -7 4  3 1 Output: 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 &lt;stdio.h&gt; #include &lt;std...
多项式加法利用链表实现（c语言）
qq_25573563的博客
01-06 627
#include #include typedef struct _value { int x; int z; }Value; typedef struct _node { Value v; struct _node *next; }Node; void accach(int x,int z,Node **r); int compare(int x,int
多项式的加法链表c语言,（二）单向链表C语言实现和多项式相加
weixin_42398386的博客
05-20 430
typedef struct Node{//系数int coef;//指数int index;struct Node *next;}Node,*pNode;pNode CreateList(int len){pNode head,tail,new;head = (pNode)malloc(sizeof(Node));tail=head;tail->next=NULL;int coef,ind...
用单链表实现多项式乘法 c语言,单链表实现多项式的相乘-c语言
weixin_42356475的博客
05-17 1259
/************************************************************************/目标：多项式的乘法exp: A(X)=2X^3+4B(x)=4X^4+2X^3C(X)=A(x)*B(x)=8X^7+4X^6+16X^4+8X^3思路：1.创建两个链表,用于存储两个多项式 用链式存储 系数域+指数域+指针域2.完成两个多项式的乘法3...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值