实验项目一 支持算数表达式求解的计算器

于 2022-10-20 20:27:54 发布
阅读量104 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57888607/article/details/127433436
版权

一.实验要求

        1.能通过设计的按钮控件输入并实现算术表达式，表达式在文本框中显示，运算结果输出显示；保存和浏览历史运算记录；

        2.能够检验算术表达式的合法性；

        3.能够实现混合运算的求解，算术表达式中包含加、减、乘、除、括号等运算符；

        4.要求交互界面友好，程序健壮。

    二.运算规则：

     先乘除，后加减，从左到右计算，先括号内，后括号外；

      中缀表达式     A+(B-C/D)*E        

      后缀表达式     ABCD/-E*+   

三.算法思想

单栈

（1）利用一个字符可变序列postQueue和操作符栈（opStack）将键盘输入的中缀表达式转换为后缀表达式。其中，postQueue存放后缀表达式的结果，操作符栈（opStack）用于存储运算符。

算法思想：
        把中缀表达式当作一个字符串，表达式从左到右一个个字符判断，规则如下：

        ① 如果是数字，直接存进postQueue。

        ② 如果字符加减乘除和左括号：

                A.栈为空，直接将操作符入栈；
                B.假设现在的操作符是c,栈顶的操作符是s
                        a. 若c的优先级大于s，直接入栈；
                        b.若c的优先级小于s，将栈顶操作符弹出到postQueue,知道栈顶元素s优先级低于c或栈为空。弹出完这些元素后，再将c压入到栈中；
                        c.若栈顶元素是(,则直接入栈；
        ③如果字符是) 右括号，则依次将栈顶元素添加进postQueue，直到遇到左括号，左括号不加进postQueue，直接丢弃。
        ④字符判断完了之后，如果栈不为空，则依次输出栈的元素到postQueue。

（2）利用栈来进行后缀表达式值的求解，此栈用于存放计算的中间过程和最终结果。

算法思想：
        把后缀表达式看作是一个字符串，然后从左到右一个一个字符进行判断，规则如下：

        ①如果是数字，直接进栈。

        ②如果是+或*，则弹出栈顶两个元素，进行相加或相乘，将计算结果压入栈中。

        ③ 如果是-或/，则先弹出一个数字为x，再弹出一个数字为y，然后y-x或y/x，最后将计算结果压入栈中。

（3）输出计算结果。
四.源代码

package com.company;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Objects;
import javax.swing.*;

//Calculator类，继承JFrame框架，实现事件监听器接口
class Calculator extends JFrame implements ActionListener {
    private final String[] KEYS = { "7", "8", "9", "C", "4", "5", "6", "+", "1", "2", "3", "-", "0", "*", "%", "/", "(", ")", ".", "=" };
    private JButton keys[] = new JButton[KEYS.length];
    private JTextArea resultText = new JTextArea("0");// 文本域组件TextArea可容纳多行文本；文本框内容初始值设为0.0
    private JTextArea History = new JTextArea();// 历史记录文本框初始值设为空
    private JPanel jp2=new JPanel();
    private JScrollPane gdt1=new JScrollPane(resultText);//给输入显示屏文本域新建一个垂直滚动滑条
    private JScrollPane gdt2=new JScrollPane(History);//给历史记录文本域新建一个垂直滚动滑条
    // private JScrollPane gdt3=new JScrollPane(History);//给历史记录文本域新建一个水平滚动滑条
    private JLabel label = new JLabel("历史记录");
    private String b = "";
    int flash=0;
    int flash2=0;
    int flash3=0;

