Java栈思想应用——四则运算|附括号匹配

四则运算：
1、遍历四则运算式，遇到数字存入栈中
2、遇到符号，栈为空则入栈；否则需要比较是否计算
给每个符号±*/设置优先级；
栈顶优先级>=当前优先级，则符号出栈，出两个操作数，进行计算，结果入栈，当前符号入栈；
3、直至遍历完整个字符串，不为空则继续出栈计算结果压栈，直至符号栈为空；
4、实现栈的思想：先进后出：
数组：尾巴作为栈顶，方便进入出去；
链表：头结点为栈顶，方便插入删除

代码如下：
思路来源：该文章

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44366571/article/details/114825726

public class SiZeYunSuan {
//    1\遍历算术表达式
//    2、遇到数字入栈；
//    遇到符号：符号栈顶拿出作比较，
//    顶的优先级>=当前符号优先级就取数字栈顶两个数，计算结果压栈，当前大于栈顶的优先级，则压栈
    //两个栈,静态变量属于类而不是实例，因此可以在类的任何地方直接访问，不需要创建对象。
//    静态变量在所有实例之间共享，当一个实例修改了静态变量的值，其他实例也会受到影响。
    public static void main(String[] args)
    {
        Operation op=new Operation();
        op.operation_s("3*9+9+8*1");//预期=44
        //* + +

    }

}
class Operation{
    //存储运算符和操作数的两个数组
    private char[] operatorstack=new char[10];
    private int[] datastack=new int[10];
    //优先级
    private final int sump=0;//+
    private final int subp=0;//-
    private final int mulp=1;//*
    private final int divp=1;// /
//    数组索引
    private int operatortop=-1;
    private int datatop=-1;
    private static int datasum=0;//运算结果
    //判断运算符栈为空
    private boolean operatorstackisEmpty()
    {
        return operatortop==-1;
    }
    //获取优先级
    private int getpriority(char operator)
    {
        switch (operator)
        {
            case '+':
                return sump;
            case'-':
                return subp;
            case'*':
                return mulp;
            case '/':
                return divp;
            default:
                return -1;
        }

    }
    //计算
    //a是顶元素，b是顶元素的下一个，在遍历四则运算式的时候，前一个操作数先入栈
    private int operator(int a,int b,char operator_n)
    {
        System.out.println(a+" "+b+" "+operator_n);
        switch (operator_n){
            case '+':
                return a+b;
            case'-':
                return b-a;
            case'*':
                return b*a;
            case '/':
                return b/a;
            default:
                return -1;
        }

    }
    //判断栈顶元素和当前元素的优先级
    private boolean isoperationprioritybig(char operator)
    {
        char topoperatordata=operatorstack[operatortop];//获取栈顶元素
        int topdatapriority=getpriority(topoperatordata);
        int currentpriority=getpriority(operator);
        //当前<=栈顶优先级，就计算压栈
        if(topdatapriority>=currentpriority)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    //遍历s
    public void operation_s(String s)
    {
        int contins = 0;//多位数
        for (int i = 0; i < s.length(); i++)
        {
            if (s.charAt(i) >= '0' && s.charAt(i) <= '9')
            {
                contins++;
                if (contins > 1) {
                    //更新data数组元素
                    datastack[datatop] = datastack[datatop] * 10 + (s.charAt(i));
                } else {
                    //更新datatop
                    datastack[++datatop] = s.charAt(i) - '0';//压入的是数字字符
                }

                if(i+1==s.length())//当前为最后一个元素：数字
                {
                    //存放操作符的数组operatorstack不为空
                    while(!operatorstackisEmpty())//说明栈顶符号的运算优先级大，因为比较的时候出现了top<current则入栈
                    {
                        //数据栈顶;:取出两个操作数
                        int data1=datastack[datatop--];//相当于stack.pop()
                        int data2=datastack[datatop--];
                        //计算,操作数和操作符
                        datasum=operator(data1,data2,operatorstack[operatortop--]);
                        datastack[++datatop]=datasum;//计算结果压栈
                        System.out.println("计算结果为"+datasum);
                    }
                }
            }
            //为运算符
            else{
                contins=0;//数字位数=0
                //为空则压入栈
                if(operatorstackisEmpty())
                {
                    operatorstack[++operatortop]=s.charAt(i);
                }
                else
                {
                    //比较优先级
//                    ！false
                    if(!isoperationprioritybig(s.charAt(i)))//top《current===》压栈
                    {
                        operatorstack[++operatortop]=s.charAt(i);//压入
                    }
                    else
                    {
                        while(isoperationprioritybig(s.charAt(i)))//top>=current则计算
                        {
                            char stacktoperator_temp=operatorstack[operatortop--];//栈顶元素
                            int data1=datastack[datatop--];//相当于stack.pop()
                            int data2=datastack[datatop--];
                            datasum=operator(data1,data2,stacktoperator_temp);
                            datastack[++datatop]=datasum;//结果压栈
                            if(operatorstackisEmpty())
                                break;//空了就跳出

                        }
                        //计算完栈内>=自己优先级的运算，再把自己（current）存入
                        operatorstack[++operatortop]=s.charAt(i);
                    }
                }
                System.out.println("计算结果为"+datasum);
            }
        }
        System.out.print("最终结果为"+datastack[0]);
    }
}

关于括号匹配：

public class KuoHaoStack {
    public static boolean  isok(String s)//O(n)
    {
        MyStack<Character> brackets=new ArrayStack<Character>(20);
        char[] c =s.toCharArray();
        for(char elem:c)
        {
            switch(elem){
                case '{':
                case'[':
                case'(':
                    brackets.push(elem);
                    break;
                case'}':
                    Character top=brackets.pop();
                    if(top==null)
                    {
                        System.out.println("匹配错误");
                        return false;
                    }

                    if(top=='{')
                        break;
                    else
                    {
                        System.out.println("匹配错误");
                        return false;
                    }
                case']':
                    top = brackets.pop();
                    if(top==null)
                    {
                        System.out.println("匹配错误");
                        return false;
                    }

                    if(top=='[')
                        break;
                    else{
                        System.out.println("匹配错误");
                        return false;
                    }
                case')':
                    top=brackets.pop();
                    if(top==null)
                    {
                        System.out.println("匹配错误");
                        return false;
                    }

                    if(top=='(')
                        break;
                    else
                    {
                        System.out.println("匹配错误");
                        return false;
                    }
                default:
                    break;
            }
        }
        System.out.print("走到这里了");
        if(brackets.isEmpty())
        {
            System.out.println("匹配成功");
            return true;
        }
        else{
            System.out.println("匹配错误");
            return false;
        }

}
    public static void main(String args[])
    {
       String s="{{}}({})[]";
       isok(s);
    }
}

上文中关于Character型stack，pop出来的元素：

if(top==‘{’)
补充如下：