Java尚硅谷数据结构与算法学习记录(6)续-栈实现综合计算器

最新推荐文章于 2021-11-20 18:09:16 发布
最新推荐文章于 2021-11-20 18:09:16 发布
阅读量242 收藏 2
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38715538/article/details/106872162
版权

栈实现综合计算器（中缀表达式）

思路分析：

  1. 需要两个栈：数栈和符号栈 定义一个index索引来遍历表达式
  2. 遍历到一个数字，则入数栈
  3. 遍历到一个符号，若符号栈为空则入符号栈；
    若符号栈不为空：如果当前遍历到的符号优先级小于或等于符号栈中符号的优先级，则从数栈中pop出两个数，从符号栈中pop出一个符号，进行运算，然后将运算结果入数栈，将当前遍历到的符号入符号栈；如果当前遍历到的符号优先级大于符号栈中符号优先级，则将该符号直接入符号栈。
  4. 表达式遍历完毕后，则按顺序从数栈和符号栈中pop出值进行运算
  5. 最后数栈中只会有一个数字 即运算结果。

代码实现：

package com.datastructures.stack;

public class Calculator {
    public static void main(String[] args) {
        String expression = "70+2*6-2";
        //创建两个栈
        ArrayStack2 numStack = new ArrayStack2(10);
        ArrayStack2 operStack = new ArrayStack2(10);
        int index = 0;//用于扫描表达式
        int num1 = 0;
        int num2 = 0;
        int oper = 0;
        int res = 0;
        char ch = ' ';
        String keepNum = "";//用于拼接多位数
        while (true) {
            ch = expression.substring(index, index + 1).charAt(0);
            if (operStack.isOper(ch)) {//扫描到是符号
                if (!operStack.isEmpty()) {
                    //如果当前遍历到的符号优先级小于或等于符号栈中符号的优先级，
                    //则从数栈中pop出两个数，从符号栈中pop出一个符号，进行运算，
                    // 然后将运算结果入数栈，将当前遍历到的符号入符号栈；
                    if (operStack.priority(ch) <= operStack.priority(operStack.peek())) {
                        num1 = numStack.pop();
                        num2 = numStack.pop();
                        oper = operStack.pop();
                        res = numStack.cal(num1, num2, oper);
                        numStack.push(res);
                        operStack.push(ch);

                    } else {
                        //如果**当前遍历到的符号优先级大于符号栈中符号优先级**，则将该符号直接入符号栈
                        operStack.push(ch);
                    }
                } else {
                    //若符号栈为空则入符号栈；
                    operStack.push(ch);
                }

            } else {//扫描到是数字
                //numStack.push(ch-48);
                //处理多位数：
                // 当index扫描到数字后 再往后扫描一位 若后一位是符号则将该数字入数栈 否则继续扫描
                // 需要定义一个变量字符串用于拼接数字

                //如果ch已经是expression的最后一位则直接入栈
                keepNum += ch;
                if (index == expression.length() - 1) {
                    numStack.push(Integer.parseInt(keepNum));

                } else {

                    if (operStack.isOper(expression.substring(index + 1, index + 2).charAt(0))) {
                        numStack.push(Integer.parseInt(keepNum));
                        //注意要将keepNum清空
                        keepNum = "";
                    }
                }
            }
            index++;
            if (index >= expression.length()) {
                break;

            }
        }
        //表达式遍历完毕后，则按顺序从数栈和符号栈中pop出值进行运算
        while (true) {
            if (operStack.isEmpty()) {
                break;
            }
            num1 = numStack.pop();
            num2 = numStack.pop();
            oper = operStack.pop();
            res = numStack.cal(num1, num2, oper);
            numStack.push(res);
        }
        System.out.printf("表达式%s的结果为:%d", expression, numStack.pop());

    }


}

class ArrayStack2 {
    private int maxSize;//栈的最大容量
    private int[] stack;//定义一个数组 栈的数据存在数组中
    private int top = -1;//指向栈顶

    public ArrayStack2(int maxSize) {
        this.maxSize = maxSize;
        stack = new int[maxSize];
    }

    //栈满
    public boolean isFull() {
        return top == maxSize - 1;
    }

    //栈空
    public boolean isEmpty() {
        return top == -1;
    }

