栈的原理以及应用（制作一个简单的计算器）

最新推荐文章于 2023-02-19 23:18:23 发布
最新推荐文章于 2023-02-19 23:18:23 发布
阅读量733 收藏 3
点赞数 1
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lzinner/article/details/102757460
版权

说在前面

其实有一段时间没有更新了，主要是这段时间学习了很多很多的新东西。现在也渐渐做一些整理

栈(stack)

1.基础介绍
1.栈是一种先入后出(FILO)的有序列表
2.栈是限制线性表中元素插入和删除只能在线性表同一侧进行的一种特殊线性表，允许插入和删除的一端称为变化的一端，称为栈顶。另一端为固定的一端，称为栈底
3.根据栈的定义可知，先放进去的在栈底，最后放入的在栈顶，而删除元素正好相反
4.类似往手枪中压子弹

从小甲鱼那里白嫖的图...

2.应用场景
1.处理递归调用
2.表达式的转换(中缀转后缀)和求值
3.二叉树遍历
4.深度优先搜索景
3.栈的代码实现

注：由于栈是一种有序列表，所以可以使用数组的结构来存储栈的数据内容

3-1:创建栈
定义一个top表示栈顶，初始化为-1,定义一个数组(int[]stack)来表示栈 同时定义一个变量初始化数组的最大值

//栈结构
public class ArrayStack {
    private int maxSize;//栈的大小
    private int[] stack;//数组，将数组模拟栈，数据就放在该数组中
    private int top = -1; //top表示栈顶，初始化为-1

    public ArrayStack(int _maxSize) {
        this.maxSize = _maxSize;
        stack = new int[this.maxSize];
    }
    
	 //判断栈满
    public boolean isStackFull() {
        return top == maxSize - 1;
    }

    //判断栈空
    public boolean isStackEmpty() {
        return top == -1;
    }

3-2:入栈
首先判断栈是否为满，当有数据(data)加入到栈时,栈顶指针++ 将数据存入栈

 //入栈:将数据压入栈中
    public void pushToStack(int value) {
        if (isStackFull()) {
            System.out.println("栈已经满了");
            return;
        }
        //入栈成功
//        top++;
//        stack[top] = value;
        stack[++top]=value;
    }

3-3:出栈
首先判断栈是否为空，当有数据需要出栈时，通过辅助指针拿到栈顶数据，栈顶指针–, 返回出栈值

 //出栈:将数据从栈中取出
    public int popFromStack() {
        if (isStackEmpty()) {
            throw new RuntimeException("栈已经空了");
        }
        //保存栈顶值
        int tempNum = stack[top];
        top--;
        return tempNum;
        //return stack[top--];
    }

3-4:遍历
遍历时需要从栈顶开始显示数据

