一元多项式的运算 单链表实现

最新推荐文章于 2024-04-26 22:25:06 发布
最新推荐文章于 2024-04-26 22:25:06 发布
阅读量551 收藏 11
点赞数 2
文章标签： 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zjxzjx123456789/article/details/132123310
版权

前言 

        实现将两个多项式相加、相减、相乘。具体代码以及讲解在下方。

1.引入库

  1. stdio.h：提供输入输出操作相关的函数，如printf、scanf等。
  2. stdlib.h：提供内存管理、类型转换、随机数生成等功能，如malloc、free、atoi等。
  3. math.h：提供数学运算相关的函数，如sin、cos、sqrt等。
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

2结构体定义

        数据域包含data和datax，data表示系数，datax表示指数

typedef struct Lnode{
	int data;        //系数
	int datax;        //指数
	struct Lnode* next;
}LNode,*LinkList;

3.链表初始化

        单链表包含头节点，方便后续插入操作 

LinkList InitList(LinkList L){//头结点 
	L=(LinkList)malloc(sizeof(LNode));
	if(L==NULL)
		exit(EXIT_FAILURE);
	L->next=NULL;
	return L;
}

4.读入数据

        读入数据，要实现对输入的数据自行进行排序，即使在输入时指数没有按照由小到大的数据顺序，也能按照由小到大的顺序输出。

        在createList函数中，通过尾插法，将输入的结点添加到已经初始化好的单链表中，并通过LocateElem函数实现对输入的数据进行排序。

         LocateElem函数讲解：

                 L是之前的链表，p是要插入的结点，在while循环中遍历L，分成三种请况

                1.如果p的指数比L的第一项大，则继续向后遍历

                2.如果p的指数与L的某一项相等，则将系数合并，跳出循环，尾指针r不变，因为最下面的if语句不会被执行。

                3.如果p的指数比L的第一项小，则将p插入到L的某一项的前面，尾指针r不变，因为最下面的if语句不会被执行。

        最下面的if语句，只有当p的指数比L中的每一项的指数都大时才会执行。

void createList(LinkList L,int l1){
	int i;
	LinkList p,r=L;//p是要插入的结点，r是尾指针
	for(i=0;i<l1;i++){//尾插法
		p=(LinkList)malloc(sizeof(LNode));
		printf("请输入第%d项的系数和指数(以空格隔开):",i+1);
		scanf("%d%d",&p->data,&p->datax);
		r=LocateElem(L,p,r);
	}
}
LinkList LocateElem(LinkList L,LinkList p,LinkList r){//排序
	LinkList p1=L->next,p2=L;//p2为p1的前一项
	while(p1){
		if(p->datax>p1->datax){
			p1=p1->next;
			p2=p2->next;
		}
		else if(p->datax==p1->datax){
			p1->data=p1->data+p->data;
			break;
		}
		else{
			p2->next=p;
			p->next=p1;
			break;
		}
	}
	if(!p1){    //p1==NULL
		p->next=NULL;
		r->next=p;
		r=p;
		return r;
	}
}

5.相加操作

        为保证相加后的多相似依旧有序，需对相加的两项进行判断，分为三种情况。

         从第一项开始，如果L1的指数小于L2的指数 ，则将L1的第一项添加到L3中，L1指向它的下一项，L2不动。

        如果L1的指数等于L2的指数，则将这两项合并后添加到L3中，L1和L2都指向下一项。

        如果L1的指数大于L2的指数 ，则将L2的第一项添加到L3中，L2指向它的下一项，L1不动。

        直到L1或L2完全遍历完为止，然后将L1或L2中没有遍历完的部分（较长的）添加L3中。