    //显示当前栈顶元素
    public int peek() {
        return stack[top];
    }

    //入栈
    public void push(int data) {
        if (isFull()) {
            System.out.printf("栈满，无法入栈");
            return;
        } else {
            top++;
            stack[top] = data;
        }
    }

    //出栈
    public int pop() {
        if (isEmpty()) {
            throw new RuntimeException("栈空");
        } else {
            int value = stack[top];
            top--;
            return value;
        }
    }

    //显示栈
    public void show() {
        if (isEmpty()) {
            throw new RuntimeException("栈空");
        } else {
            for (int i = top; i >= 0; i--) {
                System.out.printf("stack[%d]=%d\n", i, stack[i]);
            }
        }
    }

    //返回运算符的优先级   规定数字越大优先级越高
    public int priority(int oper) {
        if (oper == '*' || oper == '/') return 1;
        else if (oper == '+' || oper == '-') return 0;
        else return -1;//假设当前只有+ - * /四种符号
    }

    //判断是否是符号
    public boolean isOper(int oper) {
        return oper == '+' || oper == '-' || oper == '*' || oper == '/';
    }

    //定义运算规则
    public int cal(int num1, int num2, int oper) {
        int res = 0;
        switch (oper) {
            case '+':
                res = num1 + num2;
                break;
            case '-':
                res = num2 - num1;
                break;
            case '*':
                res = num1 * num2;
                break;
            case '/':
                res = num2 / num1;
                break;
            default:
                break;
        }
        return res;
    }

}

逆波兰计算器的代码实现：（只支持对整数）

前缀：从右到左计算
后缀：从左到右计算

package com.datastructures.stack;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class PolandNotation {
    public static void main(String[] args) {
        //定义一个逆波兰表达式 (3+4)*5-6=> 3 4 + 5 * 6 -
        String suffixExpression = "3 4 + 5 * 6 -";
        List<String> rpnList = getListString(suffixExpression);
        System.out.println("rpnList=" + rpnList);
        int res=cal(rpnList);
        System.out.println("计算结果是："+res);
    }

    public static List<String> getListString(String suffixExpression) {
        //将表达式中数字和符号放入到ArrayList中
        String[] split = suffixExpression.split(" ");
        List<String> list = new ArrayList<String>();
        for (String ele : split) {
            list.add(ele);
        }
        return list;
    }

    /*
        计算步骤：
        1）从左至右扫描，将3和4压入堆栈
        2）遇到+运算符，弹出栈顶元素4和次顶元素3 计算3+4的值 将其入栈
        3）5入栈
        4）遇到* 弹出5,7 计算结果入栈
        5）6入栈
        6）遇到- 弹出35,6 计算结果
    */
    public static int cal(List<String> ls) {
        Stack<String> stack = new Stack<>();
        //遍历list集合
        for (String i : ls) {
            if (i.matches("\\d+")) {
                stack.push(i);
            } else {
                int num2 = Integer.parseInt(stack.pop());
                int num1 = Integer.parseInt(stack.pop());
                int res = 0;
                if (i.equals("+")) {
                    res = num1 + num2;
                } else if (i.equals("-")) {
                    res = num1 - num2;
                } else if (i.equals("*")) {
                    res = num1 * num2;
                } else if (i.equals("/")) {
                    res = num1 / num2;
                }else{
                    throw new RuntimeException("运算符有误！");
                }
                stack.push("" + res);
            }

        }
        return Integer.parseInt(stack.pop());
    }
}

中缀表达式转后缀表达式：

