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

方法1：
主要思路：解题汇总
（1）使用栈来处理这种嵌套的情形；
（2）遍历字符串，当字符为 ‘[’ 时，说明需要新增一个NestedInterger；
（3）当字符为‘，’时，若之前提取出了字符串，则说明该字符串可以转化为一个数字，并存入当前的NestedInterger；
（4）当字符为‘ ] ’时，若之前提取出了字符串，则该字符同样需要转化为一个数字，并存入当前的NestedInterger中，同时判断当前的栈中NestedInterger的个数是否大于1，若大于1，在需要将当前栈顶的NestedInterger取出，并合并到随后的栈顶的NestedInterger中；
（5）其他的字符，在接入到临时字符串中；

/**
 * // 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) {
    	//处理特殊的情形
        if(s.empty()){
            return NestedInteger();
        }
        if(s[0]!='['){
            return NestedInteger(stoi(s));
        }
        //辅助栈
        stack<NestedInteger*> st;
        string str;//辅助字符串
        for(char& ch:s){
            if(ch=='['){//需要新增一个NestedInterger
                st.push(new NestedInteger());
            }
            else if(ch==']'){
                if(str.size()){//处理上一个字符串
                    st.top()->add(NestedInteger(stoi(str)));
                    str.clear();
                }
                if(st.size()>1){//合并NestedInterger
                    NestedInteger* cur=st.top();
                    st.pop();
                    st.top()->add(*cur);
                }
            }
            else if(ch==','){
                if(str.size()){//处理字符串，存入到当前的NestedInterger中
                    st.top()->add(NestedInteger(stoi(str)));
                    str.clear();
                }
            }
            else {
                str+=ch;//生成子字符串
            }
        }
        return *st.top();//返回最终的合并后的NestedInterger
    }
};