【支持算术表达式求解的计算器】——软件实习项目一

最新推荐文章于 2024-07-26 12:28:02 发布
最新推荐文章于 2024-07-26 12:28:02 发布
阅读量478 收藏 4
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lynnquad/article/details/121539799
版权

一、 项目准备

需求分析：
在这里插入图片描述
编程语言及开发工具：

JAVA，使用IDEA

二、实现过程

1.中缀表达式->后缀表达式

基于堆栈的算法：从左到右扫描每一个字符。

（1）如果扫描到的字符是操作数（如a、b等），就直接输出这些操作数。

（2）如果扫描到的字符是一个操作符，分三种情况：
①如果堆栈是空的，直接将操作符存储到堆栈中（push it）
②如果该操作符的优先级大于堆栈出口的操作符，就直接将操作符存储到堆栈中（push it）
③如果该操作符的优先级低于堆栈出口的操作符，就将堆栈出口的操作符导出（pop it）, 直到该操作符的优先级大于堆栈顶端的操作符。将扫描到的操作符导入到堆栈中（push）。

（3）如果遇到的操作符是左括号"（”，就直接将该操作符输出到堆栈当中。该操作符只有在遇到右括号“)”的时候移除。这是一个特殊符号该特殊处理。

（4）如果扫描到的操作符是右括号“）”，将堆栈中的操作符导出（pop）到output中输出，直到遇见左括号“（”。将堆栈中的左括号移出堆栈（pop ）。继续扫描下一个字符

（5）如果输入的中缀表达式已经扫描完了，但是堆栈中仍然存在操作符的时候，我们应该讲堆栈中的操作符导出并输入到output 当中。

2.后缀表达式的计算。

堆栈法计算后缀表达式的值：
（1）从左到右扫描后缀表达式字符串
（2）初始化一个空栈
（3）如果扫描到数字，那么就直接入栈
（4）如果被扫描的字符是一个二元运算符，那么就连续出栈两次，获得两个字符，元素出栈后，应用运算符进行计算，并将结果压栈
（5）重复3）和4）的操作，直至扫描完字符串
（6）扫描完所有字符串之后，栈中只剩一个元素，该元素就是最终结果，将其出栈并返回。

3.GUI界面的设计
1.JAVA swing 各组件的混合运用；
2.按钮的监听；
3.界面的设计；

关于界面设计的学习详见以下博客 ，带着耐心从中慢慢学习使我受益良多。
https://blog.csdn.net/xietansheng/article/details/72814492

三、完整代码

具体细节和难点详见代码注释。

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.math.BigDecimal;
import java.math.RoundingMode;
import javax.swing.*;