    // 构造方法
    public Calculator() {
        super("简易计算器");//“超”关键字，表示调用父类的构造函数，
        resultText.setBounds(20, 18, 255, 115);// 设置文本框大小
        resultText.setAlignmentX(RIGHT_ALIGNMENT);// 文本框内容右对齐
        resultText.setEditable(false);// 文本框不允许修改结果
        History.setBounds(290, 40, 250,370);// 设置文本框大小
        History.setAlignmentX(LEFT_ALIGNMENT);// 文本框内容右对齐
        History.setEditable(false);// 文本框不允许修改结果
        label.setBounds(300, 15, 100, 20);//设置标签位置及大小
        jp2.setBounds(290,40,250,370);//设置面板窗口位置及大小
        jp2.setLayout(new GridLayout());
        JPanel jp1 = new JPanel();
        jp1.setBounds(20,18,255,115);//设置面板窗口位置及大小
        jp1.setLayout(new GridLayout());
        resultText.setLineWrap(true);// 激活自动换行功能
        resultText.setWrapStyleWord(true);// 激活断行不断字功能
        resultText.setSelectedTextColor(Color.RED);
        History.setLineWrap(true);//自动换行
        History.setWrapStyleWord(true);
        History.setSelectedTextColor(Color.blue);
        gdt1.setViewportView(resultText);//使滚动条显示出来
        gdt2.setViewportView(History);
        gdt1.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);//设置让垂直滚动条一直显示
        gdt2.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);//设置让垂直滚动条一直显示
        gdt2.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);//设置让水平滚动条一直显示
        jp1.add(gdt1);//将滚动条添加入面板窗口中
        jp2.add(gdt2);
        this.add(jp1);//将面板添加到总窗体中
        this.add(jp2);//将面板添加到总窗体中
        this.setLayout(null);
        this.add(label);// 新建“历史记录”标签
        //this.add(resultText);// 新建文本框，该语句会添加进去一个新的JTextArea导致带有滚动条的文本无法显示或者发生覆盖
        //this.add(History);// 新建历史记录文本框，该语句会添加进去一个新的JTextArea导致带有滚动条的文本无法显示

        // 放置按钮
        int x = 20, y = 150;
        for (int i = 0; i < KEYS.length; i++)
        {
            keys[i] = new JButton();
            keys[i].setText(KEYS[i]);
            keys[i].setBounds(x, y, 60, 50);
            if (x < 215) {
                x += 65;
            } else {
                x = 20;
                y += 53;
            }
            this.add(keys[i]);
        }
        for (int i = 0; i < KEYS.length; i++)// 每个按钮都注册事件监听器
        {
            keys[i].addActionListener(this);
        }
        this.setResizable(false);
        this.setBounds(500, 200, 567, 480);
        this.setDefaultCloseOperation(EXIT_ON_CLOSE);
        this.setVisible(true);
    }
    // 事件处理
    public void actionPerformed(ActionEvent e)
    {
        //History.setText(b);//使输入的表达式显示在历史记录文本框中
        String label=e.getActionCommand();//获得事件源的标签int flash=1;
        if(Objects.equals(label, "="))//
        {
            resultText.setText(this.b);
            History.setText(History.getText()+resultText.getText());
            if(label.equals("="))//调用计算方法，得出最终结果
            {
                String[] s =houzhui(this.b);
                String result=Result(s);
                this.b=result+"";
                //更新文本框，当前结果在字符串b中，并未删除，下一次输入接着此结果以实现连续运算
                resultText.setText(this.b);
                History.setText(History.getText()+"="+resultText.getText()+"\n");
            }
        }
        else if(Objects.equals(label, "C"))//清空按钮，消除显示屏文本框前面所有的输入和结果
        {
            this.b="";
            resultText.setText("0");//更新文本域的显示，显示初始值;
            flash=0;
        }
        else if(label.equals("+")){
            if(b.charAt(b.length()-1)!='+'&&b.charAt(b.length()-1)!='-'&&b.charAt(b.length()-1)!='*'&&b.charAt(b.length()-1)!='/'&&b.charAt(b.length()-1)!='('&&b.charAt(b.length()-1)!='.'&&b.charAt(b.length()-1)!='%'){
                this.b = this.b + label;
                resultText.setText(this.b);
                flash=1;
            }
        }
        else if(label.equals("-")){
            if(b.charAt(b.length()-1)!='-'&&b.charAt(b.length()-1)!='+'&&b.charAt(b.length()-1)!='*'&&b.charAt(b.length()-1)!='/'&&b.charAt(b.length()-1)!='.'&&b.charAt(b.length()-1)!='%') {
                this.b = this.b + label;
                resultText.setText(this.b);
                flash=1;
            }
        }else if(label.equals("*")){
            if(b.charAt(b.length()-1)!='*'&&b.charAt(b.length()-1)!='-'&&b.charAt(b.length()-1)!='+'&&b.charAt(b.length()-1)!='/'&&b.charAt(b.length()-1)!='('&&b.charAt(b.length()-1)!='.'&&b.charAt(b.length()-1)!='%') {
                this.b = this.b + label;
                resultText.setText(this.b);
                flash=1;
            }
        }else if(label.equals("/")){
            if(b.charAt(b.length()-1)!='/'&&b.charAt(b.length()-1)!='-'&&b.charAt(b.length()-1)!='*'&&b.charAt(b.length()-1)!='+'&&b.charAt(b.length()-1)!='('&&b.charAt(b.length()-1)!='.'&&b.charAt(b.length()-1)!='%') {
                this.b = this.b + label;
                resultText.setText(this.b);
                flash=1;
            }
        }
        else if(label.equals("%")){
            if(b.charAt(b.length()-1)!='*'&&b.charAt(b.length()-1)!='-'&&b.charAt(b.length()-1)!='+'&&b.charAt(b.length()-1)!='/'&&b.charAt(b.length()-1)!='('&&b.charAt(b.length()-1)!='.'&&b.charAt(b.length()-1)!='%'){
                this.b=this.b+label;
                resultText.setText(this.b);
                flash=1;
            }
        }
        else if(label.equals(".")){
            if (flash==0){
                this.b=this.b+label;
                resultText.setText(this.b);
                flash=1;
            }
        }
        else if(label.equals("(")) {
            flash2++;
            if (b.charAt(b.length()-1)!=')'&&b.charAt(b.length()-1)!='1'&&b.charAt(b.length()-1)!='2'&&b.charAt(b.length()-1)!='3'&&b.charAt(b.length()-1)!='4'&&b.charAt(b.length()-1)!='5'&&b.charAt(b.length()-1)!='6'&&b.charAt(b.length()-1)!='7'&&b.charAt(b.length()-1)!='8'&&b.charAt(b.length()-1)!='9'&&b.charAt(b.length()-1)!='0'&&b.charAt(b.length()-1)!='.'&&b.charAt(b.length()-1)!=')'&&b.charAt(b.length()-1)!='%') {
                this.b = this.b + label;
                resultText.setText(this.b);
            }
        }
        else if(label.equals(")")) {
            flash3++;
            if (b.charAt(b.length()-1)!=' '&&b.charAt(b.length()-1)!='.'&&b.charAt(b.length()-1)!='-'&&b.charAt(b.length()-1)!='*'&&b.charAt(b.length()-1)!='/'&&b.charAt(b.length()-1)!='('&&b.charAt(b.length()-1)!='+'&&b.charAt(b.length()-1)!='('&&flash3<=flash2) {
                this.b = this.b + label;
                resultText.setText(this.b);
            }
        }
        else
        {   if(label.equals("+")||label.equals("-")||label.equals("*")||label.equals("/"))flash=0;
            this.b=this.b+label;
            resultText.setText(this.b);
            // History.setText(History.getText()+this.b);
        }
        //History.setText(History.getText()+this.b);//使输入的表达式显示在历史记录文本框中
    }
    //将中缀表达式转换为后缀表达式
    private String[] houzhui(String str) {
        String s = "";// 用于承接多位数的字符串
        char[] opStack = new char[100];// 静态栈,对用户输入的操作符进行处理，用于存储运算符
        String[] postQueue = new String[100];// 后缀表达式字符串数组，为了将多位数存储为独立的字符串
        int top = -1, j = 0;// 静态指针top,控制变量j
        for(int i=0;i<str.length();i++){
            if(str.charAt(i)=='('&&str.charAt(i+1)=='-'){//将"(-"变为”（0-“
                str=str.substring(0,i+1)+"0"+str.substring(i+1);
            }
        }
        for (int i = 0; i < str.length(); i++)// 遍历中缀表达式
        // indexof函数，返回字串首次出现的位置；charAt函数返回index位置处的字符；
        {
            if ("0123456789.".indexOf(str.charAt(i)) >= 0) // 遇到数字字符的情况直接入队
            {
                s = "";// 作为承接字符，每次开始时都要清空
                for (; i < str.length() && "0123456789.".indexOf(str.charAt(i)) >= 0; i++) {
                    s = s + str.charAt(i);
                    //比如，中缀表达式：234+4*2，我们扫描这个字符串的时候，s的作用相当于用来存储长度为3个字符的操作数：234
                }
                i--;
                postQueue[j] = s;// 数字字符直接加入后缀表达式
                j++;
            }
            else if ("(".indexOf(str.charAt(i)) >= 0) {// 遇到左括号
                top++;
                opStack[top] = str.charAt(i);// 左括号入栈
            }
            else if (")".indexOf(str.charAt(i)) >= 0) {// 遇到右括号
                for (;;)// 栈顶元素循环出栈，直到遇到左括号为止
                {
                    if (opStack[top] != '(') {// 栈顶元素不是左括号
                        postQueue[j] = opStack[top] + "";// 栈顶元素出栈
                        j++;
                        top--;
                    } else { // 找到栈顶元素是左括号
                        top--;// 删除栈顶左括号
                        break;// 循环结束
                    }
                }
            }
            else if ("*%/+-".indexOf(str.charAt(i)) >= 0)// 遇到运算符
            {
                if (top == -1)
                {// 若栈为空则直接入栈
                    top++;
                    opStack[top] = str.charAt(i);
                }
                else if ("*%/".indexOf(opStack[top]) >= 0)
                {// 当栈顶元素为高优先级运算符时,让栈顶元素出栈进入后缀表达式后,当前运算符再入栈
                    postQueue[j] = opStack[top] + "";
                    j++;
                    opStack[top] = str.charAt(i);
                }
                else
                {
                    top++;
                    opStack[top] = str.charAt(i);// 当前元素入栈
                }
            }
        }
        while (top != -1) {// 遍历结束后将栈中剩余元素依次出栈进入后缀表达式
            postQueue[j] = opStack[top] + "";
            j++;
            top--;
        }
        return postQueue;
    }
    // 计算后缀表达式，并返回最终结果
    public String Result(String[] str) {
        String[] Result = new String[100];// 顺序存储的栈，数据类型为字符串
        int Top = -1;// 静态指针Top
        for (int i = 0; str[i] != null; i++) {
            if ("+-*%/".indexOf(str[i]) < 0) {  //遇到数字，直接入栈
                Top++;
                Result[Top] = str[i];
            }
            if ("+-*%/".indexOf(str[i]) >= 0)// 遇到运算符字符，将栈顶两个元素出栈计算并将结果返回栈顶
            {
                double x, y, n;
                x = Double.parseDouble(Result[Top]);// 顺序出栈两个数字字符串，并转换为double类型
                Top--;
                y = Double.parseDouble(Result[Top]);
                Top--;
                if ("*".indexOf(str[i]) >= 0) {
                    n = y * x;
                    Top++;
                    Result[Top] = String.valueOf(n);// 将运算结果重新入栈

                }
                if ("/".indexOf(str[i]) >= 0)
                {
                    if (x == 0)// 被除数不允许为0
                    {
                        String s = "error!";
                        return s;
                    } else {
                        n = y / x;
                        Top++;
                        Result[Top] = String.valueOf(n);// 将运算结果重新入栈
                    }
                }
                if ("%".indexOf(str[i]) >= 0)
                {
                    if (x == 0)// 被除数不允许为0
                    {
                        String s = "error!";
                        return s;
                    } else {
                        n = y % x;
                        Top++;
                        Result[Top] = String.valueOf(n);// 将运算结果重新入栈
                    }
                }
                if ("-".indexOf(str[i]) >= 0) {
                    n = y - x;
                    Top++;
                    Result[Top] = String.valueOf(n);// 将运算结果重新入栈
                }
                if ("+".indexOf(str[i]) >= 0) {
                    n = y + x;
                    Top++;
                    Result[Top] = String.valueOf(n);// 将运算结果重新入栈
                }
            }
        }
        return Result[Top];// 返回最终结果
    }
    // 主函数
    public static void main(String[] args) {

        Calculator a = new Calculator();
    }
}
m0_57888607
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
实验一支持算数表达式求解的计算器
weixin_45986866的博客
11-25 255
实验一支持算数表达式求解的计算器
实验项目一 支持算术表达式的计算器（代码）
Anna_beller的博客
12-25 338
import re def md(l, x): a = l.index(x) if x == '*' and l[a + 1] != '-': k = float(l[a - 1]) * float(l[a + 1]) elif x == '/' and l[a + 1] != '-': k = float(l[a - 1]) / float(l[a + 1]) elif x == '*' and l[a + 1] == '-': .
实验项目一：支持算数表达式求解的计算器源代码
qq_58364169的博客
12-28 297
run： from calculator import * import tkinter import tkinter as TK from turtle import back # 主窗口 root = TK.Tk() root.title("Calculator") root.resizable(0, 0) root.geometry('280x500') result = TK.StringVar() # 用来显示结果的可变文本 equation = TK.StringVar() #
C++实现计算器（功能完善）
jimu41的博客
05-07 1万+
说明： 支持带括号的表达式； 支持±*/ (加减乘除）基本运算； 支持^(指数)运算； 输入格式及结果： 代码： //支持带括号的表达式,支持+-*/、^(指数) #include <iostream> #include <stack> #include <math.h> using namespace std; double inStack(); //核心函数，将操作符有序的入栈计算， 最后返回结果 void calculate(stack<char&
哈工大数据结构作业-算数表达式求值
11-29
在哈工大的数据结构课程中，学生被分配了一项作业，任务是实现一个算数表达式求值的程序。这个程序不仅需要处理基本的算数运算，如加法、减法、乘法和除法，还要扩展到处理小数计算以及涉及变量的计算。这个项目旨在...
表达式的求解，可以是多位数和小数
12-07
#include using namespace std; const int MAX_SIZE = 100; //堆栈类 template class Stack { private: Type list[MAX_SIZE]; int top;//标记 public: Stack(); void Push(const Type & a);...
算术表达式的求解（数据结构）
07-04
设计一个模拟计算器的程序，要求能对包含加、减、乘、除、括号运算符及SQR和ABS函数的任意整型表达式进行求解。 要求：要检查有关运算的条件，并对错误的条件产生报警。
java数学表达式计算程序设计报告
11-12
此项目中的计算器允许用户直接输入数学表达式，无需转换，可以立即得到运算结果。 4. 知识点：GUI 设计 图形用户界面（GUI）设计是项目的重要组成部分。在这里，使用了 Java 的 Swing 库来创建界面，例如 JFrame ...
栈的应用 括号匹配，计算器，中缀表达式转换为后缀表达式
06-18
在IT领域，栈的应用广泛且实用，特别是在处理括号匹配、计算器运算以及中缀表达式转后缀表达式的问题上。 1. **括号匹配**： 在编程语言中，括号（如圆括号"()"、方括号"[]"和大括号"{}"）用于定义代码块或表达式...
面向对象版表达式计算器之完整源码分享
04-20
面向对象版表达式计算器的实现，见网络上资源较少，特整理处来以供大家学习，共享。
如何利用计算机求函数解析式,数据结构表达式求值(计算器)实验报告(共10篇).doc...
weixin_39918248的博客
06-25 664
数据结构表达式求值(计算器)实验报告(共10篇)数据结构表达式求值(计算器)实验报告(共10篇)数据结构课程设计_实验报告(一)表达式求值(计算器)数据结构课程设计 实验报告起止时间：2015.12.28-2015.12.31附件：(程序源代码)#includestdio.h#includestdlib.h#includestring.h#includemath.h#define N 100#de...
实验1：支持算术表达式求解的计算器
qq_54606867的博客
12-27 369
1、 项目概述 1.1 项目目标和主要内容 实现一个计算器软件。 能通过设计的按钮控件输入并实现算术表达式，表达式在文本框中显示，运算结果输出显示；保存和浏览历史运算记录； 能够检验算术表达式的合法性； 能够实现混合运算的求解，算术表达式中包括加、减、乘、除、括号等运算符； 要求交互界面友好，程序健壮。 简述本项目实现的主要内容和目标，使用的开发平台，采用的主要工具。 1.2 项目的主要功能 检验算术表达式的合法性； 能够实现混合运算的求解，算术表达式中包括加、减、乘、除、括号等运算符； 运算结果输出显示
实验项目一：支持算数表达式求解的计算器
m0_58144501的博客
11-25 362
一、实验要求 1)能通过设计的按钮控件输入并实现算术表达式，表达式在文本框中显示，运算结果输出显示;保存和浏览历史运算记录； 2)能够检验算术表达式的合法性； 3)能够实现混合运算的求解，算术表达式中包括加、减、乘、除、括号等运算符； 4) 要求交互界面友好，程序健壮。 ...
数据结构课程设计——算术表达式计算器
weixin_63586982的博客
05-26 2296
目录 一、问题描述 基本要求 二、问题分析 实现思路 三、逻辑设计 1.界面设计 2.程序设计 四、物理设计 1.calculator方法 2.actionPerformed方法 3.infixToSuffix方法 4.result方法 一、问题描述 设计一个简单的算术表达式计算器 基本要求 实现四则运算表达式的求值（包含括号，可多层嵌套） 二、问题分析 目前的计算器大多使用后缀表达式来进行计算，因此基本思想是将用户输入的中缀表达式转为后缀表达式，即逆波兰式，进而..
数据结构 实验报告03
zRNA__的博客
03-12 672
一、实验目的和要求 设计并实现一个整型算术表达式计算器。
表达式解析计算器源码（完整实现）
David_Jett
01-27 2938
大一下时做的大数非图形界面计算器，自己在这个过程中收获较大，希望和大家分享下 分三个（面向过程浮点版，面向对象浮点版和面向对象大数版）版本:： 完整实现如下： Version1： 面向过程浮点版 （从文件读入并输出） divexcept.h(存储各种错误信息) #include #include using namespace std; string return_except(
编译原理练习试验
weixin_37569325的博客
12-11 484
编译原理练习试验 表达式计算器的设计与实现 一、 字符集定义 1． &lt;字符&gt; → &lt;数字&gt;│&lt;单界符&gt;│. 2． &lt;数字&gt; → 0│&lt;非零数字&gt; 3． &lt;非零数字&gt;→ 1│2│…│9 4． &lt;单界符&gt; →&lt;运算符&gt;│(│) 5． &lt;运算符&gt; → +│-│*│/
用java写一个简易的计算器
热门推荐
liujunwei6的博客
04-17 2万+
package main; import java.awt.BorderLayout; import java.awt.Color; import java.awt.GridLayout; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import javax.swing.JButton; i...
输入一个中缀算数表达式，求解表达式的值python
最新发布
07-13
当然可以帮你求解中缀算数表达式的值。在Python中，可以使用eval()函数来计算中缀表达式的值。eval()函数会将字符串作为表达式进行计算并返回结果。 下面是一个示例代码，演示如何计算中缀算数表达式的值： ```...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值