java 一元稀疏多项式简单计算器_求一个用java数据结构做的一元稀疏多项式计算器...

最新推荐文章于 2023-06-14 11:07:58 发布
最新推荐文章于 2023-06-14 11:07:58 发布
阅读量311 收藏 4
点赞数
文章标签： java 一元稀疏多项式简单计算器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39632327/article/details/114354886
版权

展开全部

栈的要不要？

---------

class Stack_Float

{

float nums[];

int top;

Stack_Float()

{

nums = new float[50];

top = -1;

}

boolean IsEmpty()

{

if(top == -1)

return true;

else

return false;

}

float Pop_Stack()

{

if(top==-1)

{

return 0;

}

top--;

return nums[top + 1];

}

float GetTop()

{

return nums[top];

}

void Push_Stack(float num)

{

if(top == 49)

return;

top++;

nums[top] = num;

}

}

/*****************************************************************************/

class Stack_Char

{

char str[];

int top;

Stack_Char()

{

str = new char[50];

top = -1;

}

boolean IsEmpty()

{

if(top==-1)

return true;

else

return false;

}

void Push_Stack(char ch)

{

if(top == 49)

return;

top++;

str[top] = ch;

}

char Pop_Stack()

{

if(top == -1)

return '\0';

top--;

return str[top + 1];

}

char GetTop()

{

if(top == -1)

{

System.out.print("error");

System.exit(0);

}

return str[top];

}

}

/*****************************************************************************/

public class jisuanqi extends javax.swing.JFrame

{

String show = "";

public jisuanqi()

{

initComponents();

}

char[] TranSmit(char str[])

{

char houzhui[] = new char[50]; //存放后缀表达62616964757a686964616fe58685e5aeb931333262363637式的字符串

int i = 0,j = 0;

char c = str[i];

Stack_Char s = new Stack_Char(); //存放运算符的栈

while(c != '=') //对算术表达式扫描未结束时

{

if(c >= '0' && c <= '9')

{

while(c >= '0' && c <= '9')//数字直接入栈

{

houzhui[j]=c;

j++;

i++;

c=str[i];

}

houzhui[j]='#';//用#隔开数字

j++;

}

switch(c) //扫描到运算符时

{

case '+':

case '-':

case '*':

case '/':

if(s.IsEmpty() == true) //栈空,直接入栈

{

s.Push_Stack(c);

i++;

c=str[i];

break;

}

if(ComPare(s.GetTop(),c) == -1)

{

s.Push_Stack(c); //入栈

i++;

c=str[i];

break;

}

if(ComPare(s.GetTop(),c) == 1)

{

houzhui[j]=s.Pop_Stack();//出栈元素存入后缀表达式

j++;

break;

}

}

}

while(s.IsEmpty() != true)//把剩余的运算符直接出栈

{

houzhui[j]=s.Pop_Stack();

j++;

}

houzhui[j] = '=';//后缀表达式后面加 =

j++;

houzhui[j] = '\0';

j++;

return houzhui;

}

float Count(char str[])

{

Stack_Float s = new Stack_Float();//定义存放数字的栈

char c = str[0];

int i = 0,j = 0;

float result = 0,temp,left,right;

while(c != '=') //未扫描到 = 时

{

if(c >= '0' && c <= '9')//扫描到数字

{

temp = 0;

while(c != '#')//未读到分隔符时

{

temp = temp * 10 + c - '0';

i++;

c = str[i];

}

s.Push_Stack(temp);//进栈

}

switch(c)//扫描到运算符时

{

case '+':

{

result = s.Pop_Stack() + s.Pop_Stack();//2个数字出栈相加

s.Push_Stack(result);//最后得数进栈

break;

}

case '-':

{

right = s.Pop_Stack();//右操作数出栈

left = s.Pop_Stack();//左操作数出栈

result = left - right;

s.Push_Stack(result);

break;

}

case '*':

{

result = s.Pop_Stack() * s.Pop_Stack();//2个数字出栈相乘

s.Push_Stack(result);

break;

}

case '/':

{

right = s.Pop_Stack();//右操作数出栈

left = s.Pop_Stack();//左操作数出栈

result = left / right;

s.Push_Stack(result);

break;

}

}

i++;

c = str[i];

}

return result;

}

int ComPare(char a,char b) //判断运算符的优先级函数

{

int s[][] =

{// 栈顶元素高于算术表达式中的元素时, 返回 1,否则返回 -1

{1,1,-1,-1},

{1,1,-1,-1},

{1,1,1,1},

{1,1,1,1},

};

char x1[]={'+','-','*','/'};//栈顶元素

char x2[]={'+','-','*','/'};//算术表达式中的元素

int k=0,m,n = 0;

for(m=0;m<4;m++) //查找2个进行比较的运算符在表中的位置,并返回比较结果

{

for(n=0;n<4;n++)

{

if(x1[m]==a&&x2[n]==b)

{

k=1;break; //找到比较结果后,跳出循环

}

}

if(k==1)

break;

}

return s[m][n];//返回比较结果

}

/*****************************************************************************/

@SuppressWarnings("unchecked")

// //GEN-BEGIN:initComponents

private void initComponents() {

text = new javax.swing.JTextField();

jButton1 = new javax.swing.JButton();

jButton2 = new javax.swing.JButton();

jButton3 = new javax.swing.JButton();

jButton4 = new javax.swing.JButton();

jButton5 = new javax.swing.JButton();

jButton6 = new javax.swing.JButton();

jButton7 = new javax.swing.JButton();

jButton8 = new javax.swing.JButton();

jButton9 = new javax.swing.JButton();

jButton10 = new javax.swing.JButton();

jButton11 = new javax.swing.JButton();

jButton12 = new javax.swing.JButton();

jButton13 = new javax.swing.JButton();

jButton14 = new javax.swing.JButton();

jButton21 = new javax.swing.JButton();

jButton22 = new javax.swing.JButton();

setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

getContentPane().setLayout(null);

getContentPane().add(text);

text.setBounds(10, 10, 270, 30);

jButton1.setText("1");

jButton1.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jButton1ActionPerformed(evt);

}

});

