栈的实际应用

##括号匹配问题

问题描述

给定一个字符串，里面可能包含“（）”小括号和其他字符，编写程序检查该字符串是否成对出现

即有一个（,则有一个）进行匹配，每一个左括号都有一个右括号匹配，且不能有单独的括号出现。

解题思路

1.创建一个栈来存储左括号

2.从左到右遍历字符串，拿到每一个字符

3.判断该字符是不是左括号。如果是放入栈中存储

4.判断该字符是不是右括号，如果不是继续下一次循环遍历

5.如果字符是右括号，从栈中弹出一个元素T

6.判断元素t是否为Null，如果不是，则证明有对应左括号，如果是，证明没有对应的左括号

7.字符遍历完成判断栈是否为空，不为空则不匹配

代码实现

public class BracketMaptvhTest {
    public static void main(String[] args) {
        String str = "(上海(长安)())";
        boolean match = isMacth(str);
        System.out.println("括号是否匹配:"+match);
    }

    private static boolean isMacth(String str) {

        //创建栈对象，用来存储左括号
        Stack<String> chars = new Stack<>();
        //从左向右遍历字符串
        for (int i = 0; i < str.length(); i++) {
            String currChar = str.charAt(i)+"";
            if (currChar.equals("(")) {
                chars.push(currChar);
            } else if (currChar.equals(")")) {
                String pop = chars.pop();
                if (pop == null) {
                    return false;
                }
            }

        }
        //判断是否为左括号，是放入栈中
        if (chars.size() == 0) {
            return true;
        }else {
            return false;
        }
        //不是，是不是右括号吗，是弹出栈中元素，看该元素是否为null，是则有匹配，无则不匹配

        //判断栈中有没有元素
        
    }
}

逆波兰表达式求值问题

逆波兰表达式

即将运算符放置在相关的操作符之后。

问题描述

给定一个只包含加减乘除四种运算的逆波兰表达式的数组表示方法，求出该逆波兰表达式的结果。

思路分析

1.创建一个栈对象存储操作数

2.从左向右遍历逆波兰表达式，得到每一个字符串

3.判断该字符串是不是运算符，如果不是，把该操作数压入栈中

4.如果是运算符从栈中弹出连个操作数

5.使用该运算符计算o1和o2，得到结果result

6.把该结果压入栈中

7.遍历结束后，拿出栈中的最终结果返回

代码实现

public class ReversePolishNotationTest {
    public static void main(String[] args) {
        String[] notation = {"3","17","15","-","*","18","6","/","+"};
        int result = calculate(notation);
        System.out.println("结果为："+ result);

    }

    private static int calculate(String[] notation) {
        Stack<Integer> oprands = new Stack<>();

        for (int i = 0; i < notation.length; i++) {
            String curr = notation[i];
            Integer o1;
            Integer o2;
            Integer result;
            switch (curr) {
                case "+":
                    o1 = oprands.pop();
                    o2 = oprands.pop();
                    result = o1 + o2;
                    oprands.push(result);
                    break;
                case "-":
                    o1 = oprands.pop();
                    o2 = oprands.pop();
                    result = o2 - o1;
                    oprands.push(result);
                    break;
                case "*":
                    o1 = oprands.pop();
                    o2 = oprands.pop();
                    result = o1 * o2;
                    oprands.push(result);
                    break;
                case "/":
                    o1 = oprands.pop();
                    o2 = oprands.pop();
                    result = o2 / o1;
                    oprands.push(result);
                    break;
                default:
                    oprands.push(Integer.parseInt(curr));
                    break;
            }
        }
        int result = oprands.pop();
        return result;
    }
}