//主类，继承JFrame框架，实现事件监听器接口
public class Main extends JFrame implements ActionListener {
    String []KEYS = { "7", "8", "9", "C", "4", "5", "6", "back", "1", "2", "3", "+", "0", ".", "pi", "-", "sqrt",
            "%", "/", "*", "AC", "(", ")", "=" };
    JButton []keys = new JButton[KEYS.length];
    JTextArea resultText = new JTextArea("0.0");// 文本域组件TextArea可容纳多行文本；文本框内容初始值设为0.0
    JTextArea History = new JTextArea();// 历史记录文本框初始值设为空
    JPanel jp1=new JPanel();
    JPanel jp2=new JPanel();
    JScrollPane gdt1=new JScrollPane(resultText);//给输入显示屏文本域新建一个垂直滚动滑条
    JScrollPane gdt2=new JScrollPane(History);//给历史记录文本域新建一个垂直滚动滑条
    JLabel label = new JLabel("历史记录");
    String b="";
    static int index;
    static int left,right;//左右括号标记
    static int count;//成功运算标记
    Font font = new Font("TIMES NEW ROMAN", Font.PLAIN, 14);//设置字体
    // 构造方法
    public Main() {
        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());
        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);
        jp1.add(gdt1);//将滚动条添加入面板窗口中
        jp2.add(gdt2);
        this.add(jp1);//将面板添加到总窗体中
        this.add(jp2);//将面板添加到总窗体中
        this.setLayout(null);
        this.add(label);// 新建“历史记录”标签

        // 放置按钮
        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, 62, 40);
            keys[i].setBackground(new Color(144, 201, 108));//设置按钮颜色
            keys[i].setFont(font);//设置按钮字体
            if (x < 215) {
                x += 65;
            } else {
                x = 20;
                y += 45;
            }
            this.add(keys[i]);
        }
        keys[16].setBackground(Color.ORANGE);
        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) {
        String label=e.getActionCommand();//获得事件源的标签
        left=0;
        right=0;
        index=resultText.getText().length()-1;
        if(!resultText.getText().equals("")){
            //计算括号的数量
            for(int i=resultText.getText().length()-1;i>=0;i--){
                switch (resultText.getText().charAt(i)) {
                    case '(' -> left++;
                    case ')' -> right++;
                }
            }
            //找到最后一个数字的下标
            if(!"+-*/()".contains(resultText.getText().charAt(resultText.getText().length()-1)+"")){
                for(;index>0;index--){
                    if("+-*/(".contains(resultText.getText().charAt(index)+"")){
                        break;
                    }
                }
            }
        }

        if("0123456789".contains(label)){//输入数字时：
            if(count==1){//文本框内为上一个有效算式的答案，则替换为后输入的数字
                b=label;
                resultText.setText(b);
                count=0;
            }
            else if(("0".contains(resultText.getText().charAt(resultText.getText().length()-1)+"")&&
                    resultText.getText().length()<=1)){//无法输入0开头的整数
                b=label;
                resultText.setText(b);
            }
            else if(("0".contains(resultText.getText().charAt(resultText.getText().length()-1)+""))&&
                    ("+-*/%".contains(resultText.getText().charAt(resultText.getText().length()-2)+""))){
                StringBuilder BK = new StringBuilder(this.b);//无法输入0开头的整数
                resultText.setText(BK.substring(0, this.b.length() - 1)+label);
                b=resultText.getText();
            }
            else{
                this.b = this.b + label;
                resultText.setText(b);
            }
        }

        //输入左括号时
        else if(label.equals("(")){
            if(b.equals("")){
                resultText.setText("(");
                b=resultText.getText();
            }
            //前面是数字和右括号时补乘，是小数点时无法输入
            else if("0123456789)".contains(resultText.getText().charAt(resultText.getText().length()-1)+"")){
                b=b+"*(";
                resultText.setText(resultText.getText()+"*(");
            }
            else if(".".contains(resultText.getText().charAt(resultText.getText().length()-1)+"")){
            }
            else{
                b=b+"(";
                resultText.setText(resultText.getText()+"(");
            }
        }

        else if (label==")"){//输入右括号时
            if (b.equals("")){//表达式为空时不做响应
            }
            else if("+-*/(".contains(resultText.getText().charAt(resultText.getText().length()-1)+"")
            ||left==right){//运算符、左括号后不能跟右括号，左右括号数量匹配时不能输入右括号
            }
            //前面是右括号时补乘
        else if(b.length()>0&&(")".contains(resultText.getText().charAt(resultText.getText().length()-1)+""))){
            b=b+"*"+label;
            resultText.setText(b);
        }
            else {
                resultText.setText(resultText.getText()+")");
                b=resultText.getText();
            }
        }

        else if(label=="."){//输入小数点时
            if(count==1){//文本框内为上一个有效算式的答案，则替换
                b="0"+label;
                resultText.setText(b);
                count=0;
            }
            if((b.equals(""))
                    ||"(+-*/".contains(resultText.getText().charAt(resultText.getText().length()-1)+"")){
                b=b+"0.";
                resultText.setText(b);
            }
            else if(")".contains(resultText.getText().charAt(resultText.getText().length()-1)+"")){
                b=b+"*0.";//前面是右括号时补乘
                resultText.setText(b);
            }
            else if (".".contains(resultText.getText().charAt(resultText.getText().length()-1)+"")){
            }//前面是小数点时不作响应

            else if(!b.substring(index+1).contains(".")){//前面是不带小数点的数字时正常输入
                b=b+".";
                resultText.setText(b);
            }
            else{//前面是带小数点的数字时不响应
            }
        }

        else if(label.equals("=")){//输入等于号时,调用计算方法，得出最终结果
            //resultText.setText(this.b);
            History.setText(History.getText()+resultText.getText());
            if (".".contains(resultText.getText().charAt(resultText.getText().length()-1)+"")){
                StringBuilder BK = new StringBuilder(this.b);
                resultText.setText(BK.substring(0, this.b.length() - 1));
                this.b=resultText.getText();
            }
                try {
                    String s[] = Calculate(this.b);
                    String result = Result(s);
                    this.b = result + "";
                    double Test1;
                    Test1=Double.parseDouble(this.b);//将答案字符串转换成双精度型数据检测是否有错误
                    //更新文本框，当前结果在字符串b中，并未删除，下一次输入接着此结果以实现连续运算
                    resultText.setText(this.b);
                    History.setText(History.getText() + "=" + resultText.getText() + "\n");
                    count=1;
                }catch (Exception e1){//抓取错误，不参与运算并提示输入错误，并将文本区域初始化
                    JOptionPane.showMessageDialog(null,"表达式错误");
                    History.setText(History.getText() +"：表达式不完整或将0设置为了除数" + "\n");
                    this.b="";
                    resultText.setText("0");
                }

        }

        else if(label=="C"){ //清空按钮，消除显示屏文本框前面所有的输入和结果
            this.b="";
            resultText.setText("0");//更新文本域的显示，显示初始值;
        }

        else if(label=="sqrt") {//开方功能并不完善，目前只能用于单目运算
            String n=kFys(this.b);
            resultText.setText("sqrt"+"("+this.b+")"+"="+n);//使运算表达式显示在输入界面
            History.setText(History.getText()+resultText.getText()+"\n");//获取输入界面的运算表达式并使其显示在历史记录文本框
            this.b=n;
        }

        else if(label=="AC") {
            this.b="";
            resultText.setText("0");
            History.setText(" ");
        }

        else if(label=="pi") {
            String m=String.valueOf(3.14159265);
            this.b=this.b+m;
            resultText.setText(this.b);
        }

        else if(label=="back"&&this.b.length()>1) {//退格
            StringBuilder BK = new StringBuilder(this.b);
            resultText.setText(BK.substring(0, this.b.length() - 1));
            this.b=resultText.getText();
        }

        else if((label=="back")&&(this.b.length()<=1)){//防止文本框为空时打印退格键
            this.b="";
            resultText.setText("0");
        }

        else if (label=="-"){//运算符后不能输入减号
            if("+-*/.".contains(resultText.getText().charAt(resultText.getText().length()-1)+"")){
            }
            else{
                this.b = this.b + label;
                resultText.setText(this.b);
            }
        }

        else if(label=="+"||label=="*"||label=="/"||label=="%"||label=="sqrt") {//输入运算符时
            if("+-*/(%.".contains(resultText.getText().charAt(resultText.getText().length()-1)+"")){
            }//运算符后不能输入运算符
            else if(b.length()==0) {//当文本框为空时无法输入减号以外的运算符
            }
            else{
                this.b = this.b + label;
                resultText.setText(this.b);
            }
        }

        else {
            b = b + label;
            resultText.setText(this.b);
        }
    }

    //将中缀表达式转换为后缀表达式
    public   String[] Calculate(String str) {
        char opStack[] = new char[100];// 静态栈,对用户输入的操作符进行处理，用于存储运算符
        String postQueue[] = new String[100];// 后缀表达式字符串数组，为了将多位数存储为独立的字符串
        int top = -1, j = 0; // 静态指针top,控制变量j

        if(str.charAt(0)=='-'){//如果表达式以负号开头,在最前面补一个0,方便计算
            str="0"+str;
        }
        StringBuilder addZero= new StringBuilder(str);//将表达式中的所有"(-"变为"(0-"以方便计算
        if(str.contains("(-")){
            do{
                addZero.insert(addZero.indexOf("(-")+1,'0');
                str=addZero.toString();
            }while (str.contains("(-"));
        }
        // 用于承接多位数的字符串
        String s = "";
        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);
                }
                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 kFys(String str) {
        String result = "";
        double a = Double.parseDouble(str), b = 0;
        b = Math.sqrt(a);
        result = String.valueOf(b);//将运算结果转换为string类型并赋给string类型的变量result
        return result;
    }

    // 计算后缀表达式，并返回最终结果
    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)// 遇到运算符字符，将栈顶两个元素出栈计算并将结果返回栈顶
            {
                BigDecimal x, y, n;
                x = BigDecimal.valueOf(Double.parseDouble(new BigDecimal(Result[Top]).toString()));// 顺序出栈两个数字字符串，并转换为double类型
                Top--;
                y = BigDecimal.valueOf(Double.parseDouble(new BigDecimal(Result[Top]).toString()));
                Top--;
                if ("-".indexOf(str[i]) >= 0) {
                    n = y.subtract(x);
                    Top++;
                    Result[Top] = String.valueOf(n);// 将运算结果重新入栈
                }
                if ("+".indexOf(str[i]) >= 0) {
                    n = y.add(x);
                    Top++;
                    Result[Top] = String.valueOf(n);// 将运算结果重新入栈
                }
                if ("*".indexOf(str[i]) >= 0) {
                    n = y.multiply(x);
                    Top++;
                    Result[Top] = String.valueOf(n);// 将运算结果重新入栈

                }
                if ("/".indexOf(str[i]) >= 0){
                        n = y.divide(x,5,RoundingMode.HALF_UP);
                        Top++;
                        Result[Top] = String.valueOf(n);// 将运算结果重新入栈
                }
                if ("%".indexOf(str[i]) >= 0) {
                   double num1= Double.parseDouble(String.valueOf(y));
                   double num2= Double.parseDouble(String.valueOf(x));
                        n = BigDecimal.valueOf(num1%num2);
                        Top++;
                        Result[Top] = String.valueOf(n);// 将运算结果重新入栈
                }
            }
        }
        return Result[Top];// 返回最终结果
    }

    // 主函数
    public static void main(String[] args) {
        Main test = new Main();
    }
}