void AdditionList(LinkList L1,LinkList L2,LinkList L3){
	LinkList p=L1->next,q=L2->next,s,sr=L3;
	while(p&&q){
		s=(LinkList)malloc(sizeof(LNode)); 
		if(p->datax<q->datax){//L1的指数比L2小 
			s->data=p->data;
			s->datax=p->datax;
			s->next=NULL;
			sr->next=s;
			sr=s;
			p=p->next; 
		}
		else if(p->datax==q->datax){//L1的指数和L2相等
			s->data=p->data+q->data;
			s->datax=p->datax;
			s->next=NULL;
			sr->next=s;
			sr=s;
			p=p->next;
			q=q->next; 
		}
		else{//L1的指数比L2大 
			s->data=q->data;
			s->datax=q->datax;
			s->next=NULL;
			sr->next=s;
			sr=s;
			q=q->next; 
		}
	}
	if(p){
		s->next=p;
	}
	else{
		s->next=q; 
	}
}

6.相减操作

        相减操作和相加操作的算法一样，只不过在相减操作中需要先将第二个多项式的系数变成负的，再进行操作。

         此时会产生一个问题，就是L2中data域的值全都取负了，在执行时如果先进行了相减操作，会使之后进行的相加相乘操作产生错误。

void SubtractList(LinkList L1,LinkList L2,LinkList L4){
	LinkList p=L1->next,q=L2->next,s,sr=L4;
	while(q){//找负 
		q->data=0-(q->data);
		q=q->next;
	}
	q=L2->next;
	while(p&&q){
		s=(LinkList)malloc(sizeof(LNode)); 
		if(p->datax<q->datax){//L1的指数比L2小 
			s->data=p->data;
			s->datax=p->datax;
			s->next=NULL;
			sr->next=s;
			sr=s;
			p=p->next; 
		}
		else if(p->datax==q->datax){//L1的指数和L2相等
			s->data=p->data+q->data;
			s->datax=p->datax;
			s->next=NULL;
			sr->next=s;
			sr=s;
			p=p->next;
			q=q->next; 
		}
		else{//L1的指数比L2大 
			s->data=q->data;
			s->datax=q->datax;
			s->next=NULL;
			sr->next=s;
			sr=s;
			q=q->next; 
		}
	}
	if(p){
		s->next=p;
	}
	else{
		s->next=q; 
	}
}

7.相乘操作

        f(x1)=2X^2+3X^3,f(x2)= 3X^2+4X^3

         对于上面两个多项式，相乘时，结果多项式会有三项而非四项。因有两项发生了合并。结局办法是将第一个多项式的第一项拿出来，依次和第二个多项式的每一项相乘，此时的操作和读入数据是完全相同的。

void multiplyList(LinkList L1,LinkList L2,LinkList L5){
	LinkList p=L1->next,q=L2->next,r=L5,p1;
	for(;p;){
		for(;q;){
			p1=(LinkList)malloc(sizeof(LNode));
			p1->data=p->data*q->data;
			p1->datax=p->datax+q->datax;
            r=LocateElem(L5,p1,r);
			q=q->next;
		}
		p=p->next;
		q=L2->next;
	}
}

8.打印多项式

void printfList(LinkList L,int j){
	LinkList p=L->next;
	if(j==3){
		printf("和多项式为：P(X)=");
	} 
	else if(j==4){
		printf("差多项式为：P(X)=");
	}
	else if(j==5){
		printf("积多项式为：P(X)=");
	}
	else{
		printf("第%d个多项式为：P(X)=",j);
	}
	while(p){
		if(p->data!=0){
			printf("%dX^%d",p->data,p->datax);
			p=p->next;
			if(p!=NULL){//不是最后一项
				if(p->data>=0){//系数是整数
				printf("+");
				}
			}
		} 
		else if(p->data==0&&p->next==NULL){//首项为0，且只有一项
			printf("0");
			p=p->next;
		}
		else{
			p=p->next;	
		}
	}
	printf("\n");	
}

9.多项式带值计算

void Sum(LinkList L,int x){
	int i=0;
	LinkList p=L->next; 
	while(p){
		i+=p->data*pow(x,p->datax);
		p=p->next;
	}
	printf("结果为：%d\n",i);
}

