多项式加减乘求导（链表）（如果多项式不是升序的处理就太恶心了，所以是升序的，我就是这么懒。。。）

最新推荐文章于 2023-07-19 23:09:17 发布
最新推荐文章于 2023-07-19 23:09:17 发布
阅读量501 收藏 2
点赞数
分类专栏： 数据结构与算法分析（java）
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chinmint/article/details/52919845
版权
这个方法里面，用的那个AddPoly的用法可以get下，实验课老师写的太没有实用性了 
package polynolist;
public class polynolist {
	public Node head;
	public Node tail;
	public Node pointer;
	
	public polynolist( )
	{	
	  head=new Node();
	 tail=head;
	}	
	
	public void PrintList()
	
	{
	  pointer=head.next();
	  while(pointer.getCoeff()==0)
		  pointer=pointer.next();
	  if((pointer.getCoeff()==1)&&(pointer.getExpon()==1)) System.out.print("x");
	  if((pointer.getCoeff()==1)&&(pointer.getExpon()==0)) System.out.print(pointer.getCoeff());
	  if((pointer.getCoeff()==1)&&(pointer.getExpon()>1)) System.out.print("x^"+pointer.getExpon());
	  if((pointer.getCoeff()>1)&&(pointer.getExpon()==1)) System.out.print(pointer.getCoeff()+"x");
	  if((pointer.getCoeff()>1)&&(pointer.getExpon()==0)) System.out.print(pointer.getCoeff());
	  if((pointer.getCoeff()>1)&&(pointer.getExpon()>1)) System.out.print(pointer.getCoeff()+"x^"+pointer.getExpon());
	  if((pointer.getCoeff()==-1)&&(pointer.getExpon()==1)) System.out.print("-x");
	  if((pointer.getCoeff()==-1)&&(pointer.getExpon()==0)) System.out.print(pointer.getCoeff());
	  if((pointer.getCoeff()==-1)&&(pointer.getExpon()>1)) System.out.print("-x^"+pointer.getExpon());
	  if((pointer.getCoeff()<-1)&&(pointer.getExpon()==1)) System.out.print(pointer.getCoeff()+"x");
	  if((pointer.getCoeff()<-1)&&(pointer.getExpon()==0)) System.out.print(pointer.getCoeff());
	  if((pointer.getCoeff()<-1)&&(pointer.getExpon()>1)) System.out.print(pointer.getCoeff()+"x^"+pointer.getExpon());
	  pointer=pointer.next();
	  while(pointer!=null)
	  {   
		 
	  if((pointer.getCoeff()==1)&&(pointer.getExpon()==1)) System.out.print("+"+"x");
	  if((pointer.getCoeff()==1)&&(pointer.getExpon()==0)) System.out.print("+"+pointer.getCoeff());
	  if((pointer.getCoeff()==1)&&(pointer.getExpon()>1)) System.out.print("+"+"x^"+pointer.getExpon());
	  if((pointer.getCoeff()>1)&&(pointer.getExpon()==1)) System.out.print("+"+pointer.getCoeff()+"x");
	  if((pointer.getCoeff()>1)&&(pointer.getExpon()==0)) System.out.print("+"+pointer.getCoeff());
	  if((pointer.getCoeff()>1)&&(pointer.getExpon()>1)) System.out.print("+"+pointer.getCoeff()+"x^"+pointer.getExpon());
	  if((pointer.getCoeff()==-1)&&(pointer.getExpon()==1)) System.out.print("-x");
	  if((pointer.getCoeff()==-1)&&(pointer.getExpon()==0)) System.out.print(pointer.getCoeff());
	  if((pointer.getCoeff()==-1)&&(pointer.getExpon()>1)) System.out.print("-x^"+pointer.getExpon());
	  if((pointer.getCoeff()<-1)&&(pointer.getExpon()==1)) System.out.print(pointer.getCoeff()+"x");
	  if((pointer.getCoeff()<-1)&&(pointer.getExpon()==0)) System.out.print(pointer.getCoeff());
	  if((pointer.getCoeff()<-1)&&(pointer.getExpon()>1)) System.out.print(pointer.getCoeff()+"x^"+pointer.getExpon());
	  pointer=pointer.next();
	  }
	  System.out.println();
	 
	}
	public void AddPoly(int coeff,int expon)
	{
	 Node node=new Node(coeff,expon);
	 tail.LinkList(node);
	 tail=node;
	}
	
