多项式计算器 java_链表一元多项式计算器的实现(Java语言描述)

最新推荐文章于 2022-12-29 20:15:29 发布
最新推荐文章于 2022-12-29 20:15:29 发布
阅读量171 收藏 1
点赞数
文章标签： 多项式计算器 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39917291/article/details/114067929
版权
这篇博客介绍了一个用Java编写的用于计算一元多项式的程序，包括加法、减法和乘法运算，并实现了链表的逆置。代码中定义了PolyNode节点类和PolyList链表类，提供了插入、打印多项式、合并同类项等功能。此外，博主还指出代码中存在一些问题，如处理系数为0的情况、空指针错误等，并给出了部分解决方案。
摘要由CSDN通过智能技术生成

链表的经典应用，程序在多项式相加同类项合并还有小的瑕疵，有待改进。

代码如下：

package 一元多项式计算器;

public class PolyNode {

private double a;

private int i;

PolyNode next;

public PolyNode(double a,int i){

this.a=a;

this.i=i;

this.next=null;

}

public PolyNode(){

this(0,0);

}

public double getA() {

return a;

}

public int getI() {

return i;

}

public void setA(double a) {

this.a = a;

}

public void setI(int i) {

this.i = i;

}

}

package 一元多项式计算器;

public class PolyList {

PolyNode head;

PolyNode current;

public PolyList(){

head=new PolyNode();

current=head;

head.next=null;

}

//是否为空

public boolean isEmpty(){

return head.next==null;

}

//这里只考虑按顺序插入元素

public void insert(PolyNode node){

current.next=node;

current=node;

}

//打印多项式

public String printS(){

StringBuilder s=new StringBuilder("");

StringBuilder a=new StringBuilder("");

StringBuilder i=new StringBuilder("");

StringBuilder theOne=new StringBuilder("");

current=head.next;

int count1=0;

int count2=0;

while(current!=null){

if(current.getA() == 0){

count1++;

}

count2++;

current = current.next;

}

if(count1 == count2){

s.append("0");

}else{

current=head.next;

while(current!=null){

a.delete(0, a.length());

i.delete(0, i.length());

theOne.delete(0, theOne.length());

if((current.getA()==1 || current.getA()==-1) && current.getI()!=0)

a.append("");

else if(current.getA() < 0){

a.append(String.valueOf((-current.getA())));

}else{

a.append(String.valueOf(current.getA()));

}

if(current.getI()==1)

{

i.append("");

theOne.append(a.toString()).append("x").append(i.toString());

} else if(current.getI()==0){

i.append("");

theOne.append(a.toString());

} else{

i.append(String.valueOf(current.getI()));

theOne.append(a.toString()).append("x^").append(i.toString());

}

if(current.getA() == 0){

s.append("");

}else{

if(current==head.next && current.getA()<0){

s.append("-").append(theOne.toString());

}else if(current==head.next && current.getA()>0){

s.append(theOne.toString());

}

else if(current.getA() < 0){

s.append(" - ").append(theOne.toString());

}else

s.append(" + ").append(theOne.toString());

}

current = current.next;

}

}

return s.toString();

}

//加法运算

public static PolyList add(PolyList p1,PolyList p2){

PolyList result=new PolyList();

//分别指向p1 p2的第一个元素

p1.current=p1.head.next;

p2.current=p2.head.next;

while(p1.current!=null && p2.current!=null){

if(p1.current.getI()==p2.current.getI()){

result.insert(new PolyNode(p1.current.getA()+p2.current.getA(),p1.current.getI()));

p1.current=p1.current.next;

p2.current=p2.current.next;

}

else if(p1.current.getI()

result.insert(p1.current);

p1.current=p1.current.next;

}else{

result.insert(p2.current);

p2.current=p2.current.next;

}

}

while(p1.current!=null){

result.insert(p1.current);

p1.current=p1.current.next;

}

while(p2.current!=null){

result.insert(p2.current);

p2.current=p2.current.next;

}

//return result;

result.current=result.head.next;

PolyNode tempPrevious=result.current;

PolyNode temp=result.current.next;

while(result.current.next!=null){

while(temp!=null)

{

if(temp.getI()!=result.current.getI())

{

temp=temp.next;

tempPrevious=tempPrevious.next;

}else{

result.current.setA(result.current.getA()+temp.getA());

tempPrevious.next=temp.next;

temp=temp.next;

}

}

result.current=result.current.next;

tempPrevious=result.current;

temp=result.current.next;

}

return result;

}

//减法运算

public static PolyList sub(PolyList p1,PolyList p2){

PolyList result=new PolyList();

p2.current = p2.head.next;

while(p2.current!=null){

p2.current.setA(-(p2.current.getA()));

p2.current=p2.current.next;

}

//System.out.println(p2.printS());

//分别指向p1 p2的第一个元素

p1.current=p1.head.next;

p2.current=p2.head.next;

while(p1.current!=null && p2.current!=null){

if(p1.current.getI()==p2.current.getI()){

result.insert(new PolyNode(p1.current.getA()+p2.current.getA(),p1.current.getI()));

p1.current=p1.current.next;

p2.current=p2.current.next;

}

else if(p1.current.getI()

result.insert(p1.current);

p1.current=p1.current.next;

}else{

result.insert(p2.current);

p2.current=p2.current.next;

}

}

while(p1.current!=null){

result.insert(p1.current);

p1.current=p1.current.next;

}

while(p2.current!=null){

result.insert(p2.current);

p2.current=p2.current.next;

}

return result;

}

//乘法运算

public static PolyList multiply(PolyList p1,PolyList p2){

PolyList result=new PolyList();

//分别指向p1 p2的第一个元素

p1.current=p1.head.next;

p2.current=p2.head.next;

while(p1.current!=null){

while(p2.current!=null)

{

double a=p1.current.getA()*p2.current.getA();

int i=p1.current.getI()+p2.current.getI();

result.insert(new PolyNode(a,i));

p2.current=p2.current.next;

}

p1.current=p1.current.next;

p2.current=p2.head.next;

}

//合并同类项

result.current=result.head.next;

PolyNode tempPrevious=result.current;

PolyNode temp=result.current.next;

PolyNode t = result.current.next;

while(result.current.next!=null){

while(temp!=null)

{

if(temp.getI()!=result.current.getI())

{

temp=temp.next;

tempPrevious=tempPrevious.next;

}else{

result.current.setA(result.current.getA()+temp.getA());

tempPrevious.next=temp.next;

temp=temp.next;

}

}

result.current=result.current.next;

tempPrevious=result.current;

temp=result.current.next;

}

return result;

}

//就地逆置单链表

public static void reverse(PolyList p_){

PolyNode p,q;

p = p_.head.next;

p_.head.next = null;

while(p!=null){

q = p.next;

p.next = p_.head.next;//让p.next变成p_.head.next;

p_.head.next = p;//让p_.head.next变成p;

p = q;//让p变成q;

}

}

}

