2021-9-13 385. 迷你语法分析器（栈）

注：

题目：
给定一个用字符串表示的整数的嵌套列表，实现一个解析它的语法分析器。
列表中的每个元素只可能是整数或整数嵌套列表
提示：你可以假定这些字符串都是格式良好的：

字符串非空
字符串不包含空格
字符串只包含数字0-9、[、-、,、]

示例 1：
给定 s = “324”,
你应该返回一个 NestedInteger 对象，其中只包含整数值 324。
示例 2：
给定 s = “[123,[456,[789]]]”,
返回一个 NestedInteger 对象包含一个有两个元素的嵌套列表：

1. 一个 integer 包含值 123
2. 一个包含两个元素的嵌套列表：
   i. 一个 integer 包含值 456
   ii. 一个包含一个元素的嵌套列表
   a. 一个 integer 包含值 789

题解：
我们维护一个栈stack用于存储嵌套列表，接下来我们对可能出现的情况分别进行处理：

Step1： 第一个字符不是’[’，说明遇到了数字，那么我们就直接返回
注意要包装成NestedInteger对象：

if(c=='['){
	st.push(NestedInteger());
}

Step2： 第一个字符是’[’，每一个字符可能的情况共有5种，我们分别讨论

• 数字：计算10进制数字大小即可
• 负号：设置符号位为-1
• 左括号：栈append一个空的NestedInteger对象
• 逗号：如果前面是数字，在栈顶元素里添加一个NestedInteger对象。
• 右括号：如果前面是数字，则在栈顶的NestedInteger对象里添加一个NestedInteger对象。如果前面不是数字，把栈顶的NestedInteger对象pop出来，在新的栈顶元素中添加刚才pop出来的NestedInteger对象。

复杂度分析
时间复杂度：O(N)。
空间复杂度：O(N)。

/**
 * // This is the interface that allows for creating nested lists.
 * // You should not implement it, or speculate about its implementation
 * class NestedInteger {
 *   public:
 *     // Constructor initializes an empty nested list.
 *     NestedInteger();
 *
 *     // Constructor initializes a single integer.
 *     NestedInteger(int value);
 *
 *     // Return true if this NestedInteger holds a single integer, rather than a nested list.
 *     bool isInteger() const;
 *
 *     // Return the single integer that this NestedInteger holds, if it holds a single integer
 *     // The result is undefined if this NestedInteger holds a nested list
 *     int getInteger() const;
 *
 *     // Set this NestedInteger to hold a single integer.
 *     void setInteger(int value);
 *
 *     // Set this NestedInteger to hold a nested list and adds a nested integer to it.
 *     void add(const NestedInteger &ni);
 *
 *     // Return the nested list that this NestedInteger holds, if it holds a nested list
 *     // The result is undefined if this NestedInteger holds a single integer
 *     const vector<NestedInteger> &getList() const;
 * };
 */
class Solution {
public:
    NestedInteger deserialize(string s) {
        stack<NestedInteger> st;
        if(s.size()==0){
            return NestedInteger();
        }
        if(s[0]!='['){
            return NestedInteger(atoi(s.c_str()));
        }
        string num;
        for(auto c:s){
            if(c=='['){
                st.push(NestedInteger());
            }
            else if(c==','){
                if(num!=""){
                    st.top().add(NestedInteger(atoi(num.c_str())));
                    num="";
                }
            }
            else if(c=='-'){
                num=("-"+num);
            }
            else if(c==']'){
                if(num!=""){
                    st.top().add(NestedInteger(atoi(num.c_str())));
                    num="";
                }
                auto t=st.top();
                if(st.size()==1){
                    return t;
                }
                else{
                    st.pop();
                    st.top().add(t);
                }
            }
            else {
                num+=c;
            }
        }
        return NestedInteger(-1);
    }
};