10.销毁单链表

void Destory(LinkList* L){
	LinkList p;
	while(*L){
		p=*L;
		*L=(*L)->next; 
		free(p);
	}
}

11.菜单

void menu(){
	printf( "*******************************************************\n");
	printf( "****************    1.输入1   相加  *******************\n");
	printf( "****************    2.输入2   相减  *******************\n");
	printf( "****************    3.输入3   相乘  *******************\n");
	printf( "****************    4.输入4   退出	 *******************\n");
	printf( "*******************************************************\n");
}

12.主函数

int main(int argc, char *argv[])
{
	char p,c;
	int l1,l2,x,y;
	LinkList L1,L2,L3,L4,L5;
	L1=InitList(L1);//第一个多项式
	L2=InitList(L2);//第二个多项式
	L3=InitList(L3);//相加后的多项式
	L4=InitList(L4);//相减后的多项式
	L5=InitList(L5);//相乘后的多项式
	printf("请输入第一个多项式的项数:");
	scanf("%d",&l1);
	createList(L1,l1);
	printfList(L1,1);
	printf("请输入第二个多项式的项数:");
	scanf("%d",&l2);
	createList(L2,l2);
	printfList(L2,2);
	menu();
	while ((c = getchar()) != '\n' && c != EOF){
	 // 清空输入缓冲区中的其他字符
	}
	printf("请输入要进行的操作序号："); 
 	while(scanf("%d",&y)){
	 	if(y==4){
	 		printf("再见\n");
	 		Destory(&L1);
			Destory(&L2);
			Destory(&L3);
			Destory(&L4);
			Destory(&L5);
			return 0;	
	 	}
	 	switch(y){
	 		case 1:
	 			AdditionList(L1,L2,L3);//相加 
				printfList(L3,3);
				printf("是否带入X求结果？(是:Y,否:N):");
				scanf(" %c",&p);
				if(p=='Y'||p=='y'){
					printf("请输入X的值:");
					scanf("%d",&x);
					Sum(L3,x);
				}
				printf("请输入要进行的操作序号：");
	 			break;
	 		case 2:
		 		SubtractList(L1,L2,L4);//相减 
				printfList(L4,4);
				printf("是否带入X求结果？(是:Y,否:N):");
				scanf(" %c",&p);
				if(p=='Y'||p=='y'){
					printf("请输入X的值:");
					scanf("%d",&x);
					Sum(L4,x);
				}
				printf("请输入要进行的操作序号：");
	 			break;
			case 3:
				multiplyList(L1,L2,L5);//相乘 
				printfList(L5,5);
				printf("是否带入X求结果？(是:Y,否:N):");
				scanf(" %c",&p);
				if(p=='Y'||p=='y'){
					printf("请输入X的值:");
					scanf("%d",&x);
					Sum(L5,x);
				}
				printf("请输入要进行的操作序号：");
		 		break;
	 		default:
	 			printf("输入有误请重新输入\n");
			 	printf("请输入要进行的操作序号：");
	 			break;
		}
	 }
}

运行示例