 //遍历:需要从栈顶取出数据
    public void listStack() {
        if (isStackEmpty()) {
            System.out.println("栈空，没有数据");
            return;
        }
        for (int i = top; i >= 0; i--) {
            System.out.printf("stack[%d]=%d\n", i, stack[i]);
        }
    }

3-5:测试代码

package stack;

import java.util.Scanner;

public class ArrayStackDemo {
    public static void main(String[] args) {
        ArrayStack stack = new ArrayStack(4);
        String key = "";
        boolean loop = true;
        Scanner scanner = new Scanner(System.in);

        while (loop) {
            System.out.println("show:表示显示栈");
            System.out.println("exit:退出程序");
            System.out.println("push:入栈");
            System.out.println("pop:出栈");
            System.out.println("请输入你的选择");
            key = scanner.next();
            switch (key) {
                case "show":
                    stack.listStack();
                    break;
                case "push":
                    System.out.println("请输入一个数");
                    int value = scanner.nextInt();
                    stack.pushToStack(value);
                    break;
                case "pop":
                    try {
                        int res = stack.popFromStack();
                        System.out.println("出栈值为:" + res);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    break;
                case "exit":
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出了···");
    }
}
栈的应用实例:实现一个简单的计算器

如何使用栈完成计算简单计算器？

 思路一览:
 
 假设计算一个表达式的结果:3+2*6-2
    1.设置两个栈，一个为数栈，一个为符号栈
        数栈(numStack):存放数据
        符号栈(operStack): 存放运算符

    2.先创建一个index标志位，通过index值(索引)用来对字符串进行扫描，来遍历我们的表达式


    3.如果发现扫描到的是一个数字
        3-1.当处理多位数的时候 不能发现是一个数就直接入数栈 因为可能是多位数
        3-2.在处理数时，需要向expression的表达式的index 后再看一位，
                如果是数就继续扫描(无操作)
                如果是符号就直接让数入栈
        3-3.因此，我们需要定义一个变量(字符串)，用于拼接


    4.如果发现扫描到的是一个符号，就分如下情况解决:
        4-1:如果发现当前符号栈为空，就直接入栈
        4-2:如果符号栈有操作符，就进行比较，
                如果当前的操作符的优先级小于或者等于栈中的操作符，这时，就需要从数栈中pop出两个数，然后从符号栈中pop出一个符号，进行运算，将得到的结果入数栈。还要把当前的操作符入符号栈.
                如果当前的操作符的优先级大于栈中的操作符，就直接入栈即可
                (操作均为 后面一个数 符号 前面一个数)

    5.当表达式扫描完毕的时候，就顺序的从数栈和符号栈中pop出相应的数和符号，并运算。

    6.最后数栈只有一个数字 就是我们的结果

//重新准备一个栈 和上面的栈思路一致
package simple_calc;
//栈结构
public class MyStack {
    private int maxSize;//栈的大小
    private int[] stack;//数组，将数组模拟栈，数据就放在该数组中
    private int top = -1; //top表示栈顶，初始化为-1
    public MyStack(int _maxSize) {
        this.maxSize = _maxSize;
        stack = new int[this.maxSize];
    }

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

    //判断栈空
    public boolean isStackEmpty() {
        return top == -1;
    }

    //入栈:将数据压入栈中
    public void pushToStack(int value) {
        if (isStackFull()) {
            System.out.println("栈已经满了");
            return;
        }
        //入栈成功
//        top++;
//        stack[top] = value;
        stack[++top] = value;
    }

    //出栈:将数据从栈中取出
    public int popFromStack() {
        if (isStackEmpty()) {
            throw new RuntimeException("栈已经空了");
        }
        //保存栈顶值
        int tempNum = stack[top];
        top--;
        return tempNum;
        //return stack[top--];
    }

    //遍历:需要从栈顶取出数据
    public void listStack() {
        if (isStackEmpty()) {
            System.out.println("栈空，没有数据");
            return;
        }
        for (int i = top; i >= 0; i--) {
            System.out.printf("stack[%d]=%d\n", i, stack[i]);
        }
    }

    //返回运算符的优先级，优先级是程序员决定的。优先级使用数字表示，数字越大 则优先级越高
    public int priority(int oper) {
        /**
         * 在java中 char在进行比较的时候 底层依旧是使用int型进行比较的
         * */
        if (oper == '*' || oper == '/') {
            return 1;
        } else if (oper == '+' || oper == '-') {
            return 0;
        } else {
            return -1;//假定目前表达式只有加减乘除
        }
    }

    public boolean isOper(char val) {
        return val == '+' || val == '-' || val == '*' || val == '/';
    }

    //计算方法 次出栈数-首先出栈数
    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;
    }
    //返回当前栈顶的值,但是不是真正的出栈
    public int peek(){
        return stack[top];
    }
}



//开始建立计算器:
package simple_calc;
public class Calculator {
    public static void main(String[] args) {
        //根据的思路 完成表达式的运算
        String expression = "30+2*6-2";
        //1.创建两个栈(数字栈和符号栈)
        MyStack numStack = new MyStack(10);
        MyStack operStack = new MyStack(10);
        //2.定义需要的相关变量
        //用于扫描
        int index = 0;
        //定义操作数
        int num1 = 0;
        int num2 = 0;
        //定义操作符
        int oper = 0;
        //定义结果数
        int res = 0;
        //将每次得到的char保存到ch中
        char ch = ' ';
        String keepNum = "";//用于拼接多位数
        //开始循环扫描
        while (true) {
            //!!!依次得到expression 的每一个字符
            ch = expression.substring(index, index + 1).charAt(0);
            //判断ch是什么 进行相应的处理
            //ch为符号
            if (operStack.isOper(ch)) {//如果是运算符
                if (!operStack.isStackEmpty()) {
                    // 如果当前的操作符的优先级小于或者等于栈中的操作符，这时，就需要从数栈中pop出两个数，然后从符号栈中pop出一个符号，进行运算，将得到的结果入数栈。还要把当前的操作符入符号栈.
                    if (operStack.priority(ch) <= operStack.priority(operStack.peek())) {
                        num1 = numStack.popFromStack();
                        num2 = numStack.popFromStack();
                        oper = operStack.popFromStack();
                        res = numStack.cal(num1, num2, oper);
                        //将运算结果入数栈
                        numStack.pushToStack(res);
                        //操作符入符号栈
                        operStack.pushToStack(ch);
                    }
                    // 如果当前的操作符的优先级大于栈中的操作符，就直接入栈即可
                    else {
                        operStack.pushToStack(ch);
                    }
                    // 操作均为 后面一个数 符号 前面一个数

                } else {
                    //如果为空直接入符号栈
                    operStack.pushToStack(ch);
                }
            }
            //ch为数字
            else {
                //如果是数字 则直接入数栈!!! 注意这里 char和int的转换
                //如果是多位数的话 需要进行操作

                // numStack.pushToStack(ch-48);
                /**
                 * 1.当处理多位数的时候 不能发现是一个数就直接入数栈 因为可能是多位数
                 * 2.在处理数时，需要向expression的表达式的index 后再看一位，如果是数就继续扫描如果是符号就直接让数入栈
                 * 3.因此，我们需要定义一个变量(字符串)，用于拼接
                 * */
                keepNum += ch;
                //如果ch已经是expression的最后一位 直接入栈
                if (index == expression.length() - 1) {
                    numStack.pushToStack(Integer.parseInt(keepNum));
                } //如果ch不是expression的最后一位
                else {
                    //寻找当前位的后一位
                    if (operStack.isOper(expression.substring(index + 1, index + 2).charAt(0))) {
                        //如果后一位是运算符 则入栈
                        numStack.pushToStack(Integer.parseInt(keepNum));
                        //将keepNum清空!!
                        keepNum = "";
                    }
                }
            }
            //继续扫描
            index++;
            if (index >= expression.length()) {
                break;
            }
        }
        //扫描完毕 开始计算
        while (true) {
            if (operStack.isStackEmpty()) {
                break;
            }
            num1 = numStack.popFromStack();
            num2 = numStack.popFromStack();
            oper = operStack.popFromStack();
            res = numStack.cal(num1, num2, oper);
            numStack.pushToStack(res);
        }
        System.out.printf("表达式 %s = %d ", expression, numStack.popFromStack());
    }
}

在这里插入图片描述

ks_zhe
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构用栈制作简易计算器
04-27
编写程序，完成手机计算机器中的简单表达式求值，完成+、-、*、/、% 五种混合运算。（难度分为六级） 基本要求：无括号、整数 中级要求：有括号、整数 高级要求：有括号、多位整数 超级要求：有括号、小数 ...
老韩数据结构-栈实现简单计算器运算（图解+代码）
快乐学术猿
08-29 741
目录基本思路压栈过程图解过程特殊情况处理代码 基本思路 对于一个字符串运算表达式5+10*6-4 定义一个指针从左往右遍历表达式，分别将数字和运算符压入数栈和运算符栈中。 最后从数栈和运算符栈中分别pop出元素进行运算 压栈过程 对于指针所指元素为数字： 直接入数栈 对于指针所指元素为运算符： 如果运算符栈为空，则直接入栈 如果运算符栈栈顶运算符优先级小于指针所在运算符，则指针所指运算符直接入栈 如果运算符栈栈顶运算符优先级大于指针所在运算符，则从数栈中弹出两个数，从符号栈中弹出一个运算符，进行
使用栈实现简单计算器
Little Big Us的博客
10-24 1204
描述： 输入一串字符串，输出它的计算结果。//考虑输入不正确的情况 例如输入：722-5+1-5+3-4 输出18 代码如下： public static void main(String[] args) { Scanner sc = new Scanner(System.in); String str = sc.next(); Stack<Character> stack2 = new Stack<>();
(3)栈原理与应用场景讲解
大表哥的博客
09-05 1982
1.顺序栈和链表栈 (1)顺序栈 ①顺序栈基于数组，数组满时需要动态扩容 ②代码实现 // 基于数组实现的顺序栈 public class ArrayStack { private String[] items; // 数组 private int count; // 栈中元素个数 private int n; //栈的大小 // 初始化数组，申请一个大小为n的数组空间 public ArrayStack(int n) { thi
数据结构学习笔记(7.栈的应用及简单的计算器)
qq418674358的专栏
03-22 3092
本节知识点： 1.栈的应用一：编译器中成对符号匹配的检查！如：括号 ：() 、{} 、[] 引号：'单引号' 、 “双引号” 这些符号匹配情况的检查！ 算法思路： 这里有一个问题是需要注意的：就是单引号和双引号在使用的时候，是需要借助转移字符的！ 示例代码： main.c文件： #include <stdio.h> #include <stdli...
栈实现综合计算器（2）
wangjiaju960914的博客
08-31 181
栈实现综合计算器（2） 优点：可以实现多位数的加减乘除的计算 缺点：中缀表达式的求值是我们人最熟悉的，但是对计算机来说却不好操作。 思路分析 当我们把表达式存储在一个字符串当中时候，每次用index去扫描，对于多位数，我们就可以看作是多个单个字符串的拼接。 因此，每次当我们利用index进行扫描读取数据的时候，还需要考虑index的下一位，如果是数据的话，就继续向下一位扫描，直到是操作符为止 然后将数据拼接后，可以利用包装类再将字符串转换成数据的形式，便于接下去的计算操作。 代码实现 其余部分的代码详细
一个用栈实现的简易计算机。
m0_71847201的博客
02-19 124
一个用栈实现的简易计算器
用栈写一个计算器
weixin_50125130的博客
04-28 161
计算器 希望：用户直接输入一个中缀表达式（字符串）给计算机 然后计算机计算出结果。 思路 创建两个栈一个存储数s1，另一个存储运算符号s2，对用户传入的字符串用index进行一个一个遍历。 如果遍历的数，直接入数栈s1。 因为对字符串遍历是一个一个进行的，当遍历多位数时不能直接入栈，要检验后一位是否为数字，直到后一位是符号才结束遍历 如果遍历的是符号，若符号栈s2，为空直接入栈 1.若是左括号“（”直接入栈 2. 若是遇到右括号“）” ，则从数栈中弹出两个数，符号栈中弹出一个符号进行运算，运算的结果
栈的应用-计算器实现
07-20
可执行程序可以实现数学计算公式的复杂运算。下载压缩包后需要减压文件，在目录下在linux命令行输入要计算的公式的字符串即可求出结果，例如在linux命令行下输入执行命令 ：./calculator "1+2*3-(6-3)*2+4-1" 即可求...
C++实现一个简单的表达式计算器
02-13
这个计算机实现了： 1. 基本计算 (e * ** / % + -) * 括号的处理会让代码逻辑变得混乱得多，所以还没实现左右括号 * 仅支持二元操作符 * 支持小数 2. 优先级 3. 错误回显：可指出出错位置、原因 4. 中间...
设计一个简易计算器，包含一个计算器类
10-23
设计一个简易计算器，首先接收一个后缀表达式字符串，然后将中缀表达式转换为后缀表达式，接着对后缀表达式进行计算，最后将得到的值返回
栈 简易计算器
10-09
简易计算器满足输入中缀表达式转化为后缀表达式并能计算结果（只满足个位数字） codeblocks上测试
[栈 字符串] 224. 基本计算器（栈的应用：符号栈+数字栈+出入栈规则、字符串解析） 227.基本计算器 II（出入栈规则、字符串解析）
m0_38142029的博客
09-30 527
[栈 字符串] 224. 基本计算器（栈的应用：符号栈+数字栈+出入栈规则、字符串解析）224. 基本计算器思路：栈 + 字符串解析实现遇到的问题：数字截取问题 224. 基本计算器 题目链接：https://leetcode-cn.com/problems/basic-calculator/ 分类： 栈（开辟符号栈、数字栈，设计出入栈规则，实现带括号的加减法） 数学/字符串（分析+实现基本计算器的功能，实质上是对字符串的解析：对数字、括号字符、加减法号的提取） 思路：栈 + 字符串解析 开辟两个
栈的实现原理及应用
qq_54017644的博客
10-14 530
栈的实现原理及应用
数组实现栈
xiaoxiaoxiaopb的博客
09-08 745
栈 栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。 数组实现栈 代码如下 public class ArrayStack { private int maxSize; private int top; p
栈的应用——编写简单计算器
weixin_45693164的博客
03-16 448
如何用栈写出一个简单计算器 数据结构 实验报告 日期：2020.3.15 一、实验目的和要求 栈的应用 实现简易计算器 二、实验环境 软件环境：Vs2017 硬件环境：①CPU：Intel（R）Core（TM）i7-8565U CPU @1.80Ghz ②内存：16.0GB 三、实验内容 任务：利用栈编写十进制整数的简易计算器【只包括±*/()这五个符号】 四、实验过程 用文字、...
用栈写计算器
这个人很懒什么都没有留下
05-21 104
package tu; import java.lang.reflect.Array; import java.math.BigInteger; import java.util.*; public class Main { public static void main(String[] args) { Main1 arr=new Main1(10); String exper = "111+111*6555"; Main1 oper=new Main1(10); int index
栈实现简单的计算器
zjq_smile的博客
03-17 656
上个星期的作业，现在才改好。。。。。 基本思路： 当我们从键盘上输入一串字符，比如1+(2+3),建立两个栈，一个存放运算符的栈toperator，一个存放操作数number，依次遍历。 遇到操作数就依次存放到操作栈里； 遇到运算符时，优先级高的就直接压进运算符栈里，优先级低的就依次弹出操作栈中的两个值与运算符进行计算，然后把计算的值再次压进操作数栈里。其中有括号的情况，左括号的直接压进，
数据结构小白之顺序二叉树
Lzinner的博客
11-23 1286
1.什么是顺序二叉树 从数据存储而言，数据存储的方式和树的存储方式可以进行相互的转换，即: 数组可以转换为树，而树可以转换为数组 2.顺序二叉树的特点 . 顺序二叉树一般只考虑完全二叉树 . 顺序二叉树第n个元素的左子节点为2*n+1 . 顺序二叉树第n个元素的右子节点为2*n+2 . 顺序二叉树第n个元素的父节点为(n-1)/2 康康图解: 3.如何进行数组和顺序...
实现一个简单的计算器,c 栈
最新发布
10-23
实现一个简单的计算器可以借助于c中的栈数据结构。 首先，我们可以定义一个栈结构，用来存储计算器需要的操作数和操作符。一般来说，栈中的元素可以包括数字和符号两种类型。 然后，我们可以通过使用栈来解析输入的表达式。遍历输入的表达式，当遇到数字时，将其压入栈中；当遇到操作符时，从栈中弹出两个数字进行运算，并将结果压入栈中。 具体步骤如下： 1. 创建一个栈，用来存储操作数和操作符。 2. 遍历输入的表达式，对于每一个字符： - 如果是数字，将其转换成整数并将其压入栈中。 - 如果是操作符，从栈中弹出两个操作数，并按照该操作符进行运算，将结果压入栈中。 3. 最后，将栈中的最后一个元素弹出，即为计算结果。 以下是一个简单的示例代码： ```c #include <stdio.h> #include <stdlib.h> #include <string.h> // 定义栈结构 typedef struct { int top; int *data; } Stack; // 初始化栈 void initStack(Stack *stack, int maxSize) { stack->top = -1; stack->data = (int*)malloc(maxSize * sizeof(int)); } // 压栈 void push(Stack *stack, int num) { stack->data[++stack->top] = num; } // 弹栈 int pop(Stack *stack) { return stack->data[stack->top--]; } // 判断栈是否为空 int isEmpty(Stack *stack) { return stack->top == -1 ? 1 : 0; } // 实现简单的计算器 int calculate(char *expression) { int len = strlen(expression); Stack stack; initStack(&stack, len); for (int i = 0; i < len; i++) { if (expression[i] >= '0' && expression[i] <= '9') { push(&stack, expression[i] - '0'); } else { int num1 = pop(&stack); int num2 = pop(&stack); switch (expression[i]) { case '+': push(&stack, num1 + num2); break; case '-': push(&stack, num2 - num1); break; case '*': push(&stack, num2 * num1); break; case '/': push(&stack, num2 / num1); break; } } } int result = pop(&stack); free(stack.data); return result; } int main() { char expression[] = "3 4 + 5 *"; int result = calculate(expression); printf("计算结果：%d\n", result); return 0; } ``` 上述代码实现了一个简单的计算器，可以计算输入表达式的结果。例如，在主函数中，我们将中缀表达式"3 4 + 5 \*"传递给calculate函数进行计算，并输出结果。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值