  public void PolyBigExpon()
  {
	  System.out.println(tail.getExpon());
  }
	//多项式加法
   public void PolyAdd(polynolist blist)
   {  
	  polynolist result=new polynolist();
	  Node apointer=head.next();
	  Node bpointer=blist.head.next();
	  while(apointer!=null&&bpointer!=null)
	  {  
		  if(apointer.getExpon()==bpointer.getExpon())
		  {
			  int a=apointer.getCoeff()+bpointer.getCoeff();
			  if(a!=0)
			  {
				  result.AddPoly(a, apointer.getExpon());
				  apointer=apointer.next();
				  bpointer=bpointer.next();
			  }
		  }
		  else if(apointer.getExpon()<bpointer.getExpon())
		  {
		    result.AddPoly(apointer.getCoeff(), apointer.getExpon());
		    apointer=apointer.next;
		  }
		  else if(apointer.getExpon()>bpointer.getExpon())
		  {
			  result.AddPoly(bpointer.getCoeff(), bpointer.getExpon());
			  bpointer=bpointer.next();
		  }
	  }
	  while(apointer!=null)
	  {
		  result.AddPoly(apointer.getCoeff(), apointer.getExpon());
		  apointer=apointer.next();
	  }
	  while(bpointer!=null)
	  {
		  result.AddPoly(bpointer.getCoeff(), bpointer.getExpon());
		  bpointer=bpointer.next();
	  }
	  result.PrintList();
   }
   //多项式减法
   public void PolyMin(polynolist blist)
   {  
	  polynolist result=new polynolist();
	  Node apointer=head.next();
	  Node bpointer=blist.head.next();
	  while(apointer!=null&&bpointer!=null)
	  {   
		  if(apointer.getExpon()==bpointer.getExpon())
		  {
			  int a=apointer.getCoeff()-bpointer.getCoeff();
			  if(a!=0)
			  {
				  result.AddPoly(a, apointer.getExpon());
				  apointer=apointer.next();
				  bpointer=bpointer.next();
			  }
			  else
			  {
				  apointer=apointer.next();
				  bpointer=bpointer.next();
			  }
		  }
		  else if(apointer.getExpon()<bpointer.getExpon())
		  {
		    result.AddPoly(apointer.getCoeff(), apointer.getExpon());
		    apointer=apointer.next;
		  }
		  else if(apointer.getExpon()>bpointer.getExpon())
		  {
			  result.AddPoly(-bpointer.getCoeff(), bpointer.getExpon());
			  bpointer=bpointer.next();
		  }
	  }
	  while(apointer!=null)
	  {
		  result.AddPoly(apointer.getCoeff(), apointer.getExpon());
		  apointer=apointer.next();
	  }
	  while(bpointer!=null)
	  {
		  result.AddPoly(-bpointer.getCoeff(), bpointer.getExpon());
		  bpointer=bpointer.next();
	  }
	  result.PrintList();
   }
   //多项式求导
   public void PolyDiff()
   {
	 polynolist result=new polynolist();
	 Node pointer=head.next();
	 while(pointer!=null)
	 {
	 result.AddPoly(pointer.getCoeff()*pointer.getExpon(), pointer.getExpon()-1);
	 pointer=pointer.next();
	 }
	 result.PrintList();
   }
   //多项式乘法
   public void PolyMulti(polynolist list)
   {
	  polynolist result=new polynolist();
	  Node apointer=head.next();
	  int rcurrent=1;
	  while(apointer!=null)
	  {
		  Node bpointer=list.head.next();
		  while(bpointer!=null)
		  {
			  int co=apointer.getCoeff()*bpointer.getCoeff();
			  int ex=apointer.getExpon()+bpointer.getExpon();
			  Node rpointer=result.head;
			  Node r=rpointer;
			  if(rcurrent==1)
			  {
				  result.AddPoly(co, ex);
				  rcurrent++;
			  }
			  else
			 {
		      boolean check=false;
			  while(rpointer!=null)
			  {  
				  if(ex==rpointer.getExpon())
				  {
					check=true;
				    rpointer.setCoeff(rpointer.getCoeff()+co);
				    break;
				  }
				  else if(ex>rpointer.getExpon())
				  {
					 r=rpointer;
					 rpointer=rpointer.next(); 
				  }
				  else if(ex<rpointer.getExpon())
				  {   
					  check=true;
					  Node node=new Node(co,ex);
					  node.LinkList(rpointer);
					  r.LinkList(node);
				  }
				  
			  }
			  if(check==false) result.AddPoly(co, ex);
			 }
			  bpointer=bpointer.next();
		  }
			 apointer=apointer.next();
	  }
	  result.PrintList();
   }
   
}
 class Node{
	public Node next;
	public int  coeff;
	public int  expon;
	
	public Node()
	{
		
	}
	public Node(int coeff,int expon)
	{
		this.coeff=coeff;
		this.expon=expon;
	}
	public Node next()
	{
		return this.next=next;
	}
	public int getCoeff()
	{
		return this.coeff;
	}
	public int getExpon()
	{
		return this.expon;
	}
	public void LinkList(Node node)
	{
		this.next=node;
	}
	public void setCoeff(int coeff)
	{
		this.coeff=coeff;
	}
	public void setExpon(int expon)
	{
		this.expon=expon;
	}
}


