表达树构造-LintCode

表达树是一个二叉树的结构，用于衡量特定的表达。所有表达树的叶子都有一个数字字符串值。而所有表达树的非叶子都有另一个操作字符串值。
给定一个表达数组，请构造该表达的表达树，并返回该表达树的根。

定义：
什么是表达树？详见wiki百科

示例：
对于 (2*6-(23+7)/(1+2)) 的表达（可表示为 [“2” “*” “6” “-” “(” “23” “+” “7” “)” “/” “(” “1” “+” “2” “)”]).
其表达树如下：

             [ - ]
         /          \
    [ * ]              [ / ]
  /     \           /         \
[ 2 ]  [ 6 ]      [ + ]        [ + ]
                 /    \       /      \
               [ 23 ][ 7 ] [ 1 ]   [ 2 ] .

在构造该表达树后，你只需返回根节点[-]。

思想：
构造原式的后缀表达式，再通过后缀表达式构建表达树。
实现方法：
对于数字时，加入后缀表达式；
对于运算符：
a. 若为 ‘(‘，入栈；
b. 若为 ‘)’，则依次把栈中的的运算符加入后缀表达式中，直到出现’(‘，从栈中删除’(’ ；
c. 若为 除括号外的其他运算符， 当其优先级高于除’(‘以外的栈顶运算符时，直接入栈。否则从栈顶开始，依次弹出比当前处理的运算符优先级高和优先级相等的运算符，直到一个比它优先级低的或者遇到了一个左括号为止。
当扫描的中缀表达式结束时，栈中的的所有运算符出栈；

#ifndef C367_H
#define C367_H
#include<iostream>
#include<string>
#include<vector>
#include<stack>
using namespace std;
class ExpressionTreeNode{
public:
    string symbol;
    ExpressionTreeNode *left, *right;
    ExpressionTreeNode(string symbol)
    {
        this->symbol = symbol;
        this->left = this->right = NULL;
    }
};
class Solution{
public:
    /*
    * @param expression: A string array
    * @return: The root of expression tree
    */
    ExpressionTreeNode * build(vector<string> &expression) {
        // write your code here
        vector<string> post = postExpression(expression);
        stack<ExpressionTreeNode*> sk;
        for (auto c : post)
        {
            ExpressionTreeNode *node = new ExpressionTreeNode(c);
            if (string("+-*/").find(c) != string::npos)
            {
                node->right = sk.top();
                sk.pop();
                node->left = sk.top();
                sk.pop();
                sk.push(node);
            }
            else
                sk.push(node);
        }
        if (sk.empty())
            return NULL;
        else
            return sk.top();
    }
    int getPriority(string s)
    {
        if (s == "(")
            return 0;
        else if (s == "+" || s == "-")
            return 1;
        else if (s == "*" || s == "/")
            return 2;
        else
            return 3;
    }
    vector<string> postExpression(vector<string> &expression)
    {
        stack<string> sk;
        vector<string> post;
        for (auto c : expression)
        {
            if (c == "(")
                sk.push(c);
            else if (c == ")")
            {
                while (sk.top() != "(")
                {
                    post.push_back(sk.top());
                    sk.pop();
                }
                sk.pop();
            }
            else
            {
                if (string("+-*/").find(c)==string::npos)
                    sk.push(c);
                else
                {
                    while(!sk.empty() && getPriority(sk.top()) >= getPriority(c))
                    {
                        post.push_back(sk.top());
                        sk.pop();
                    }
                    sk.push(c);
                }

            }
        }
        while (!sk.empty())
        {
            post.push_back(sk.top());
            sk.pop();
        }
        return post;
    }
};
#endif