getContentPane().add(jButton1);

jButton1.setBounds(10, 50, 60, 25);

jButton2.setText("2");

jButton2.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jButton2ActionPerformed(evt);

}

});

getContentPane().add(jButton2);

jButton2.setBounds(80, 50, 60, 25);

jButton3.setText("3");

jButton3.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jButton3ActionPerformed(evt);

}

});

getContentPane().add(jButton3);

jButton3.setBounds(150, 50, 60, 25);

jButton4.setText("4");

jButton4.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jButton4ActionPerformed(evt);

}

});

getContentPane().add(jButton4);

jButton4.setBounds(220, 50, 60, 25);

jButton5.setText("5");

jButton5.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jButton5ActionPerformed(evt);

}

});

getContentPane().add(jButton5);

jButton5.setBounds(10, 80, 60, 25);

jButton6.setText("6");

jButton6.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jButton6ActionPerformed(evt);

}

});

getContentPane().add(jButton6);

jButton6.setBounds(80, 80, 60, 25);

jButton7.setText("7");

jButton7.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jButton7ActionPerformed(evt);

}

});

getContentPane().add(jButton7);

jButton7.setBounds(150, 80, 60, 25);

jButton8.setText("8");

jButton8.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jButton8ActionPerformed(evt);

}

});

getContentPane().add(jButton8);

jButton8.setBounds(220, 80, 60, 25);

jButton9.setText("9");

jButton9.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jButton9ActionPerformed(evt);

}

});

getContentPane().add(jButton9);

jButton9.setBounds(10, 110, 60, 25);

jButton10.setText("0");

jButton10.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jButton10ActionPerformed(evt);

}

});

getContentPane().add(jButton10);