中缀表达式 1 + ( ( 2 + 3 )× 4) - 5 =》 后缀表达式
将 s2 出栈 - 5 + * 4 + 3 2 1 => 1 2 3 + 4 * + 5 -
步骤：

  1. 初始化两个栈：运算符栈s1和储存中间结果的栈s2；

  2. 从左至右扫描中缀表达式；

  3. 遇到操作数时，将其压s2；

  4. 遇到运算符时，比较其与s1栈顶运算符的优先级：

    1. 如果s1为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈；
    2. 否则，若优先级比栈顶运算符的高，也将运算符压入s1；
    3. 否则，将s1栈顶的运算符弹出并压入到s2中，再次转到4.1与s1中新的栈顶运算符相比较；

  5. 遇到括号时：
    如果是左括号“(”，则直接压入s1
    如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃

  6. 重复步骤2至5，直到表达式的最右边

  7. 将s1中剩余的运算符依次弹出并压入s2

  8. 依次弹出s2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式
    在这里插入图片描述
    代码实现：

package com.datastructures.stack;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class PolandNotation {
    public static void main(String[] args) {
        //1、完成将中缀表达式转成后缀表达式的功能1+((2+3)*4)-5  =>  1 2 3 + 4 * + 5 -
        //因为直接对表达式进行操作不方便 因此先将“1+((2+3)*4)-5”=>中缀表达式对应的List
        //即 “1+((2+3)*4)-5”=>ArrayList[1,+,(,(,2,+,3,),*,4,),-,5]
        String expression = "1+((2+3)*4)-5";
        List<String> infixExpressionList = toInfixExpressionList(expression);
        System.out.println("中缀表达式对应的List："+infixExpressionList);
        List<String> suffixExpressionList = parseSuffixExpressionList(infixExpressionList);
        System.out.println("后缀表达式对应的List："+suffixExpressionList);
        int res = cal(suffixExpressionList);
        System.out.println("计算结果是："+res);

       /* //定义一个逆波兰表达式 (3+4)*5-6=> 3 4 + 5 * 6 -
        String suffixExpression = "3 4 + 5 * 6 -";
        List<String> rpnList = getListString(suffixExpression);
        System.out.println("rpnList=" + rpnList);
        int res=cal(rpnList);
        System.out.println("计算结果是："+res);*/
    }

    //2、将中缀表达式转成对应的List  s="1+((2+3)*4)-5" => ArrayList[1,+,(,(,2,+,3,),*,4,),-,5]
    public static List<String> toInfixExpressionList(String s) {
        //定义一个List存放中缀表达式对应的内容
        List<String> ls = new ArrayList<String>();
        int i = 0;// 指针，用于遍历
        String str;//用于多位数的拼接
        char c;//每遍历到一个字符就放入c
        do {
            //如果c是非数字则直接加入ls
            if ((c = s.charAt(i)) < 48 || (c = s.charAt(i)) > 57) {
                ls.add("" + c);
                i++;
            } else {//如果c是数字 则需要考虑多位数
                str = "";//将str清空
                while (i < s.length() && (c = s.charAt(i)) >= 48 && (c = s.charAt(i)) <= 57) {
                    str += c;//拼接
                    i++;
                }
                ls.add(str);
            }
        } while (i < s.length());
        return ls;
    }

    //3、将得到的中缀表达式List转成后缀表达式对应的List
    // 即ArrayList[1,+,(,(,2,+,3,),*,4,),-,5]=>ArrayList[1,2,3,+,4,*,+,5,-]
    public static List<String> parseSuffixExpressionList(List<String> ls) {
        //1) 初始化两个栈：**运算符栈s1和储存中间结果的栈s2**；
        Stack<String> s1 = new Stack<String>();//运算符栈s1
        //因为在整个转换过程中s2并没有进行pop操作 且最后需要逆序输出s2内容
        //因此为了方便 可以使用List<String>集合来代替Stack<String>
        List<String> s2 = new ArrayList<String>();//储存中间结果的List<String> s2;
        int index = 0;//用于扫描表达式
        //2)遍历ls
        for (String item : ls) {
            //如果是一个数，则加入s2
            if (item.matches("\\d+")) {
                s2.add(item);
            } else if (item.equals("(")) {
                s1.push(item);
            } else if (item.equals(")")) {
                //   如果是**右括号“)”**，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃
                while (!s1.peek().equals("(")) {
                    s2.add(s1.pop());
                }
                s1.pop();//将“(”弹出s1消除小括号
            }else{
                //将s1栈顶的运算符弹出并压入到s2中，再次转到4.1与s1中新的栈顶运算符相比较
                while(s1.size()!=0&&Operation.getValue(s1.peek())>=Operation.getValue(item)){
                    s2.add(s1.pop());
                }
                s1.push(item);
            }
        }
        //将s1中剩余的运算符依次弹出并加入s2中
        while (s1.size()!=0){
            s2.add(s1.pop());
        }
        return s2;//因为s2是List集合  所以它的顺序输出就是后缀表达式
    }


    public static List<String> getListString(String suffixExpression) {
        //将表达式中数字和符号放入到ArrayList中
        String[] split = suffixExpression.split(" ");
        List<String> list = new ArrayList<String>();
        for (String ele : split) {
            list.add(ele);
        }
        return list;
    }


      /*  计算步骤：
        1）从左至右扫描，将3和4压入堆栈
        2）遇到+运算符，弹出栈顶元素4和次顶元素3 计算3+4的值 将其入栈
        3）5入栈
        4）遇到* 弹出5,7 计算结果入栈
        5）6入栈
        6）遇到- 弹出35,6 计算结果*/

    public static int cal(List<String> ls) {
        Stack<String> stack = new Stack<>();
        //遍历list集合
        for (String i : ls) {
            if (i.matches("\\d+")) {
                stack.push(i);
            } else {
                int num2 = Integer.parseInt(stack.pop());
                int num1 = Integer.parseInt(stack.pop());
                int res = 0;
                if (i.equals("+")) {
                    res = num1 + num2;
                } else if (i.equals("-")) {
                    res = num1 - num2;
                } else if (i.equals("*")) {
                    res = num1 * num2;
                } else if (i.equals("/")) {
                    res = num1 / num2;
                } else {
                    throw new RuntimeException("运算符有误！");
                }
                stack.push("" + res);
            }

        }
        return Integer.parseInt(stack.pop());
    }
}
//编写Operation类可以返回运算符对应的优先级
class Operation{
    private static int ADD=1;
    private static  int SUB=1;
    private static  int MUL=2;
    private static int DIV=2;
    public static int getValue(String operation){
        int res=0;
        switch(operation){
            case "+":
                res=ADD;
                break;
            case "-":
                res=SUB;
                break;
            case "*":
                res=MUL;
                break;
            case "/":
                res=DIV;
                break;
            default:
                System.out.println("不存在运算符！");
                break;
        }
        return res;
    }

}
liililiya
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构与算法课程设计--模拟简单计算器.docx
07-09
数据结构与算法课程设计--模拟简单计算器.docx
数据结构-用栈实现计算器中 尚硅谷老师出现的思路问题
QiuYuSy的博客
08-23 275
尚硅谷的JAVA数据结构与算法中用栈实现计算器的问题老师的思路这种思路的问题在等号执行前，两个栈的情况老师的代码 老师的思路 这种思路的问题 如果在运算中出现了减去一个乘法然后再进行运算的情况就会出现问题 例如：3-2*1+1 在等号运算前栈内的情如下图所示 此时继续执行程序会让数字2、1和运算符‘+’弹栈，然后再运算完后结果为2再把2压栈到nums中 这里就是问题所在了 按照正常的运算应该是3-2+1 = 2 而这里却是 3-(2+1) = 0 !! 我弄了半天还以为是自己代码有问题结果用老师的源码试
个人数据结构与算法学习总结-栈、实现综合计算器、递归
qq_39084191的博客
06-01 278
栈 本总结主要是以“尚硅谷Java算法教程”的学习教程为主，加上一些个人的理解 目录栈栈介绍介绍出栈和入栈的图示栈的应用场景实现栈利用栈实现综合计算器前缀、中缀、后缀表达式设计逆波兰计算器 栈介绍 介绍 栈的英文为(stack)，是一个先入后出(FILO-First In Last Out)的有序列表。栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)。 根据栈的定义可知
数据结构与算法Java版--利用栈实现简易计算器
weixin_43217921的博客
01-21 130
本系列博客源自学习《尚硅谷数据结构与算法》的学习随笔。 思路分析： 代码实现： package test.learn.algorithm.Stack; //定义一个数组表示的栈 public class ArrayStack { private int MaxSize; private int [] stack; private int top = -1; //构造器 public ArrayStack(int MaxSize){ this.Ma
尚硅谷算法与数据结构学习笔记04 -- 栈
exodus3的博客
11-20 735
1、栈的基本介绍 1.1、栈的实际需求 请计算表达式：[7_2_2-5+1-5+3-3] 的值 请问: 计算机底层是如何运算得到结果的？ 注意不是简单的把算式列出运算，因为我们看这个算式 7 * 2 * 2 - 5，但是计算机怎么理解这个算式的 对计算机而言， 它接收到的就是一个字符串， 我们讨论的是这个问题：栈 1.2、栈的基本性质 栈的英文为(stack) 栈是一个先入后出(FILO-First In Last Out)的有序列表 栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一
【Java数据结构与算法】栈及经典应用
12-21
文章目录栈的应用场景与介绍栈的介绍出入栈的概念（如图所示）栈的应用场景数组模拟栈的思路分析图代码实现栈实现综合计算器要求思路分析代码实现 栈的应用场景与介绍 计算式：7*2*2-5+1-5*3-3=? 计算机底层是如何...
Java版本的数据结构与算法
12-26
关于数据结构和算法的详细书籍，为Java版本，超详细，超准确！
基于Java实现长整数加减法(数据结构与算法课设)【100012352】
05-22
1.作为长整数加减法，要实现任意唱的整数的加、减法运算。以用户和计算机对话的方式，即用户根据网页对话框显示的提示信息之后，由用户通过键盘，输入演示程序用规定的运算命令，然后返回结果提示。 2.我们的长整数...
王博外文文献.pdf
05-23
王博外文文献.pdf
基于 Go+Echo 开发的多房间实时通讯系统。.zip
05-23
Go语言（也称为Golang）是由Google开发的一种静态强类型、编译型的编程语言。它旨在成为一门简单、高效、安全和并发的编程语言，特别适用于构建高性能的服务器和分布式系统。以下是Go语言的一些主要特点和优势： 简洁性：Go语言的语法简单直观，易于学习和使用。它避免了复杂的语法特性，如继承、重载等，转而采用组合和接口来实现代码的复用和扩展。 高性能：Go语言具有出色的性能，可以媲美C和C++。它使用静态类型系统和编译型语言的优势，能够生成高效的机器码。 并发性：Go语言内置了对并发的支持，通过轻量级的goroutine和channel机制，可以轻松实现并发编程。这使得Go语言在构建高性能的服务器和分布式系统时具有天然的优势。 安全性：Go语言具有强大的类型系统和内存管理机制，能够减少运行时错误和内存泄漏等问题。它还支持编译时检查，可以在编译阶段就发现潜在的问题。 标准库：Go语言的标准库非常丰富，包含了大量的实用功能和工具，如网络编程、文件操作、加密解密等。这使得开发者可以更加专注于业务逻辑的实现，而无需花费太多时间在底层功能的实现上。 跨平台：Go语言支持多种操作系统和平台，包括Windows、Linux、macOS等。它使用统一的构建系统（如Go Modules），可以轻松地跨平台编译和运行代码。 开源和社区支持：Go语言是开源的，具有庞大的社区支持和丰富的资源。开发者可以通过社区获取帮助、分享经验和学习资料。 总之，Go语言是一种简单、高效、安全、并发的编程语言，特别适用于构建高性能的服务器和分布式系统。如果你正在寻找一种易于学习和使用的编程语言，并且需要处理大量的并发请求和数据，那么Go语言可能是一个不错的选择。
Qt调用Sqlite数据库
05-23
使用Qt自带的库来使用Sqlite数据库,实现增删查改功能； Sqlite 数据库作为 Qt 项目开发中经常使用的一个轻量级的数据库，可以说是兼容性相对比较好的数据库之一，尤其是在一些嵌入式设备中，由于其小巧简洁而大量使用；
WHHA树洞的后端，基于Go语言.zip
05-23
Go语言（也称为Golang）是由Google开发的一种静态强类型、编译型的编程语言。它旨在成为一门简单、高效、安全和并发的编程语言，特别适用于构建高性能的服务器和分布式系统。以下是Go语言的一些主要特点和优势： 简洁性：Go语言的语法简单直观，易于学习和使用。它避免了复杂的语法特性，如继承、重载等，转而采用组合和接口来实现代码的复用和扩展。 高性能：Go语言具有出色的性能，可以媲美C和C++。它使用静态类型系统和编译型语言的优势，能够生成高效的机器码。 并发性：Go语言内置了对并发的支持，通过轻量级的goroutine和channel机制，可以轻松实现并发编程。这使得Go语言在构建高性能的服务器和分布式系统时具有天然的优势。 安全性：Go语言具有强大的类型系统和内存管理机制，能够减少运行时错误和内存泄漏等问题。它还支持编译时检查，可以在编译阶段就发现潜在的问题。 标准库：Go语言的标准库非常丰富，包含了大量的实用功能和工具，如网络编程、文件操作、加密解密等。这使得开发者可以更加专注于业务逻辑的实现，而无需花费太多时间在底层功能的实现上。 跨平台：Go语言支持多种操作系统和平台，包括Windows、Linux、macOS等。它使用统一的构建系统（如Go Modules），可以轻松地跨平台编译和运行代码。 开源和社区支持：Go语言是开源的，具有庞大的社区支持和丰富的资源。开发者可以通过社区获取帮助、分享经验和学习资料。 总之，Go语言是一种简单、高效、安全、并发的编程语言，特别适用于构建高性能的服务器和分布式系统。如果你正在寻找一种易于学习和使用的编程语言，并且需要处理大量的并发请求和数据，那么Go语言可能是一个不错的选择。
基于go获得Linux系统负载， web.zip
05-23
Go语言（也称为Golang）是由Google开发的一种静态强类型、编译型的编程语言。它旨在成为一门简单、高效、安全和并发的编程语言，特别适用于构建高性能的服务器和分布式系统。以下是Go语言的一些主要特点和优势： 简洁性：Go语言的语法简单直观，易于学习和使用。它避免了复杂的语法特性，如继承、重载等，转而采用组合和接口来实现代码的复用和扩展。 高性能：Go语言具有出色的性能，可以媲美C和C++。它使用静态类型系统和编译型语言的优势，能够生成高效的机器码。 并发性：Go语言内置了对并发的支持，通过轻量级的goroutine和channel机制，可以轻松实现并发编程。这使得Go语言在构建高性能的服务器和分布式系统时具有天然的优势。 安全性：Go语言具有强大的类型系统和内存管理机制，能够减少运行时错误和内存泄漏等问题。它还支持编译时检查，可以在编译阶段就发现潜在的问题。 标准库：Go语言的标准库非常丰富，包含了大量的实用功能和工具，如网络编程、文件操作、加密解密等。这使得开发者可以更加专注于业务逻辑的实现，而无需花费太多时间在底层功能的实现上。 跨平台：Go语言支持多种操作系统和平台，包括Windows、Linux、macOS等。它使用统一的构建系统（如Go Modules），可以轻松地跨平台编译和运行代码。 开源和社区支持：Go语言是开源的，具有庞大的社区支持和丰富的资源。开发者可以通过社区获取帮助、分享经验和学习资料。 总之，Go语言是一种简单、高效、安全、并发的编程语言，特别适用于构建高性能的服务器和分布式系统。如果你正在寻找一种易于学习和使用的编程语言，并且需要处理大量的并发请求和数据，那么Go语言可能是一个不错的选择。
MCU云快充协议C语言实现库软件源代码.zip
最新发布
05-23
MCU云快充协议C语言实现库软件源代码： #define FRAME_TYPE_0X01 0x01//充电桩登录认证 #define FRAME_TYPE_0X02 0x02 #define FRAME_TYPE_0X03 0x03//充电桩心跳包 #define FRAME_TYPE_0X04 0x04 #define FRAME_TYPE_0X05 0x05//计费模型验证请求 #define FRAME_TYPE_0X06 0x06 #define FRAME_TYPE_0X09 0x09//充电桩计费模型请求 #define FRAME_TYPE_0X0A 0x0A #define FRAME_TYPE_0X12 0x12//读取实时监测数据 //charger ---> server #define FRAME_TYPE_0X13 0x13//离线监测数据 #define FRAME_TYPE_0X15 0x15//充电
c语言实现多功能计算器数据结构与算法
04-06
b'c\xe8\xaf\xad\xe8\xa8\x80\xe5\xae\x9e\xe7\x8e\xb0\xe5\xa4\x9a\xe5\x8a\x9f\xe8\x83\xbd\xe8\xae\xa1\xe7\xae\x97\xe5\x99\xa8\xe6\x95\xb0\xe6\x8d\xae\xe7\xbb\x93\xe..."如何实现多功能计算器数据结构与算法"。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值