package polynolist;
import java.util.Scanner;

public class polylisttest {
	public static void main(String[] args)
	{
		Scanner input=new Scanner (System.in);
		int coeff,expon;
		//输入第一个多项式链表
		System.out.println("请输入第一个多项式的长度");
		int n=input.nextInt();
		System.out.println("请输入第一个多项式");
		polynolist alist=new polynolist();
		for(int i=0;i<n;i++)
		{
		 coeff=input.nextInt();
		 expon=input.nextInt();
		 alist.AddPoly(coeff, expon);
		}
		//输入第二个多项式
		System.out.println("请输入第二个多项式的长度");
		int m=input.nextInt();
		System.out.println("请输入第二个多项式");
		polynolist blist=new polynolist();
		for(int i=0;i<m;i++)
		{
			coeff=input.nextInt();
			expon=input.nextInt();
			blist.AddPoly(coeff, expon);
		}
		//两个多项式的最高次项
		System.out.println("alist的最高次项：");
		alist.PolyBigExpon();
		System.out.println("blist的最高次项：");
		blist.PolyBigExpon();
		
		//两个多项式的加法：
		System.out.println("两个多项式的加法：");
		alist.PolyAdd(blist);
		//两个多项式的减法
		System.out.println("两个多项式的减法：");
		alist.PolyMin(blist);
		//两个多项式的乘积
		System.out.println("两个多项式的乘积为：");
		alist.PolyMulti(blist);
		//两个多项式的求导
		System.out.println("两个多项式的求导：");
		alist.PolyDiff();
		blist.PolyDiff();
	}
}
运行结果：
请输入第一个多项式的长度
4
请输入第一个多项式
2 0
3 1
4 2
5 3
请输入第二个多项式的长度
5
请输入第二个多项式
6 0
5 1
4 2
3 3
2 4
alist的最高次项：
3
blist的最高次项：
4
两个多项式的加法：
8+8x+8x^2+8x^3+2x^4
两个多项式的减法：
-4-2x+2x^3-2x^4
两个多项式的乘积为：
12+28x+47x^2+68x^3+54x^4+38x^5+23x^6+10x^7
两个多项式的求导：
3+8x+15x^2
5+8x+9x^2+8x^3