四、遇到的问题及其解决过程

1.非法表达式的识别
请添加图片描述

当输入如图非法表达式时，会因为括号数未匹配而无法返回正确值。
解决方法：
在“＝”的执行语句后使用以下代码抓取错误并提示

catch (Exception e1){//抓取错误，不参与运算并提示输入错误
                    JOptionPane.showMessageDialog(null,"表达式错误");
                    History.setText(History.getText() +"：此表达式错误" + "\n");

添加后结果如下：
在这里插入图片描述
2.负数的运算问题
程序会因为无法运算负数而直接报错

解决方法：
加入以下“补零”代码

if(str.charAt(0)=='-'){//如果表达式以负号开头,在最前面补一个0,方便计算
          str="0"+str;
      }
      StringBuilder addZero= new StringBuilder(str);//将表达式中的所有"(-"变为"(0-"以方便计算
      if(str.contains("(-")){
          do{
              addZero.insert(addZero.indexOf("(-")+1,'0');
              str=addZero.toString();
          }while (str.contains("(-"));
      }

在这里插入图片描述

五、程序功能演示

在这里插入图片描述
程序界面分为左边的操作显示区和右侧的历史记录区。
能提示被除数不允许为0等表达式异常产生的错误。
在这里插入图片描述
有退格、清空历史记录等便利功能
其中开方功能并不完善，目前只能进行单目运算。
在这里插入图片描述

12.20日补充
在经过修改后，计算器有了更智能的输入功能，例如所输入的右括号数量只能小于等于左括号数量，小数点前无数字时自动补零，无法连续输入运算符等等，期间也遇到bug越写越多的情况，但耐心写下来收获甚至不小于刚写完框架，之前没注意到的各种细节被慢慢完善很有成就感。

Lynnquad
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【使用java swing制作简易贪吃蛇游戏】软件实习项目二
Lynnquad的博客
12-26 2233
一、项目准备 需求分析： 实现贪吃蛇游戏基本功能，屏幕上随机出现一个“食物”，称为豆子，上下左右控制“蛇”的移动，吃到“豆子”以后“蛇”的身体加长一点,得分增加，“蛇”碰到边界或，蛇头与蛇身相撞，蛇死亡，游戏结束。为游戏设计初始欢迎界面，游戏界面，游戏结束界面。 编程语言及开发工具： java 基于IDEA 二、实现过程 在屏幕区域内绘制出一条小蛇，并且在与蛇不重合的屏幕区域内随机出现一个食物，游戏者通过键盘操纵游戏小蛇上下左右移动来吃到食物，当食物成功被小蛇吃到后，会在另外的区域重新刷新出食物，而小蛇由于
计算机软件技术实习 项目一 支持算术表达式求解的计算器（实验准备）
Jcm_666的博客
10-11 247
记录简易计算器设计时的一些关键算法思想：堆栈法、双栈算符优先级法、二叉树求解法
实验一、支持算术表达式求解的计算器
chi_choo的博客
11-25 311
要求： （1）能通过设计的按钮控件输入并实现算术表达式，表达式在文本框中显示，运算结果输出显示；保存和浏览历史运算记录； （2）能够检验算术表达式的合法性； （3）能够实现混合运算的求解，算术表达式中包括加、减、乘、除、括号等运算符； （4）要求交互界面友好，程序健壮。 ...
数据结构课程设计——算术表达式计算器
weixin_63586982的博客
05-26 2300
目录 一、问题描述 基本要求 二、问题分析 实现思路 三、逻辑设计 1.界面设计 2.程序设计 四、物理设计 1.calculator方法 2.actionPerformed方法 3.infixToSuffix方法 4.result方法 一、问题描述 设计一个简单的算术表达式计算器 基本要求 实现四则运算表达式的求值（包含括号，可多层嵌套） 二、问题分析 目前的计算器大多使用后缀表达式来进行计算，因此基本思想是将用户输入的中缀表达式转为后缀表达式，即逆波兰式，进而..
实现支持算术表达式求解的计算器——计算机软件技术实习（项目一）
m0_51762479的博客
11-17 252
使用Java swing实现支持算术表达式求解的计算器
制作简易计算器——计算机软件技术实习
Real_orchid的博客
09-07 208
qt 计算器
软件实习项目1——计算器的设计与实现（实验准备）
Mirrracle的博客
11-30 839
软件实习项目1——计算器的设计与实现（实验准备）项目要求项目思路理论准备中缀表达式后缀表达式 项目要求 1、能通过设计的按钮控件输入并实现简单算术运算，要求表达式在编辑框中显示，能将运算结果，输出在编辑框内显示； 2、能够实现混合运算的求解，算术表达式中包括加、减、乘、除、括号等运算符；并且能够识别括号，优先级正确。 3、并保存历史的表达式运算记录。 技术准备：图形界面的开发； 难点：中缀表达式->后缀表达式，后缀表达式的计算。 项目思路 1、实现中缀表达式到后缀表达式的转换。 2、按照后缀表达式的运
计算机软件技术实习项目一（一） 简易计算器项目准备
qq_45155131的博客
12-27 907
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录系列文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例
计算机软件技术实习(实验准备)——简单计算器的实现
mou_miu的博客
10-14 326
计算器的基本界面，完成四则运算，基本上就是0~9十个按钮、一个小数点、一个等号、四个加减乘除按钮，还有一个显示文本的Text。一个 Java 的图形界面，由各种不同类型的“元素”组成，例如: 窗口、菜单栏、对话框、标签、按钮、文本框等等，这些“元素”统一被称为 组件（Component）。组件按照不同的功能，可分为 顶层容器、中间容器、基本组件。·中间容器 和 基本组件 继承自javax.swing.JComponent。·顶层容器 属于窗口类组件，继承自java.awt.Window；
数据结构大作业C++实现简单的计算器——算术表达式计算（包含实验报告）
06-25
设计一个程序，演示用算符优先法对算术表达式求值的过程。 【基本要求】 以字符序列的形式从终端输入语法正确的、不含变量的整数表达式。利用运算符优先关系，实现对算术四则混合运算表达式的求值。 【测试数据】 ...
《算术表达式的求解》C语言 代码
03-05
给定一个算术表达式，通过程序求出最后的结果。 1、从键盘输入要求解的算术表达式； 2、采用栈结构进行算术表达式的求解过程（不用栈结构验收不合格）； 3、能够判断算术表达式正确与否； 4、对于错误表达式给出提示...
算术表达式的求解-数据结构课程设计报告.pdf
10-01
算术表达式的求解 - 数据结构课程设计报告 本报告详细介绍了算术表达式的求解的设计和实现，使用栈结构来实现算术表达式的求解过程。报告分为三个部分：需求分析、设计构想和详细设计。 需求分析部分： * 需要...
算术表达式求解数据结构课设
01-15
算术表达式求解数据结构课设，代码，说明书
C/C++课设（算术表达式求解器 / 计算器 ）
01-27
功能较为完善的算术表达式求解器 / 计算器。C/C++源码，内含使用STL和不使用STL两个版本。
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1258
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
golang 接口
m0_70982551的博客
07-24 805
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
最新发布
a1058926697的博客
07-26 364
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 486
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
基于栈结构的算术表达式求解系统设计
数据结构算术表达式求解是计算机科学中一个重要的主题，它涉及到栈结构、算术表达式的求解、系统设计和实现等多个方面。在本文中，我们将对数据结构算术表达式求解进行详细的分析和讨论。 一、算术表达式的求解 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值