。木可。
关注
  • 2
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
单链表实现的多项式运算.cpp
03-25
输入多项式A的项数及各项的系数和指数，多项式B的项数及各项的系数和指数。建立两个多项式，按照指数降序输出多项式。注意对系数为负数的情况进行处理。程序结构要清晰。数据结构的定义和函数的声明写在头文件(.h)中，函数的实现写在源文件(.c或.cpp)中。以菜单的形式展示各种运算的操作。利用单链表的数据结构，在读取数据时就按指数次方排序好，再加法的运算中可以直接按指数的大小进行运算，相比随机的读入数据，这个方法优化了程序。乘法则是在加法的基础上把每一项的系数进行相乘并最后求和。注意指数相乘时x指数是相加的。
数据结构一元多项式的相加-单链表实现
weixin_46341264的博客
10-18 4937
数据结构单链表实现一元多项式的相加
【单链表】一元多项式求和(C++)
半生瓜のblog
10-22 1506
一元多项式求和要求&&实现流程代码实现 要求&&实现流程 代码实现 #include<iostream> using namespace std; typedef struct LinkNode { int cofe;//系数 int exp;//次方 struct LinkNode* next; }LinkList,LinkNode; //初始化链表 void initLinkList(LinkList*& L) { L = new
单链表实现一元多项相加
qq_62343171的博客
03-20 1229
Code: #include <iostream> #include <stdio.h> #include <malloc.h> using namespace std; const int N = 100010; typedef int Status; typedef struct LNode { int expn; int coef; struct LNode *next; } LNode, *LinkList; void Init_LinkLis
C++利用单链表实现一元多项式的加、乘操作
henry594xiaoli的博客
04-24 3940
C++利用单链表实现一元多项式的加、乘操作，提示：一元多项式中的数据项含有两个数据分别是系数与指数，为了简单起见，系数与指数都为整数。
（数据结构与算法）一元多项式求和---单链表的应用
07-16
（数据结构与算法）一元多项式求和---单链表的应用 http://blog.csdn.net/eeeduo/article/details/37877677
利用单链表实现一元多项式的表示及相加
热门推荐
qq_18677011的博客
03-06 1万+
第一个博客
单链表应用------一元多项式
weixin_44034024的博客
03-04 1251
【问题描述】编写一个程序用单链表存储多项式，并实现两个一元多项式A与B相加的函数。A，B刚开始是升序的，A与B之和按降序排列。例如： 多项式A: 1.2X^0 2.5X^1 3.2X^3 -2.5X^5 多项式B: -1.2X^0 2.5X^1 3.2X^3 2.5X^5 5.4X^10 多项式A与B之和：5.4X^10 6.4X^3 5X^1 【输入形式】任意两个多项式...
(第3种)用单链表存储一元多项式，并实现两个多项式相加运算
王陈锋的博客
10-08 1875
本次代码是纯c语言版本的 #include<stdio.h> #include<stdlib.h> typedef struct//定义存放多项式的数组类型 { double coef;//系数 int exp;//指数 }narray[10]; typedef struct pnode//定义单链表节点类型 { double coef; int exp; struct pnode *next; }Node,*LinkList; int i; LinkList cre
PAT 一元多项式的乘法与加法运算(链表 c++版)
weixin_30337251的博客
09-09 360
题目按照指数递减的顺序给出两个一元多项式，输出两个多项式的乘积，还有 和 ，按照指数递减的顺序。 用链表实现一元多项式的乘法与加法运算。 首先来看加法运算 多项式 poly1 x^4 + 3x^3 + 6x 多项式 poly2 6x^5 + 4x^4 + 6 既然用到链表，自然少不了结构体 struct node{ int coef; //系数 int expn...
一元多项式的除法
10-12
数据结构中的一元多项式的除法，用单向链表实现，也涉及到一元多项式的加法等等。
用单链表实现任意两个一元多项式的加、减法运算
04-21
编程实现以下功能： ①分别输入一元多项式pn (x)和Q n (x)。 从键盘输入一元对项式中各项的系数和...⑦由程序从所存文件中读出多项式的系数和指数，重新构建一元多项式 Pn (x) 和Q n (x)，并可对其再次进行运算操作。
一元多项式运算
11-04
以线性表来描述一元多项式，存储结构采用单链表，每个结点存储多项式中某一项的系数和指数，建立单链表时指数低的结点列于指数高的结点之后，即线性表的元素按指数递减有序排列。在多项式求和运算时，将指数相同的项...
数据结构(C语言)用单链表存储一元多项式并实现两个多项式的相加运算.doc
07-14
数据结构(C语言)用单链表存储一元多项式并实现两个多项式的相加运算.doc
一元稀疏多项式运算代码
12-20
设计程序，输入两个一元稀疏多项式， 分别完成二者的加法、减法、乘法运算，输出和多项式、差多项式、乘积... 1、分别以顺序表和单链表为存储结构实现多项式的加法和减法运算。 2、乘法运算的实现使用单链表为存储结构
从递归角度串联二叉树-图论-动态规划
qwertyasdfghh的博客
04-26 413
先不管所谓前中后序，单看traverse函数，你说它在做什么事情？
c++图论基础(1)
2301_79249663的博客
04-26 381
图是由顶点集合(简称点集)和顶点间的边(简称边集)组成的数据结构，通常用G(V,E)表示用G=(V,E);表示一个图结构 V是点集，E是边集有向边——>有向图 无向边——>无向图点集V(G)={1,2,3,4,5,6},边集E(G)={(1,2),{1,5},{2,3},{2,6},{5,6}}
【算法基础实验】图论-UnionFind连通性检测之quick-find
Greyplayground
04-26 1119
Union-Find 是解决连通性问题的一种非常高效的数据结构。它能够快速合并集合并快速判断元素之间的连通性。通过路径压缩和按秩合并的优化，Union-Find 在实际应用中可以接近常数时间完成操作。因此，它在算法竞赛、网络连接和社交网络分析等领域有广泛的应用。
【算法基础实验】图论-UnionFind连通性检测之quick-union
最新发布
Greyplayground
04-26 923
Union-Find 是解决连通性问题的一种非常高效的数据结构。它能够快速合并集合并快速判断元素之间的连通性。通过路径压缩和按秩合并的优化，Union-Find 在实际应用中可以接近常数时间完成操作。因此，它在算法竞赛、网络连接和社交网络分析等领域有广泛的应用。
java基于单链表存储结构的一元多项式求和运算
06-02
Java基于单链表存储结构的一元多项式求和运算可以通过以下步骤实现： 1. 定义一个节点类，包含三个属性：系数(coefficient)、指数(exponent)和下一个节点(next)的地址。 2. 定义一个单链表类，包含一个头节点(head)。 3. 创建两个一元多项式的单链表对象，分别存储两个多项式。 4. 对两个多项式的单链表进行遍历，将同一指数的项相加，并将结果存入一个新的单链表中。 5. 返回结果单链表对象。 具体实现可以参考以下Java代码： ``` public class Node { public double coefficient; // 系数 public int exponent; // 指数 public Node next; // 下一个节点的地址 public Node(double coefficient, int exponent) { this.coefficient = coefficient; this.exponent = exponent; this.next = null; } } public class LinkedList { public Node head; // 头节点 public LinkedList() { this.head = new Node(0, 0); // 创建头节点 } // 添加节点 public void addNode(double coefficient, int exponent) { Node node = new Node(coefficient, exponent); Node p = head; while (p.next != null && p.next.exponent > exponent) { p = p.next; } if (p.next != null && p.next.exponent == exponent) { p.next.coefficient += coefficient; } else { node.next = p.next; p.next = node; } } // 多项式求和 public LinkedList add(LinkedList list) { LinkedList result = new LinkedList(); Node p1 = this.head.next; Node p2 = list.head.next; while (p1 != null && p2 != null) { if (p1.exponent > p2.exponent) { result.addNode(p1.coefficient, p1.exponent); p1 = p1.next; } else if (p1.exponent < p2.exponent) { result.addNode(p2.coefficient, p2.exponent); p2 = p2.next; } else { double coefficient = p1.coefficient + p2.coefficient; if (coefficient != 0) { result.addNode(coefficient, p1.exponent); } p1 = p1.next; p2 = p2.next; } } while (p1 != null) { result.addNode(p1.coefficient, p1.exponent); p1 = p1.next; } while (p2 != null) { result.addNode(p2.coefficient, p2.exponent); p2 = p2.next; } return result; } } ``` 使用时，可以先创建两个多项式的单链表对象，然后调用add方法求和，最后遍历结果单链表输出即可。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值