本文详细介绍了栈的概念、应用场景，特别是用栈实现综合计算器来处理中缀表达式。还探讨了前缀、中缀、后缀表达式，包括它们的计算机求值方法，以及如何将中缀表达式转化为后缀表达式。通过实例展示了逆波兰计算器的工作原理和代码实现。
栈
栈的概念
1)栈的英文为(stack)
2)栈是一个先入后出(FILO-First In Last Out)的有序列表。
3)栈(stack)是限制线 性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶（Top)，另中一端为固定的一 端，称为栈底(Bottom)。
4)根据栈的走义可知，最先放入栈中元素在栈底，最后放入的元素在栈项，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除
栈的应用场景
1)子程序的调用:在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中。
2)处理递归调用:和子程序的调用类似，只是除了储存下一个指令的地址外，也将参数、区域变量等数据存入堆栈中。
3)表达式的转换 [中缀表达式转后缀表达式]与求值(实际解决)。
- 二叉树的遍历。
5)图形的深度优先(depth一first)搜索法。
用数组模拟栈
代码实现
package com.zhao.stack;
public class ArrayStackDemo {
public static void main(String[] args) {
ArrayStack stack = new ArrayStack(50);
for (int i=1;i<20;i++){
stack.push(i);
}
stack.pop();
stack.pop();
stack.pop();
stack.pop();
stack.list();
}
}
//定义一个ArrayStack 表示栈
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 isFull(){
return top == maxSize-1;
}
//栈空
public boolean isEmpty(){
return top == -1;
}
//入栈
public void push(int value){
if (isFull()){
System.out.println("栈已经满了");
return;
}
top++;
stack[top] = value;
}
//出栈
public int pop(){
if (isEmpty()){
new RuntimeException("栈空，没东西");
}
int value = stack[top];
top--;
return value;
}
//遍历栈
public void list(){
if (isEmpty()){
System.out.println("空了，没东西");
return;
}
for (int i=top;i>=0;i--){
System.out.printf("stack[%d]=%d \n",i,stack[i]);
}
}
}
用栈实现综合计算器(中缀表达式)
图解思路
代码实现
package com.zhao.stack;
import javax.lang.model.element.NestingKind;
public class Calculator {
public static void main(String[] args) {
String expression = "80+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 aChar = ' '; //将每次扫描得到char保存到ch
String keepNum ="";//用于拼接多位数
//开始扫描字符串
while(true){
//依次得到expression的每一个字符
aChar = expression.substring(index,index+1).charAt(0);
//判断aCher是什么
if (operStack.isOper(aChar)) {//如果是运算符
//判断当前的符号栈是否为空
if (!operStack.isEmpty()) {
//如果符号栈有操作符，就进行比较,如果当前的操作符的优先级小于或者等于栈中的操作符,就需要从数栈中pop出两个数。
//在从符号栈中pop出一个符号，进行运算，将得到结果，入数栈,然后将当前的操作符入符号栈
if (operStack.priority(aChar) <= operStack.priority(operStack.peek())) {
num1 = numStack.pop();
num2 = numStack.pop();
oper = operStack.pop();
res = numStack.cal(num1, num2, oper);
//把运算结果入数栈
numStack.push(res);
//然后将当前的操作符入符号栈
operStack.push(aChar);
} else {
//如果当前的操作符的优先级大于栈中的操作符，就直接入符号栈。
operStack.push(aChar);
}
} else {
//如果为空直接入符号栈
operStack.push(aChar);
}
}else {//如果是数，则直接入数栈
//numStack.push(aChar - 48);//因为取出来的时字符串”1“
//如果是一个多位数，不能发现一个数就立即入栈
//分析思路
//1.当处理多位数时，不能发现是一个数就立即入栈，因为他可能是多位数
//2.在处理数，需要向expression的表达式的index后再看一位,如果是数就进行扫描，如果是符号才入栈
//3.因此我们需要定义一个变量字符串，用于拼接
//处理多位数
keepNum += aChar;
//如果是最后一位则不需要判断，直接入栈
if (index == expression.length()-1){
numStack.push(Integer.parseInt(keepNum));
keepNum = "";
}else {
//判断下一个字符是不是数字，如果是数字，就继续扫描，如果是运算符，则入栈
//注意是看后一位,不是index++
if (operStack.isOper(expression.substring(index + 1, index + 2).charAt(0))) {
//如果后一位是运算符，则入栈
numStack.push(Integer.parseInt(keepNum));
//keepNum清空
keepNum = "";
}
}
}
//让index+1，并判断是否扫描到最后
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,res);
}
}
//定义一个ArrayStack 表示栈
class ArrayStack2{
private int maxSize; //栈的大小
private int[] stack; //数组，数组模拟栈，数据就放在该数组
private int top = -1;// top表示栈顶，初始化为-1
//构造器
public ArrayStack2(int maxSize) {
this.maxSize = maxSize;
stack = new int[this.maxSize];
}
//查看栈顶的方法
public int peek(){
return stack[top];
}
//栈满
public boolean isFull(){
return top == maxSize-1;
}
//栈空
public boolean isEmpty(){
return top == -1;
}
//入栈
public void push(int value){
if (isFull()){
System.out.println("栈已经满了");
return;
}
top++;
stack[top] = value;
}
//出栈
public int pop(){
if (isEmpty()){
new RuntimeException("栈空，没东西");
}
int value = stack[top];
top--;
return value;
}
//遍历栈
public void list(){
if (isEmpty()){
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){
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;
}
}
前缀、中缀、后缀表达式(逆波兰表达式)
前缀表达式(波兰表达式)
1)前缀表达式又称波兰式，前缀表达式的运算符位于操作数之前
2)举例说明: (3+4)X5-6 对应的前缀表达式就是 - X + 3 4 5 6
前缀表达式的计算机求值
从有至左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈项的两个数，用运算符对它们做相应的计算(栈顶元素和次顶元素)，并将结果入栈;重复上述过程直到表达式最左端，最后运算得出的值即为表达式的结果
例如: (3+4)X5-6对应的前缀表达式就是- x + 3 4 5 6,针对前缀表达式求值步骤如下:
1)从右至左扫描，将6、5、4、3压入堆栈
2)遇到+运算符，因此弹出3和4 (3为栈顶元素，4为次顶元素)，计算出3+4的值，得7,再将7入栈
3)接下来是x运算符，因此弹出7和5， 计算出7x5=35，将35入栈
4)最后是-运算符，计算出35-6的值，即29，由此得出最终结果
中缀表达式
1)中缀表达式就是常见的运算表达式，如(3+4)X5-6
2) 中缀表达式的求值是我们人最熟悉的，但是对计算机来说却不好操作(前面我们讲的案例就能看的这个问题)，因此，在计算结果时，往往会将中缀表达式转成其它表达式来操作
后缀表达式
1)后缀表达式又称逆波兰表达式与前缀表达式相似，只是运算符位于操作数之后
2)举例说明: (3+4)X5-6 对应的后缀表达式就是34+5 X 6-
后缀表达式的计算机求值
从左至右扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算(次顶元素和栈顶元素)，并将结果入栈;重复上述过程直到表达式最右端，最后运算得出的值即为表达式的结果
例如: (3+4)X5-6对应的后缀表达式就是3 4 + 5 X 6 -,针对后缀表达式求值步骤如下:
1)从左至右扫描，将3和4压入堆栈;
2)遇到+运算符， 因此弹出4和3 (4为栈项元素，3为次项元素)，计算出3+4的值，得7，再将7入栈;
3)将5入栈;
4) 接下来是x运算符，因此弹出5和7，计算出7x5=35，将35入栈;
5) 将6入栈;
6) 最后是-运算符，计算出35-6的值， 即29， 由此得出最终结果
逆波兰计算器
我们完成一个逆波兰计算器，要求完成如下任务:
1)输入一个逆波兰表达式(后缀表达式)，使用栈(Stack),计算其结果
2)支持小括号和多位数整数，因为这里我们主要学的是数据结构，因此计算器进行简化，只支持对整数的计算。
3）思路分析
例如: (3+4)X5-6对应的后缀表达式就是
3 4 + 5 X 6 -,针对后缀表达式求值步骤如下: 1)从左至右扫描，将3和4压入堆栈;
2)遇到
+运算符， 因此弹出4和3 (4为栈项元素，3为次项元素)，计算出3+4的值，得7，再将7入栈; 3)将5入栈;
4) 接下来是
x运算符，因此弹出5和7，计算出7x5=35，将35入栈; 5) 将6入栈;
6) 最后是
-运算符，计算出35-6的值， 即29， 由此得出最终结果
4）代码完成
package com.zhao.stack;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
public class PolandNotation {
public static void main(String[] args) {
//先定义给逆波兰表达式
//(3+4)x5-6 => 34+5x6-=> 29
//说明为了方便，逆波兰表达式的数字和符号使用空格隔开
String suffixExpression = "30 4 + 5 * 6 -";
//思路
//1.先将"(3+4)+5x6" =>放到ArrayList中
//2.将ArrayList传递给一个方法， 遍历ArrayList配合栈完成计算
List<String> stringList = getListString(suffixExpression);
System.out.println(stringList);
int calculate = calculate(stringList);
System.out.println("计算结果："+calculate);
}
//将一个逆波兰表达式，依次将数据和运算符放入到ArrayList中
public static List<String> getListString(String suffix){
//将suffix分割
String[] strings = suffix.split(" ");
List<String> list = new ArrayList<>();
for (String s:strings){
list.add(s);
}
return list;
}
/**
* 完成对逆波兰表达式的计算
* 例如: (3+4)X5-6对应的后缀表达式就是`3 4 + 5 X 6 -`,针对后缀表达式求值步骤如下:
* 1)从左至右扫描，将3和4压入堆栈;
* 2)遇到`+`运算符， 因此弹出4和3 (4为栈项元素，3为次项元素)，计算出3+4的值，得7，再将7入栈;
* 3)将5入栈;
* 4) 接下来是`x`运算符，因此弹出5和7，计算出`7x5=35`，将35入栈;
* 5) 将6入栈;
* 6) 最后是`-`运算符，计算出`35-6`的值， 即29， 由此得出最终结果
*/
public static int calculate(List<String> list){
//创建一个栈
Stack<String> stack = new Stack<>();
//遍历list
for (String item : list){
//使用正则表达式来去出数
if (item.matches("\\d+")){//匹配的是多位数
//入栈
stack.push(item);
}else {
//pop取出两个数，并运算，在入栈
int n1 = Integer.parseInt(stack.pop());
int n2 = Integer.parseInt(stack.pop());
int res = 0;
switch (item){
case "+":
res = n2 + n1;
break;
case "-":
res = n2 - n1;
break;
case "*":
res = n2 * n1;
break;
case "/":
res = n2 / n1;
break;
default:
new RuntimeException("由特殊符号");
break;
}
stack.push(""+res);
}
}
return Integer.parseInt(stack.pop());
}
}
中缀表达式 转化为 后缀表达式
大家看到，后缀表达式适合计算式进行运算，但是人却不太容易写出来，尤其是表达式很长的情况下，因此在开发中，我们需要将中缀表达式转成后缀表达式。
具体步骤如下:
- 初始化两个栈:运算符栈s1和储存中间结果的栈s2;
- 从左至右扫描中缀表达式；
- 遇到操作数时，将其压s2;
- 遇到运算符时，比较其与s1栈项运算符的优先级:
- 如果s1为空，或栈项运算符为左括号“(”， 则直接将此运算符入栈;
- 否则，若优先级比栈顶运算符的高，也将运算符压入s1;
- 否则，将s1栈项的运算符弹出并压入到s2中，再次转到(4-1)与s1中新的栈顶运算符相比较;
- 遇到括号时:
- 如果是左括号“(”，则直接压入s1
- 如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃
- 重复步骤2至5，直到表达式的最右边
- 将s1 中剩余的运算符依次弹出并压入s2
- 依次弹出s2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式
图解：
package com.zhao.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)x4)-5 => 转成 123+4x+5-
//2.因为直接对str. 进行操作，不方便，因此先将"1+((2+3)x4)-5" =》中缀的表达式对应的List
//即"1+((2+3)x4)-5" => ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]
//3.将得到的中缀表达式对应的List =>后缀表达式对应的List
//即ArrayList [1,+,(,(,2,+,3,),*,4,),-,5] =》 ArrayList [1,2,3,+,4,*,+,5,-]
String expression = "1+((2+3)*4)-5";
List<String> list = toInfixExpressionList(expression);
System.out.println(list);
List<String> suffixList = parseSuffixList(list);
System.out.println(suffixList);
int calculate = calculate(suffixList);
System.out.println(calculate);
/*
//先定义给逆波兰表达式
//(3+4)x5-6 => 34+5x6-=> 29
//说明为了方便，逆波兰表达式的数字和符号使用空格隔开
String suffixExpression = "30 4 + 5 * 6 -";
//思路
//1.先将"(3+4)+5x6" =>放到ArrayList中
//2.将ArrayList传递给一个方法， 遍历ArrayList配合栈完成计算
List<String> stringList = getListString(suffixExpression);
System.out.println(stringList);
int calculate = calculate(stringList);
System.out.println("计算结果："+calculate);
*/
}
//方法：将得到的中缀表达式对应的List =>后缀表达式对应的List
public static List<String> parseSuffixList(List<String> ls){
//定义两个栈
Stack<String> s1 = new Stack<>();
//说明:因为s2这个栈，在整个转换过程中,没有pop操作，而且后面我们还需要逆序输出
//因此比较麻烦,这里我们就不用Stack<String>直接使用List<String> s2
//Stack<String> s2 = new Stack<String>(); //储存中间结果的栈s2
List<String> s2 = new ArrayList<>();
//遍历ls
for (String item : ls){
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();//舍弃左括号
}else {
//当item的优先级小于等于s1栈顶运算符，将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;
}
//方法:将中缀表达式转成对应的List
public static List<String> toInfixExpressionList(String s){
//定义一个List，存放中缀表达式对应的内容
List<String> ls = new ArrayList<>();
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++;//i后移
}else {//如果是一个数，要考虑多位数
str = "";
if (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;
}
//将一个逆波兰表达式，依次将数据和运算符放入到ArrayList中
public static List<String> getListString(String suffix){
//将suffix分割
String[] strings = suffix.split(" ");
List<String> list = new ArrayList<>();
for (String s:strings){
list.add(s);
}
return list;
}
/**
* 完成对逆波兰表达式的计算
* 例如: (3+4)X5-6对应的后缀表达式就是`3 4 + 5 X 6 -`,针对后缀表达式求值步骤如下:
* 1)从左至右扫描，将3和4压入堆栈;
* 2)遇到`+`运算符， 因此弹出4和3 (4为栈项元素，3为次项元素)，计算出3+4的值，得7，再将7入栈;
* 3)将5入栈;
* 4) 接下来是`x`运算符，因此弹出5和7，计算出`7x5=35`，将35入栈;
* 5) 将6入栈;
* 6) 最后是`-`运算符，计算出`35-6`的值， 即29， 由此得出最终结果
*/
public static int calculate(List<String> list){
//创建一个栈
Stack<String> stack = new Stack<>();
//遍历list
for (String item : list){
//使用正则表达式来去出数
if (item.matches("\\d+")){//匹配的是多位数
//入栈
stack.push(item);
}else {
//pop取出两个数，并运算，在入栈
int n1 = Integer.parseInt(stack.pop());
int n2 = Integer.parseInt(stack.pop());
int res = 0;
switch (item){
case "+":
res = n2 + n1;
break;
case "-":
res = n2 - n1;
break;
case "*":
res = n2 * n1;
break;
case "/":
res = n2 / n1;
break;
default:
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 = 1;
private static int DIV = 1;
public static int getValue(String operation){
int result = 0;
switch (operation){
case "+":
result = ADD;
break;
case "-":
result = SUB;
break;
case "*":
result = MUL;
break;
case "/":
result = DIV;
break;
default:
break;
}
return result;
}
}
扫一扫
751
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