jButton10.setBounds(80, 110, 60, 25);

jButton11.setText("+");

jButton11.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jButton11ActionPerformed(evt);

}

});

getContentPane().add(jButton11);

jButton11.setBounds(150, 110, 60, 25);

jButton12.setText("-");

jButton12.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jButton12ActionPerformed(evt);

}

});

getContentPane().add(jButton12);

jButton12.setBounds(220, 110, 60, 25);

jButton13.setText("*");

jButton13.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jButton13ActionPerformed(evt);

}

});

getContentPane().add(jButton13);

jButton13.setBounds(10, 140, 60, 25);

jButton14.setText("/");

jButton14.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jButton14ActionPerformed(evt);

}

});

getContentPane().add(jButton14);

jButton14.setBounds(80, 140, 60, 25);

jButton21.setText("CE");

jButton21.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jButton21ActionPerformed(evt);

}

});

getContentPane().add(jButton21);

jButton21.setBounds(150, 140, 60, 25);

jButton22.setText("=");

jButton22.addActionListener(new java.awt.event.ActionListener() {

public void actionPerformed(java.awt.event.ActionEvent evt) {

jButton22ActionPerformed(evt);

}

});

getContentPane().add(jButton22);

jButton22.setBounds(220, 140, 60, 25);

pack();

}// //GEN-END:initComponents

private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton1ActionPerformed

show += "1";

text.setText(show);

}//GEN-LAST:event_jButton1ActionPerformed

private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton2ActionPerformed

show += "2";

text.setText(show);

}//GEN-LAST:event_jButton2ActionPerformed

private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton3ActionPerformed

show += "3";

text.setText(show);

}//GEN-LAST:event_jButton3ActionPerformed

private void jButton4ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton4ActionPerformed

show += "4";

text.setText(show);

}//GEN-LAST:event_jButton4ActionPerformed

private void jButton5ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton5ActionPerformed

show += "5";

text.setText(show);

}//GEN-LAST:event_jButton5ActionPerformed

private void jButton6ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton6ActionPerformed

show += "6";

text.setText(show);

}//GEN-LAST:event_jButton6ActionPerformed

private void jButton7ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton7ActionPerformed

show += "7";

text.setText(show);

}//GEN-LAST:event_jButton7ActionPerformed

private void jButton8ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton8ActionPerformed

show += "8";

text.setText(show);

}//GEN-LAST:event_jButton8ActionPerformed

private void jButton9ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton9ActionPerformed

show += "9";

text.setText(show);

}//GEN-LAST:event_jButton9ActionPerformed

private void jButton10ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton10ActionPerformed

show += "0";

text.setText(show);

}//GEN-LAST:event_jButton10ActionPerformed

private void jButton13ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton13ActionPerformed

show += "*";

text.setText(show);

}//GEN-LAST:event_jButton13ActionPerformed

private void jButton14ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton14ActionPerformed

show += "/";

text.setText(show);

}//GEN-LAST:event_jButton14ActionPerformed

private void jButton21ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton21ActionPerformed

show = "";

text.setText("");

}//GEN-LAST:event_jButton21ActionPerformed

private void jButton22ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton22ActionPerformed

show += "=";

text.setText(show);

char str1[] = new char[50];

char str2[] = new char[50];

float result = 0;

str1 = show.toCharArray();

str2 = TranSmit(str1);

result = Count(str2);

text.setText("" + result);

show = "";

}//GEN-LAST:event_jButton22ActionPerformed

private void jButton12ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton12ActionPerformed

show += "-";

text.setText(show);

}//GEN-LAST:event_jButton12ActionPerformed

private void jButton11ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton11ActionPerformed

show += "+";

text.setText(show);

}//GEN-LAST:event_jButton11ActionPerformed

public static void main(String args[])

{

jisuanqi j = new jisuanqi();

j.setBounds(300, 300, 300, 195);

j.setVisible(true);

}

