【Lintcode】367. Expression Tree Build

题目地址：

https://www.lintcode.com/problem/expression-tree-build/description

给定一个中缀表达式，要求返回其对应的表达式树。

思路和表达式求值是一模一样的，区别仅仅在于要把”求值“这一步变成建一棵子表达式树。关于表达式求值，可以参考https://blog.csdn.net/qq_46105170/article/details/106209367。代码如下：

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.HashMap;
import java.util.Map;

public class Solution {
    /*
     * @param expression: A string array
     * @return: The root of expression tree
     */
    public ExpressionTreeNode build(String[] expression) {
        // write your code here
        Deque<ExpressionTreeNode> stack = new ArrayDeque<>();
        Deque<String> ops = new ArrayDeque<>();
        
        Map<String, Integer> prec = new HashMap<>();
        prec.put("(", 1);
        prec.put("+", 2);
        prec.put("-", 2);
        prec.put("*", 3);
        prec.put("/", 3);
        
        for (String s : expression) {
            if (!prec.containsKey(s) && !")".equals(s)) {
                stack.push(new ExpressionTreeNode(s));
            } else if ("(".equals(s)) {
                ops.push(s);
            } else if (")".equals(s)) {
                while (!"(".equals(ops.peek())) {
                    pushTree(ops, stack);
                }
                ops.pop();
            } else {
                while (!ops.isEmpty() && prec.get(ops.peek()) >= prec.get(s)) {
                    pushTree(ops, stack);
                }
                ops.push(s);
            }
        }
        
        while (stack.size() > 1) {
            pushTree(ops, stack);
        }
        
        return stack.peek();
    }
    
    // 把建子表达式树写成一个函数以供调用
    private void pushTree(Deque<String> ops, Deque<ExpressionTreeNode> stack) {
        ExpressionTreeNode op = new ExpressionTreeNode(ops.pop()), n2 = stack.pop(), n1 = stack.pop();
        op.left = n1;
        op.right = n2;
        stack.push(op);
    }
}

class ExpressionTreeNode {
    String symbol;
    ExpressionTreeNode left, right;
    
    ExpressionTreeNode(String symbol) {
        this.symbol = symbol;
    }
}

时空复杂度$O(n)$。