【Java数据结构与算法】栈与逆波兰表达式 内含：逆波兰计算器，中缀表达式转后缀表达式，关于matches()方法的使用

---

栈的介绍

1. 栈是一个先入后出(FILO-First In Last Out)的有序列表。
2. 栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)。
3. 根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除

出栈(pop)和入栈(push)的概念

栈的应用场景

1. 子程序的调用：在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中。
2. 处理递归调用：和子程序的调用类似，只是除了储存下一个指令的地址外，也将参数、区域变量等数据存入堆栈中。
3. 表达式的转换[中缀表达式转后缀表达式]与求值(实际解决)。
4. 二叉树的遍历。
5. 图形的深度优先(depth一first)搜索法。

一、栈的实现（数组）

//定义一个 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;
	}
	//入栈-push
	public void push(int value) {
		//先判断栈是否满
		if(isFull()) {
			System.out.println("栈满");
			return;
		}
		top++;
		stack[top] = value;
	}
	//出栈-pop, 将栈顶的数据返回
	public int pop() {
		//先判断栈是否空
		if(isEmpty()) {
			//抛出异常
			throw 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]);
		}
	}
}

二、将中缀表达式转成对应的List集合

public static List<String> toInfixExpressionList(String s){
        //定义一个List,存放中缀表达式 对应的内容
        List<String> ls = new ArrayList<String>();
        int i = 0; //这时是一个指针，用于遍历 中缀表达式字符串
        String str; // 对多位数的拼接
        char c; // 每遍历到一个字符，就放入到c

        for (int j = 0; j < s.length(); j++) {
            //如果c是一个非数字，我需要加入到ls
            if((c=s.charAt(j)) < 48 ||  (c=s.charAt(j)) > 57) {
                ls.add("" + c);
            }else{
                str="";
                i = j;
                while (i < s.length() && (c = s.charAt(i)) >= 48 && (c=s.charAt(i)) <= 57){
                    str += c;
                    i++;
                }
                ls.add(str);
            }
        }
        return ls;
    }

三、中缀表达式转后缀表达式

public static List<String> parseSuffixExpreesionList(List<String> ls){
        Stack<String> s1 = new Stack<>();
        List<String> s2 = new ArrayList<>();

       for (String item : ls){
           if (item.matches("\\d+")){
               s2.add(item);
           }else if (item.equals("(")){
               s1.push(item);
           }else if (item.equals(")")){
               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;
    }

四、逆波兰计算器的实现

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

2. 从左至右扫描中缀表达式；
3. 遇到操作数时，将其压s2；
4. 遇到运算符时，比较其与s1栈顶运算符的优先级：
   1.如果s1为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈；
   2.否则，若优先级比栈顶运算符的高，也将运算符压入s1；
   3.否则，将s1栈顶的运算符弹出并压入到s2中，再次转到(4.1)与s1中新的栈顶运算符相比较；
5. 遇到括号时：(1) 如果是左括号“(”，则直接压入s1(2) 如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃
6. 重复步骤2至5，直到表达式的最右边
7. 将s1中剩余的运算符依次弹出并压入s2
8. 依次弹出s2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式

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

public class PolandNotation {
    public static void main(String[] args) {
        String expression = "1+((2+3)*4)-5";//注意表达式
        List<String> infixExpressionList = toInfixExpressionList(expression);
        System.out.println("中缀表达式对应的List=" + infixExpressionList); // ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]
        List<String> suffixExpreesionList = parseSuffixExpreesionList(infixExpressionList);
        System.out.println("后缀表达式对应的List" + suffixExpreesionList); //ArrayList [1,2,3,+,4,*,+,5,–]

        System.out.printf("expression=%d", calculate(suffixExpreesionList));
    }


    /*
    1) 初始化两个栈：运算符栈s1和储存中间结果的栈s2；
    2) 从左至右扫描中缀表达式；
    3) 遇到操作数时，将其压s2；
    4) 遇到运算符时，比较其与s1栈顶运算符的优先级：
    1.如果s1为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈；
    2.否则，若优先级比栈顶运算符的高，也将运算符压入s1；
    3.否则，将s1栈顶的运算符弹出并压入到s2中，再次转到(4.1)与s1中新的栈顶运算符相比较；
    5) 遇到括号时：(1) 如果是左括号“(”，则直接压入s1(2) 如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃
    6) 重复步骤2至5，直到表达式的最右边
    7) 将s1中剩余的运算符依次弹出并压入s2
    8)  依次弹出s2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式
     */

    //即 ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]  =》 ArrayList [1,2,3,+,4,*,+,5,–]
    //方法：将得到的中缀表达式对应的List => 后缀表达式对应的List
    public static List<String> parseSuffixExpreesionList(List<String> ls){
        Stack<String> s1 = new Stack<>();
        List<String> s2 = new ArrayList<>();

       for (String item : ls){
           if (item.matches("\\d+")){
               s2.add(item);
           }else if (item.equals("(")){
               s1.push(item);
           }else if (item.equals(")")){
               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;
    }

    //完成对逆波兰表达式的运算
	/*
	 * 1)从左至右扫描，将3和4压入堆栈；
		2)遇到+运算符，因此弹出4和3（4为栈顶元素，3为次顶元素），计算出3+4的值，得7，再将7入栈；
		3)将5入栈；
		4)接下来是×运算符，因此弹出5和7，计算出7×5=35，将35入栈；
		5)将6入栈；
		6)最后是-运算符，计算出35-6的值，即29，由此得出最终结果
	 */
	public static int calculate(List<String> ls){
        Stack<String> stack = new Stack<>();
        for (String str : ls){
            if (str.matches("\\d+")){
                stack.push(str);
            }else {
                // pop出两个数，并运算， 再入栈
                int num2 = Integer.parseInt(stack.pop());
                int num1 = Integer.parseInt(stack.pop());
                int res = 0;

                switch (str){
                    case "+":
                        res = num1 + num2;
                        break;
                    case "-":
                        res = num1 - num2;
                        break;
                    case "*":
                        res = num1 * num2;
                        break;
                    case "/":
                        res = num1 / num2;
                        break;
                }
                stack.push("" + res);
            }
        }
        return Integer.parseInt(stack.pop());
    }

    //方法：将 中缀表达式转成对应的List
    //  s="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

        for (int j = 0; j < s.length(); j++) {
            //如果c是一个非数字，我需要加入到ls
            if((c=s.charAt(j)) < 48 ||  (c=s.charAt(j)) > 57) {
                ls.add("" + c);
            }else{
                str="";
                i = j;
                while (i < s.length() && (c = s.charAt(i)) >= 48 && (c=s.charAt(i)) <= 57){
                    str += c;
                    i++;
                }
                ls.add(str);
            }
        }
        return ls;
    }

    //编写一个类 Operation 可以返回一个运算符 对应的优先级
    static 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;
            }
            return result;
        }
    }
}

五、关于matches()方法的使用

matches() 方法用于检测字符串是否匹配给定的正则表达式。

调用此方法的 str.matches(regex) 形式与以下表达式产生的结果完全相同：

Pattern.matches(regex, str)

1.语法

public boolean matches(String regex)

2.参数

regex — 匹配字符串的正则表达式。

3.返回值

在字符串匹配给定的正则表达式时，返回 true。

而在本代码里：括号里甜\d意思就是匹配一个数字，\d+就是匹配一个或多个数字，前面多加一个\是因为要转义。