package 一元多项式计算器;

import java.util.*;

public class Testclass {

public static void main(String[] args) {

// TODO Auto-generated method stub

while(true){

PolyList p1 = new PolyList();

PolyList p2 = new PolyList();

Scanner scan = new Scanner(System.in);

System.out.print("请输入要计算的第一个多项式的系数和指数，以0,0结束：");

double a = scan.nextDouble();

int i = scan.nextInt();

while(a!=0 || i!=0){

p1.insert(new PolyNode(a,i));

a = scan.nextDouble();

i = scan.nextInt();

}

System.out.println("您输入的第一个多项式为：");

System.out.println("p1 = " + p1.printS());

System.out.print("请输入要计算的第二个多项式的系数和指数，以0,0结束：");

a = scan.nextDouble();

i = scan.nextInt();

while(a!=0 || i!=0){

p2.insert(new PolyNode(a,i));

a = scan.nextDouble();

i = scan.nextInt();

}

System.out.println("您输入的第二个多项式为：");

System.out.println("p2 = " + p2.printS());

System.out.println("请按提示选择您想要进行的运算：");

System.out.println("0 -----> +");

System.out.println("1 -----> -");

System.out.println("2 -----> x");

int n;

n = scan.nextInt();

if(n == 0){

PolyList resultList= PolyList.add(p1, p2);

PolyList.reverse(resultList);

System.out.println("p1 + p2 = "+resultList.printS());

}else if(n == 1){

PolyList resultList= PolyList.sub(p1, p2);

PolyList.reverse(resultList);

System.out.println("p1 - p2 = "+resultList.printS());

}else{

PolyList resultList= PolyList.multiply(p1, p2);

//PolyList.reverse(resultList);

System.out.println("p1 x p2 = "+resultList.printS());

}

}

}

}

