目录
一.中缀表达式
使用栈完成表达式的思路分析：
1.通过一个index值(索引)，来遍历我们的表达式2如果我们发现是一个数字,就直接入数栈
3.如果发现扫描到是一个符号,就分如下情况
3.1如果发现当前的符号栈为空，就直接入钱
3.2如果符号栈有操作符，就进行比较,如果当前的操作符的优先级小于或者等于楼中的操作符，就需要从数栈中pop出两个数在从符号栈中pop出一个符号，进行运算，将得到结果，入数栈，然后将当前的操作符入符号栈，如果当前的操作符的优先级大于栈中的操作将,就直接入符号栈
4.当表达式扫描完毕，就顺序的从数栈和符号栈中pop出相的数和符号，并运行.5.最后在数栈只有一个数字，就是表达式的结果
1.栈代码：
package com.ws;
public class ArrayStack {
//栈的最大空间
private int maxTop;
private int stack[];
private int top;
private int bottom;
//构造器
public ArrayStack(int maxTop) {
this.maxTop = maxTop;
stack = new int[maxTop];
top = -1;
bottom = -1;
}
/**
* 判断栈是否已满
* @return true 满 ； false 没满
*/
public boolean isFull() {
if (top == maxTop - 1) {
return true;
}
return false;
}
/**
* 判断栈是否为空
* @return true 空 ； false 没空
*/
public boolean isEmpty() {
if (top == bottom) {
return true;
}
return false;
}
/**
* 入栈
* @param num
*/
public void push(int num) {
if (isFull()) {
System.out.println("栈已满 无法入栈~");
return;
}
stack[++top] = num;
}
/**
* 出栈
* @return
*/
public int pop() {
if (isEmpty()) {
throw new RuntimeException("栈已空 无法出栈~");
}
return stack[top--];
}
/**
* 获取栈顶元素
* @return
*/
public int getTop() {
if (isEmpty()) {
throw new RuntimeException("栈已空 没有栈顶元素~");
}
return stack[top];
}
/**
* 遍历栈
*/
public void showStack() {
if (isEmpty()) {
throw new RuntimeException("栈已空 无法出栈~");
}
int temp = top;
while (true) {
if (temp == -1) {
break;
}
System.out.print(stack[temp--] + " ");
}
System.out.println();
}
/**
* 比较运算符的优先级
* 只支持 + - * /
* @param c
* @return
*/
public int priority(int c) {
if(c == '+' || c == '-') {
return 0;
} else if(c == '*' || c == '/') {
return 1;
}
return -1;
}
public boolean isChar(int c) {
if(c == '+' || c == '-' || c == '*' || c == '/') {
return true;
}
return false;
}
/**
* 两个数 与 运算符做运算
* @param num1
* @param num2
* @param c
* @return
*/
public int operate2Num(int num1, int num2, int c) {
Integer res = null;
switch (c) {
case '+' :
res = num2 + num1;
break;
case '-' :
res = num2 - num1;
break;
case '*' :
res = num2 * num1;
break;
case '/' :
res = num2 / num1;
break;
default:
break;
}
return res;
}
}
2.实现综合计算器代码：
package com.ws;
public class OperateTest {
public static void main(String[] args) {
String str = "30+2*60-20*3-70+5";
// -
//9 7
ArrayStack intStack = new ArrayStack(10);
ArrayStack charStack = new ArrayStack(10);
//定义相关变量
int index = 0; //用于遍历字符串
int num ; //接收遍历所得到的字符
int next;
Integer num1 = null;
Integer num2 = null;
Integer res = null;
while(true) {
num = str.substring(index, index+1).charAt(0);
//对 num进行判断 然后入相应的栈
if(charStack.isChar(num)) {
//如果运算符栈没有符号直接入栈
if(charStack.isEmpty()) {
charStack.push(num);
}
//如果有 num比字符栈栈顶优先级大时 直接入栈
else if(charStack.priority(num) > charStack.priority(charStack.getTop())) {
charStack.push(num);
}
//如果有 num比字符栈栈顶优先级小或相等 先将已存在的进行出栈 数据栈也需要出栈两个 与之运算 再将结果入数据栈 然后再将num入字符栈
else {
//注意
while(true) {
num1 = intStack.pop();
num2 = intStack.pop();
res = intStack.operate2Num(num1, num2, charStack.pop());
intStack.push(res);
//如果当前栈没有元素
if(charStack.isEmpty()) {
break;
}
if(charStack.priority(num) > charStack.priority(charStack.getTop())) {
break;
}
}
charStack.push(num);
}
} else {
num -= 48;
//表示还有下个元素
if(index+1 < str.length()) {
next = str.substring(index+1, index+2).charAt(0);
//判断是否为多位数 768
while (!intStack.isChar(next)) {
next -= 48;
num = num * 10 + next;
index++;
//若已是最后一个元素 退出循环
if(index == str.length()) {
break;
}
next = str.substring(index+1, index+2).charAt(0);
}
}
intStack.push(num);
}
index++;
//推出条件
if(index == str.length()) {
break;
}
}
// charStack.showStack();
// System.out.println("-------");
// intStack.showStack();
while(true) {
if(charStack.isEmpty()) {
break;
}
num1 = intStack.pop();
num2 = intStack.pop();
res = intStack.operate2Num(num1, num2, charStack.pop());
intStack.push(res);
}
System.out.println(str + " = "+ intStack.getTop());
}
}
3.运行结果：
二.后缀表达式
中缀表达式转后缀表达式的思路步骤分析
1)初始化两个栈:运算符栈s1和储存中间结果的栈s2;
2)从左至右扫描中缀表达式;
3)遇到操作数时，将其压s2;
4)遇到运算符时，比较其与s1栈顶运算符的优先级:
- 如果s1为空,或栈顶运算符为左括号“("，则直接将此运算符入栈;
- 否则，若优先级比核顶运算符的高，也将运算符压入s1;
- 否则，将s1核顶的运算符弹出并压入到s2中，再次转到4.1与s1中新的栈顶运算符相比较;
5)遇到括号时:
- 如果是左括号“(”，则直接压入s1
- 如果是右括号“)"，则依次弹出s1楼顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃
6)重复步骤2至5,直到表达式的最右边
7)将s1中剩余的运算符依次弹出并压入s2
8)依次弹出s2中的元素并输出，结果的逆刺为中缀表达式对应的后缀表达式
图解：
中缀转后缀代码实现：
String expression = "1+((2+3)*4)-5";
/**
* 将中缀表达式转成对应的List
* s="1+((2+3)×4)-5" ==> list=[1, +, (, (, 2, +, 3, ), *, 4, ), -, 5]
* @param s
* @return
*/
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++; //i需要后移
} else { //如果是一个数，需要考虑多位数
str = ""; //先将str 置成"" '0'[48]->'9'[57]
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;//返回
}
/**
* 将得到的中缀表达式对应的List => 后缀表达式对应的List
* 即ArrayList [1,+,(,(,2,+,3,),*,4,),-,5] ==> ArrayList [1,2,3,+,4,*,+,5,–]
* @param ls
* @return
*/
public static List<String> parseSuffixExpreesionList(List<String> ls) {
//定义两个栈
Stack<String> s1 = new Stack<String>(); // 符号栈
//说明：因为s2 这个栈，在整个转换过程中，没有pop操作，而且后面我们还需要逆序输出
//因此比较麻烦，这里我们就不用 Stack<String> 直接使用 List<String> s2
//Stack<String> s2 = new Stack<String>(); // 储存中间结果的栈s2
List<String> s2 = new ArrayList<String>(); // 储存中间结果的Lists2
//遍历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 {
//当item的优先级小于等于s1栈顶运算符, 将s1栈顶的运算符弹出并加入到s2中，再次转到(4.1)与s1中新的栈顶运算符相比较
//问题：我们缺少一个比较优先级高低的方法
while(s1.size() != 0 && Operation.getValue(s1.peek()) >= Operation.getValue(item) ) {
s2.add(s1.pop());
}
//还需要将item压入栈
s1.push(item);
}
}
//将s1中剩余的运算符依次弹出并加入s2
while(s1.size() != 0) {
s2.add(s1.pop());
}
return s2; //注意因为是存放到List, 因此按顺序输出就是对应的后缀表达式对应的List
}
//编写一个类 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 result = 0;
switch (operation) {
case "+":
result = ADD;
break;
case "-":
result = SUB;
break;
case "*":
result = MUL;
break;
case "/":
result = DIV;
break;
case "(":
break;
default:
System.out.println("不存在该运算符" + operation);
break;
}
return result;
}
}
208
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
