栈及波兰表达式

本文介绍了栈的特点,包括先进后出的性质,以及栈的push、pop和peek方法。讨论了表达式的三种形式:前缀(波兰式)、中缀和后缀(逆波兰式),强调了后缀表达式在计算上的优势。重点讲述了如何将中缀表达式转换为后缀表达式,转化原理、示例和代码一并给出。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

栈的特点:

先进后出

栈的方法:

stack.pop():弹出最上层的数据,并弹出数据
stack.push():在栈的最上层压入数据
stack.peek():查看栈的最上层数据,但是不弹出数据

表达式:

表达式分前缀表达式、中缀表达式和后缀表达式。
中缀表达式:人类最熟悉的一种表达式1+2,(1+2)3,3+42+4等等都是中缀表示法。
前缀表达式又叫做波兰式,前缀表达式为- + A * B - C D * E F
后缀表达式又叫做逆波兰式。形如:A B C D - * + E F * -

中缀表达式对于计算机的运算并不便利,而前缀后缀表达式的计算相对简单方便。因此,需要将中缀表达式转换成前缀后缀表达式,然后利用栈结构计算前后缀表达式。

栈结构计算后缀表达式

    public static void main(String[] args) {
        ReversePolandNotation poland = new ReversePolandNotation();
        String suffixExpression = "30 4 + 5 * 6 -";
        String result =  poland.caculate(poland.getArray(suffixExpression));
        System.out.println(result);
    }

    //计算得到表达式结果
    public String caculate(String[] arrays){
        Stack<String> stack = new Stack<>();
        for(String str : arrays){
            if(str.matches("\\d+")){
                stack.push(str);
            }else{
                int num2 = Integer.parseInt(stack.pop());
                int num1 = Integer.parseInt(stack.pop());
                if("+".equals(str)){
                    stack.push(String.valueOf(num1 + num2));
                }else if("-".equals(str)){
                    stack.push(String.valueOf(num1 - num2));
                }else if("*".equals(str)){
                    stack.push(String.valueOf(num1 * num2));
                }else if("/".equals(str)){
                    stack.push(String.valueOf(num1 / num2));
                }else{
                    throw new RuntimeException("操作符不对");
                }
            }
        }
        return stack.pop();
    }

    //表达式根据空格分隔得到数组和操作符的数组
    public String[] getArray(String expression){
        if(expression != null){
            String[] arrays = expression.split(" ");
            return arrays;
        }
        return null;
    }

中缀表达式转后缀表达式

1、转化原理:
在这里插入图片描述
2、转化示例:
在这里插入图片描述
3、转化代码:

   public class PolandNotationChange {
public static void main(String[] args) {
    PolandNotationChange poland = new PolandNotationChange();
    String middleExpression = "1 + ( ( 2 + 3 ) * 4 ) - 5";
    //1、表达式转为数组
    String[] middleArray = poland.getArray(middleExpression);
    //2、中缀转后缀
    String suffixExpression = poland.changeExpression(middleArray);
    //3、后缀倒叙输出
    String reverseExpression = new StringBuilder(suffixExpression).reverse().toString();
    System.out.println("中缀表达式“"+middleExpression + "”转化为后缀表达式:“"+reverseExpression + "”");
    String result = new ReversePolandNotation().caculate(poland.getArray(reverseExpression));
    System.out.println("最终计算结果:"+result);
}
//2、中缀转后缀
private String changeExpression(String[] middleArray) {
    Stack<String> resultStack = new Stack<>();
    Stack<String> operStack = new Stack<>();

    for(String str : middleArray){
        if(str.matches("\\d+")){
            resultStack.push(str);
        }else if("+".equals(str) || "-".equals(str) || "*".equals(str) || "/".equals(str)){
            pushOperStack(resultStack,operStack,str);
        }else if("(".equals(str)){
            operStack.push(str);
        }else if(")".equals(str)){
            pushRightStack(resultStack,operStack);
        }

    }

    while(true){
        if(operStack.isEmpty()){
            break;
        }
        resultStack.push(operStack.pop());
    }

    StringBuilder sb = new StringBuilder();
    while(true){
        if(resultStack.isEmpty()){
            sb.replace(sb.length()-1,sb.length(),"");
            break;
        }
        sb.append(resultStack.pop()).append(" ");
    }
    return sb.toString();
}

//5、压栈时右括号处理
public void pushRightStack(Stack<String> resultStack,Stack<String> operStack){
    String topOper = operStack.pop();
    if("(".equals(topOper)){
        return;
    }else{
        resultStack.push(topOper);
        pushRightStack(resultStack,operStack);
    }
}

//4、压栈时运算符处理
public void pushOperStack(Stack<String> resultStack,Stack<String> operStack,String oper){
    if(operStack.isEmpty()){
        operStack.push(oper);
    }else{
        String topOper = operStack.pop();
        if( "(".equals(topOper) ){
            operStack.push(topOper);
            operStack.push(oper);
        }else if(priority(oper) > priority(topOper)){
            operStack.push(topOper);
            operStack.push(oper);
        }else{
            resultStack.push(topOper);
            pushOperStack(resultStack,operStack,oper);
        }
    }
}

//3、获取运算符优先级
public int priority(String oper){
    if("+".equals(oper)){
        return 1;
    }else if("-".equals(oper)){
        return 1;
    }else if("*".equals(oper)){
        return 2;
    }else if("/".equals(oper)){
        return 2;
    }
    throw new RuntimeException("运算符不正确");
}


//1、表达式根据空格分隔得到数组和操作符的数组
public String[] getArray(String expression){
    if(expression != null){
        String[] arrays = expression.split(" ");
        return arrays;
    }
    return null;
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值