//还存在的bug：1-当系数为0的时候应该删去一整项； 已解决！

// 2-当一个多项式只有0时，应该输出一个0；已解决！

// 3-计算器的仿真界面。已解决！使用不方便！

// 4-合并同类项有空指针错误，待解决，错误数据如1 1 1 1 0 0+1 1 1 1 0 0；

https://www.cnblogs.com/wxisme/category/670207.html

weixin_39917291
关注
java 一元稀疏多项式简单计算器
08-25
该资源包括1.0、1.1和1.2三个版本。需求分析：1 输入并建立多项式；2输出多项式，输出形式为整数序列：n,c1,e1, c2,e2,,,,,,, cn,en,其中n是多项式的项数，ci,ei,分别是第i项的系数和指数，序列按指数降序排序；3 多项式a和b相加，建立多项式a+b；4 多项式a和b相减，建立多项式a-b；5计算多项式在x处的值。6 计算器的仿真界面。
链表一元多项式计算器的实现(Java语言描述)
weixin_33857679的博客
10-14 435
链表的经典应用，程序在多项式相加同类项合并还有小的瑕疵，有待改进。 代码如下： package 一元多项式计算器; public class PolyNode { private double a; private int i; PolyNode next; public PolyNode(double a,int i){ ...
用Java编写一元稀疏多项式计算器
weixin_35749545的博客
12-29 145
好的，首先你需要定义一个类来表示一元稀疏多项式的节点，这个节点应该至少包含两个属性：指数和系数。指数表示多项式中的指数，系数表示多项式中的系数。 接下来你可以使用链表来存储多项式的各个节点，这样就可以方便地在多项式中插入或删除节点。 然后你需要编写多项式的加法运算，可以通过遍历两个多项式的节点并比较它们的指数，来实现多项式的加法运算。如果两个多项式的节点指数相同，则将它们的系数相加，并将结果放入结...
（初学者Java）一元稀疏多项式计算器——Java版
BangLiSang的博客
12-29 2680
一元稀疏多项式计算器——Java版 大二上学期结束了，数据结构老师让我们做一个一元稀疏计算器，网上的很多代码都是C语言的，我写了一个简单的Java版的，功能简陋，就是应付应付作业。 上代码 节点Node类 package internship; //自定义的结点类 public class Node { public Node next; public float coeffici...
jisuanqi.rar_一元 稀疏多项式 简单 计数_一元 稀疏多项式 简单计算器_简单计算器
09-22
文件“一元稀疏多项式计算器.doc”可能包含了这个计算器的详细设计和实现，包括算法描述、伪代码或者实际的源代码。而“www.pudn.com.txt”可能是下载资源的来源信息，或者是额外的说明文档。 设计这样一个计算器，...
一元稀疏多项式计算器
03-23
总之，“一元稀疏多项式计算器”结合了MFC的可视化能力与链表数据结构的优势，实现了高效、直观的多项式运算。这个项目不仅展示了面向对象编程的技巧，还涉及到了数据结构、算法和用户交互等多个计算机科学的关键...
计算器_多项式计算器_
10-03
总结来说，“计算器_多项式计算器_”是一个利用栈数据结构实现的能够处理多项式加减乘除的程序。通过理解栈的工作原理以及多项式的表示方法，我们可以设计出高效且准确的算法来执行这些计算。在实际编程中，还需要...
C语言-一元稀疏多项式计算器
最新发布
03-27
本项目“C语言-一元稀疏多项式计算器”专注于利用C语言来处理一元稀疏多项式运算，包括加法、减法、乘法和除法。在本文中，我们将详细探讨这一主题，以及如何用C语言实现这些功能。 一元稀疏多项式是指多项式中大...
c一元稀疏多项式计算器-课程设计实验报告.pdf
10-30
【课程设计概述】 本次课程设计的目标是开发...通过这个一元稀疏多项式计算器的设计与实现，学生不仅掌握了数据结构的实际应用，也锻炼了编程技能和问题解决能力，这对于未来从事IT行业的职业生涯有着重要的铺垫作用。
java 实现多项式的运算
11-25
java 语言的算法，包含源代码，用链表实现的多项式运算
一个一元多项式简单的计算器
02-23
一元多项式计算器的基本功能定为 (1) 建立多项式 (2) 输出多项式 (3) 两个多项式相加，建立并输出和多项式 (4) 两个多项式相减，建立并输出差多项式 实现提示：可选择带头结点的单向循环链表 或单链表存储多项式，头结点可存放多项式 的参数，如项数等。 希望对大家有帮助，我们都加油吧。
高精度加减计算（链表）
05-12
运用双向链表进行高精度计算，加减，乘除在完善中。
java 一元稀疏多项式简单计算器,一元稀疏多项式计算器
weixin_39715652的博客
03-20 392
P(x)，Q(x)分别为两个一元稀疏多项式计算器，利用单链表存储。实现相加，相减，就地逆置两者之差。#include#include#define OK 1#define ERROR 0typedef struct term{float coef;//系数int expn;//次方struct term *next;}Position;typedef struct{Position *head;P...
Java,C实现约瑟夫环，一元多项式运算器
printfxgd的博客
09-20 252
1 约瑟夫环问题描述：（初始密码为m） 约瑟夫环问题是循环链表的经典应用：具体描述如下：n 个人围成一个圆圈，首先第 1 个人从 1 开始一个人一个人顺时针报数，报到第 m 个人，令其出列。然后再从下一 个人开始从 1 顺时针报数，报到第 m 个人，再令其出列，…，如此下去，求出列顺序。 使用C实现 #include&lt;stdio.h&gt; #include&lt;stdlib.h&...
java实现计算器_Java 实现简单计算器
weixin_34861192的博客
02-12 4375
最后一次更新于2019/07/08效果演示图功能与流程要制作一个简易计算器，首先你要清楚GUI里要显示什么：结果显示框0～9的数字删除功能清楚功能搜寻历史记录功能计算结果的功能括号优先计算功能接下来通过流程图简单介绍一下思路：GUI 源码以下代码是根据我的设计来编写的/*** @author Hephaest* @since 2018/04/19* JDK 1.6*/import java.aw...
Java | 链表栈实现综合计算器（中缀表达式）
Oh_MyBug的博客
03-18 470
栈（Stack）的理解 /* * 栈（Stack） * 1. 栈是先入后出（FILO-First In Last Out）的有序列表。 * 2. 栈是限制线性表中元素的插入和删除只能在线性表的同一端进行的一个特殊线性表。 * 允许插入和删除的一段，为变化的一端，称为栈顶（Top），另一端为固定的一端，称为栈底（Bottom） * 3. 根据栈的定义可知，最先放入栈中元素在栈...
[java数据结构与算法-链表（万金油LinkedList）]
weixin_53061888的博客
01-18 827
链表一.链表1.链表定义2.动态链表3.单链表3.1代码实现3.1.1结点定义3.1.2链表的成员变量定义3.1.3将一个数组转换为链表。3.1.4添加元素3.1.5删除元素3.1.6通过角标查看元素和修改元素 一.链表 1.链表定义 链表是一种递归的数据结构，它或者为空（null），或者是指向一个结点的引用，该节点含有一个泛型的元素和一个指向另一条链表的引用。 在这个定义中，结点是一个可能含有任意类型数据类型的抽象实体，它所包含的指向结点的应用显示了它在构造构造链表中的用处。 2.动态链表 为了表示每个数
一元多项式计算器Java_数据结构实验：一元多项式计算器（C++ 实现）
weixin_42449583的博客
02-26 274
1 //----- List.h -----2 #ifndef LINKEDLIST3 #define LINKEDLIST45 #include 6 #include "Elem.h"78 using namespacestd;91011 classList12 {13 protected:14 classNode15 {16 public:17 //------...
一元稀疏多项式计算器的实现与算法
本文主要介绍了如何设计和实现一个一元多项式计算器，其核心功能包括处理一元稀疏多项式的加减运算。首先，我们需要理解一元多项式的基本概念，它是由常数、变量及变量的各次幂组成，如\( ax^n + bx^{n-1} + ... + ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值