// Variables declaration - do not modify//GEN-BEGIN:variables

private javax.swing.JButton jButton1;

private javax.swing.JButton jButton10;

private javax.swing.JButton jButton11;

private javax.swing.JButton jButton12;

private javax.swing.JButton jButton13;

private javax.swing.JButton jButton14;

private javax.swing.JButton jButton2;

private javax.swing.JButton jButton21;

private javax.swing.JButton jButton22;

private javax.swing.JButton jButton3;

private javax.swing.JButton jButton4;

private javax.swing.JButton jButton5;

private javax.swing.JButton jButton6;

private javax.swing.JButton jButton7;

private javax.swing.JButton jButton8;

private javax.swing.JButton jButton9;

private javax.swing.JTextField text;

// End of variables declaration//GEN-END:variables

}

本回答由网友推荐

2Q==

已赞过

已踩过<

你对这个回答的评价是？

评论

收起

weixin_39632327
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
一元稀疏多项式计算器
空空
08-21 1137
问题描述： 标题 一元稀疏多项式计算器 时间限制 2S 内存限制 10000 Kb 问题输入 每组数据有3行构成，第1行为3个正整数n，m，t， n表示第一个多项式的项数，m表示第二个多项式的项数，t表示运算类型，0为加法，1为减法，每组数据的第2行包含2n个整数，每两个整数分别表示第一个多项式每一项的系数和指数；第3行包含2m个整数，每两个整数分别表示第二个多项式每一项的系...
一元稀疏多项式计算器（Java）
qq_53801117的博客
12-26 3944
要求: 一元稀疏多项式计算器 【问题描述】 设计一个一元稀疏多项式简单计算器。 【基本要求】一元稀疏多项式简单计算器的基本功能是： (1) 输入并建立多项式 ； (2) 输出多项式，输出形式为整数序列：n，c1，e1，c2，e2，…，cn，en，其中n是多项式的项数，ci 和ei，分别是第 i 项的系数和指数，序列按指数降序排列； (3) 多项式a和b相加，建立多项式a +b； (4) 多项式a和b相减，建立多项式a -b 。 【测试数据】 1)(2x+5x8－3.1x11) + (7－5x8+11x9)=
用java的jni调用C语言的API，实现带图形界面的一元稀疏多项式计算器
红雨瓢泼的博客
01-13 1743
实现步骤： 1) 完成Java代码，编写好Java调用类。 2) 编译你的Java类。 3) 用javah生成编译好的class文件对应的C/C++ 函数的头文件。 4) 实现头文件中的函数原型,编写native代码。 5) 将native代码编译打包成DLL库(win32)或共享库(Linux)。 6) 将你的Java代码跑起来 一、首先在创建一个类In
java 一元稀疏多项式简单计算器,一元稀疏多项式计算器实验报告
weixin_29625757的博客
03-20 1115
一元稀疏多项式计算器实验报告课程名称：数据结构实验名称： 一元稀疏多项式计算器学 院：钱学森学院实 验 日 期 2020年 05 月 08日诚信承诺：我保证本实验报告中的程序和本实验报告是我自己编写，没有抄袭。一、实验目的熟悉课堂上讲过的一元多项式加法数据结构(使用链表)加强C++的基本操作以及STL的使用深入理解类封装，抽象的意义，并在实践中使用二、实验环境...
java 一元稀疏多项式简单计算器_一元稀疏多项式简单的计算器
weixin_30252651的博客
02-19 620
共回答了25个问题采纳率：92%一元稀疏多项式计算器设计程序代码#include#include#include#include#define maxlen 10#define large 999typedef struct Linklistomial{float coef;int expn;struct Linklistomial *next;}Linklistomial,*Linklist;v...
jisuanqi.rar_一元 稀疏多项式 简单 计数_一元 稀疏多项式 简单计算器_简单计算器
09-22
文件“一元稀疏多项式计算器.doc”可能包含了这个计算器的详细设计和实现，包括算法描述、伪代码或者实际的源代码。而“www.pudn.com.txt”可能是下载资源的来源信息，或者是额外的说明文档。 设计这样一个计算器，...
一元稀疏多项式.rar_一元多项式_一元稀疏多项式计算器_多项式计算器_稀疏多项式
07-14
一元稀疏多项式计算器，直接可运行的
基于Java实现的一元稀疏多项式计算器.zip
07-04
通过输入限制确保符合一元稀疏多项式的格式； 通过按钮组选择输出结果：多项式计算结果、在某点的值、多项式的导数(扩展功能)； 多项式的计算功能；多项式的求值功能；多项式的求导功能。 详细介绍参考：...
一元稀疏多项式计算器 数据结构课程设计
06-11
在本课程设计中，主题是“一元稀疏多项式计算器”，这是一项针对数据结构学习者的重要实践任务。数据结构是计算机科学中的基石，它研究如何有效地存储和组织数据，以便于高效地进行访问和操作。在这个项目中，我们将...
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 计算器的仿真界面。
一元稀疏多项式计算器（带界面）
11-18
一元稀疏多项式计算器（带界面），其中含有了加减乘除，求导，赋值的功能，并能在设定的界面上运行。
jisuanqi.rar_1、 一元 多项式 计算_一元稀疏多项式计算器
09-19
一元稀疏多项式计算器的基本功能是： (1)输入并建立多项式； (2)输出多项式，输出形式为整数序列：n,c1,e1,c2,e2,….,cn,en, 其中n是多项式的项数，ci和ei分别是第I项的系数和指数，序列按照指数降序排列； （3）...
基于Java实现的一元稀疏多项式计算器
毕业作品网站
05-24 1138
原因：程序期待的输入内容应为 aX^b（其中 a 为系数 b 为指数）但实际输入过程中会有所省略。应严格限制输入规范，如加减号不应连续贴合出现，每一项中应只出现一个 X，每一项中只能出现一个 ^，结果输入框中只有在 ^ 后面才能添加-，小数点的数量应该严格规范不应在系数或指数部分出现多个小数点导致数值录入失败。TreeMap 进行运算过程，将每一项的指数作为 Key，相同指数的系数加和作为对应的 Value。现象：结果输出文本框中从右开始会使部分字符顺序出现问题，如 “^” “-”。一元稀疏多项式计算器。
一元稀疏多项式运算器（java实现）
最新发布
佳-Mr.L
06-14 348
一个基于java命令行的一元稀疏多项式运算器，实现了多项式的加法，减法，乘法，和导数。
（初学者Java）一元稀疏多项式计算器——Java版
BangLiSang的博客
12-29 2614
一元稀疏多项式计算器——Java版 大二上学期结束了，数据结构老师让我们做一个一元稀疏计算器，网上的很多代码都是C语言的，我写了一个简单的Java版的，功能简陋，就是应付应付作业。 上代码 节点Node类 package internship; //自定义的结点类 public class Node { public Node next; public float coeffici...
设计一个一元稀疏多项式简单的加减法计算器
热门推荐
xueba8的博客
10-24 2万+
问题描述： 设计一个一元稀疏多项式简单的加减法计算器 实现要求： 一元稀疏多项式简单计算器的基本功能是： （1）输入并建立多项式： ； （2）输出多项式 （3）多项式A和B相加，建立多项式C＝A＋B，并输出相加的结果多项式C （4）选作：多项式A和B相减，建立多项式C＝A－B，并输出相加的结果多项式D 方法说明： （1）多项式的输入与存储 用带表头结点的单链表存储多项式，
一元稀疏多项式计算器与最小生成树设计详解
本篇文档是关于《数据结构》课程设计的一个实验报告，主要涉及两个关键部分：一元稀疏多项式计算器的设计和最小生成树问题的求解。报告由蒋林达等同学共同完成，指导教师为刘小晶。 一、问题描述： 1. 一元稀疏...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值