栈的应用
栈的应用
1.使用栈计算一个表达式的结果，如：7x2x5-3-6+5+9 （中缀表达式）
思路：创建两个栈，一个存储数据，一个存储用算符；
① 定义一个index索引，遍历表达式
② 如果为数字进入数据栈；
③ 若为符号，判断如果当前符号栈为null则直接压入，若不为null,则比较优先级大小，如果当前符号小于等于栈中符号优先级，就需要从数据栈栈中弹出两个数，从符号栈中弹出一个符号，进行与运算，将得到的结果入数据栈，然后将当前运算符入符号栈；如果当前符号大于栈中符号优先级，直接入符号栈；
④ 当表达式扫描完，就顺序从数栈和符号栈中pop出相应的数和符号，并运算；
⑤ 最后数栈中只有一个数，为结果；
package com.sratct.stack;
public class StackList {
public static void main(String[] args) {
StackArray numStack = new StackArray(10); // 数栈
StackArray operStack = new StackArray(10); // 符号栈
String expression = "30+2*6-2";
char[] chars = expression.toCharArray();
int num1 = 0; // 弹出第一个数
int num2 = 0; // 弹出第二个数
int val = 0; // 运算的结果
int oper = 0; //接收运算符
String keepNumber = ""; //用于拼接多位数
int i=0;
for (char ch : chars) {
// 判断当前的元素是不是运算符
if (operStack.isOper(ch)) {
// 是运算符，判断符号栈中是否有元素
if (!operStack.isEmpty()) {
// 不为空，判断当前运算符和符号栈中的运算符优先级，
if (operStack.priority(ch) <= operStack.priority(operStack.peek())) {
//小于等于， 从符号栈中pop出一个元素，从数栈中pop出两个元素,运算后结果入数栈
num1 = numStack.pop();
num2 = numStack.pop();
oper = operStack.pop();
val = operStack.cal(num1, num2, oper);
numStack.push(val);
operStack.push(ch);
} else {
//大于，直接插入
operStack.push(ch);
}
} else{
// 为空，直接插入
operStack.push(ch);
}
} else {
// 是数字时，不能立即入数栈，由于数字为字符会将多位数分成几个字符；如：13 ==> '1' 和 '3'
// 在处理多为数时，需要当前元素后再看一位，如果为符号则入数栈，不是则继续往后走；
// 每次将字符拼接到keepNumber中进行保存
keepNumber += ch;
// 如果ch是最后一位，则直接入入栈
if (i == expression.length()-1) {
numStack.push(Integer.parseInt(keepNumber));
} else {
// 判断下一位ch是不是数字，若为数字，继续看下一位，若为运算符，则入数栈
if (operStack.isOper(chars[i+1])) {
numStack.push(Integer.parseInt(keepNumber));
// 清空keepNumber
keepNumber = "";
}
}
}
i++;
}
// 当运算表达式循环完毕，就继续从符号栈中弹出一个，从数栈中弹出两个进行运算，直到符号栈中为空，最终数栈中剩下的为最终结果
while (true) {
if (operStack.isEmpty()) {
break;
}
num1 = numStack.pop();
num2 = numStack.pop();
oper = operStack.pop();
val = operStack.cal(num1,num2,oper);
numStack.push(val);
}
System.out.println(numStack.pop());
}
}
class StackArray {
private int maxSize;
private int top;
private int[] arrayStack;
public StackArray(int maxSize) {
this.maxSize = maxSize;
arrayStack = new int[maxSize];
top = -1;
}
// 判断栈是否为空
public boolean isEmpty() {
return top == -1;
}
// 判断栈是否满
public boolean isFull() {
return top == maxSize-1;
}
// 查看栈首元素
public int peek() {
return arrayStack[top];
}
// 入栈
public void push(int data) {
if (isFull()) {
System.out.println("栈已满");
return;
}
top++;
arrayStack[top] = data;
}
// 出栈
public int pop() {
if (isEmpty()) {
throw new RuntimeException("栈为null");
}
int temp = arrayStack[top];
top--;
return temp;
}
//遍历栈
public void getList() {
if (isEmpty()) {
System.out.println("栈为null");
return;
}
for (int i=top; i>=0; i--) {
System.out.println(arrayStack[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 val = 0;
switch (oper) {
case '-':
val = num2-num1; // 注意，后弹出的数减去前一个数
break;
case '+':
val = num1 + num2;
break;
case '*':
val =num1 * num2;
break;
case '/':
val = num2 / num1;
break;
default:
break;
}
return val;
}
}
2.前缀(波兰表达式)、中缀、后缀表达式(逆波兰表达式)
1） 前缀表达式的计算机求值
从右至左扫描的表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算，并将结果入栈，重复上述操作直到表达式的最左端，最后运算得到的值即为表达式的结果；
例如： （3+4）x 5 - 6对应的前缀表达式为： - x + 3 4 5 6 ,求值如下步骤：
① 从右至左扫描，将6、5、4、3压入堆栈；
② 遇到+号时，弹出3和4，计算3+4的值为7，再将7压入栈；
③ 接下来是 x 运算符，因此弹出7和5，计算7 x 5 =35,将35入栈；
④ 最后是 - 运算符，计算出35 - 6的值，即29，由此得到最终结果；
2） 中缀表达式
中缀表达式就是我们常见的表达式： （3+4）x 5 - 6
此表达式对我们人来说是非常容易计算，但是计算机就不好操作，计算机在计算结果时一般采用后缀表达式；
3）后缀表达式
① 后缀表达式又称逆波兰表达式
② 举例：（3+4）x 5 - 6对应的后缀表达式为3 4 + 5 x 6 -
③后缀表达式的计算机求值
从左至右扫描表达式，遇到数字，将数字压入栈中，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算，并将结果入栈，重复上述操作直到表达式的最左端，最后运算得到的值即为表达式的结果；
例如： （3+4）x 5 - 6对应的前缀表达式为：3 4 + 5 x 6 - ,求值如下步骤：
① 从左至右扫描，将3、4压入堆栈；
② 遇到+号时，弹出3和4，计算3+4的值为7，再将7压入栈；
③ 将5入栈
④ 接下来是 x 运算符，因此弹出5和7，计算7 x 5 =35,将35入栈；
⑤ 将6入栈
④ 最后是 - 运算符，计算出35 - 6的值，即29，由此得到最终结果；