ChinMint
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
saa.zip_多项式 加减_多项式 链表
09-19
多项式的加减乘法的链表实现的程序在C++中
[MATLAB]多项式求导/加减/乘除
执念斩长河
03-20 1万+
多项式计算 roots ployval MATLAB
5.2 matlab多项式计算（多项式的四则运算、求导、求值、求根）
onlyfanlala的博客
12-09 8863
1、多项式的表示 在MATLAB中创建多项式向量时，注意三点: (1)多项式系数向量的顺序是从高到低。 (2)多项式系数向量包含0次项系数，所以其长度为多项式最高次数加1。 (3）如果有的项没有，系数向量相应位置应用0补足。 2、多项式的四则运算 (1)多项式的加减运算 多项式的加减运算非常简单，即相应向量相加减。 (2)多项式乘法 conv (P1,P2):多项式相乘函数。 在这里，P1、P2是两个多项式系数向量。 (3）多项式除法 [Q,r]=deconv(P1,P2):多项式相除函数。 其中，Q返.
16matlab数据分析 多项式的求导（matlab程序）
m0_57943157的博客
07-19 1030
多项式的求导polyder( ):多项式求导函数。调用格式:( 1 ) p=polyder( P):求多项式P的导函数。( 2 ) p=polyder(P,Q):求P·Q的导函数。( 3 ) [p,q]=polyder(P,Q):求P/Q的导函数，导函数的分子存入p，分母存入q。
多项式的加减乘及求导（数组）
ChinMint的博客
10-30 4133
大体的思路就是在加减的时候开一个新的数组，然后新的数组是以指数的大小来排列的，将得到数存到新数组对应指数的位置上（当然数组是二维的） 不过要注意：在乘的时候是指数相加不是指数相乘 啊啊啊啊，我一定是傻了。 package polynomial1; import java.util.Scanner; public class polynomialarray { public stat
基于循环链表的一元多项式的求值、加减乘法、求导、求积分运算
weixin_30725467的博客
04-01 580
·~~~记两年前的一次数据结构大作业 一、题目选择 对课本上第二章的关于求多项式和的例题产生了比较浓厚的兴趣，并思考能否拓展对多项式的运算应用，于是又开辟出一些创新的运算，并尝试不同的算法（主要是对乘法运算，有的不太成功），最终确定了加法、减法、乘法、赋值求结果、求导、求不定积分、求定积分、插入单项等功能，并不断地简化步骤，使过程清晰易懂。 二、需求分析...
C语言：一元多项式加减法运算（链表 附答案）.docx
10-26
C语言链表的入门题，里面提供了两种思路供参考，用链表来实现一元多项式的加减法，并按照一定规律输出。也是练习链表和排序算法的一道小实验，初学链表的小伙伴可以参考参考噢
一元多项式的运算（加减乘）终极版
12-02
实现了一元多项式的加减乘的运算。我们使用计算机处理的对象之间通常存在着的是一种最简单的线性关系，这类数学模型可称为线性的数据结构。而数据存储结构有两种：顺序存储结构和链式存储结构。线性表是最常用且最...
链表实现多项式的加减及求导运算
11-03
C语言下链表实现多项式的加减及求导运算。
一元多项式加减乘运算
07-12
数据结构上机作业，一元多项式的加减乘运算，双向链表实现
一元多项式求导、相加、相乘
10-24
本程序是用C语言实现了一元多项式一元多项式求导、相加和相乘。
C++/C使用数据结构实现多项式的相加相减求导和正序输出逆序输出（可以保存到文件和从文件读取）
GSY码的博客
07-01 790
** 数据结构实现多项式的一些操作时，使用链表来实现，直接上代码。 ** 代码里面有备注 #include #include <stdio.h> #include <stdlib.h> using namespace std; //多项式的一项结构体 struct Node{ int index;//一元多项式的指数 int coefficient;//一元多项式的系数 ...
数据结构一元多项式求导链表_应用实例-多项式加法运算
weixin_39836860的博客
12-04 230
[TOC]一、引言二、多项式加法运算2.1 算法思路更新、更全的《数据结构与算法》的更新网站，更有python、go、人工智能教学等着你：数据结构与算法 - 咸鱼Chen - 博客园​www.cnblogs.com一、引言主要思路：相同指数的项系数相加，其余部分进行拷贝。二、多项式加法运算采用不带头结点的单向链表，按照指数递减的顺序排列各项。/* c语言实现 */ 2.1 算法思路两个指针P1和...
用链表实现一元多项式的加、减、乘、求导运算
defs6497的博客
09-09 1503
　　在数据结构线性表的链表学习中有一个很有趣的题目：计算两个多项式的加、减、乘和多项式的导数。 　　题目不难，将多项式的系数和指数存进链表，然后进行相应操作即可。 　　一、加法： 　　　　１、判断指数是否相等，若相等则将系数相加，相加后不为零就开辟新空间，将新的系数存入结点，尾插进新链表中。 　　　　２、如果表达式１的指数小于表达式２的指数，就将表达式１的该结点数据复制进...
用链表实现一元多项式加减、求导（Java）
Coder
04-12 1424
Lnode.java package PloyItem; /** *@Author wzy *@Date 2017年11月12日 *@Version JDK 1.8 *@Description */ public class Lnode implements Comparable&lt;Lnode&gt;,Cloneable{ public double coef; ...
C语言数据结构之一元多项式的求导
weixin_30369041的博客
09-23 1360
//一元多项式的求导 #include<stdio.h> #include<malloc.h>//动态申请空间的函数的头文件 typedef struct node //定义节点类型 { float coef; //多项式的系数 int expn; //多项式的指数 struct node * next; /...
数据结构与算法实验：实验二 链表实现一元多项式的加法/减法/乘法/求导
Spidy_harker的博客
03-28 1296
#include <iostream> #include <cstdio> #include <string> #include <cstring> using namespace std; int *create(int x,int y) { int *a; a=new int[2]; a[0]=x,a[1]=y; ...
大二上期数据结构实验记录（二）【初版】C实现简单一元多项式加减乘求导及代值计算（有借鉴删改）
cyannxc的博客
11-03 1037
想要记录自己编程思维的成长所以发到博客，欢迎并且感激大家指出缺点和错误！ 一、【实验构思（Conceive）】 本次实验要求是用C或C++语言设计并实现一个一元稀疏多项式的简单计算器，要求是要有如下功能 1、输入并建立多项式 2、输出多项式，序列按指数降序排列 3、多项式A(x)和B(x)相加，并建立多项式A(x)+B(x) 4、多项式A(x)和B(x)相减，并建立多项式A(x)-B(x) 5、给...
数据结构：求两个多项式的相加运算
热门推荐
Rivival_S 的博客
10-22 1万+
目的：掌握线性表的应用和有序单链表的二路归并算法设计。 内容：编写一个程序exp2-9.cpp，用单链表储存一元多项式，并实现 两个多项式的相加运算   #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; typedef struct LNode { int data; struct LNode* next; } LinkNode; ...
一元多项式加减乘用链表
最新发布
12-20
以下是使用链表实现一元多项式的加减乘的示例代码： ```c #include #include // 定义多项式的节点结构 typedef struct Node { int coef; // 系数 int exp; // 指数 struct Node* next; // 指向下一个节点的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值