Leetcode——385. Mini Parser

Description

Given a nested list of integers represented as a string, implement a parser to deserialize it.

Each element is either an integer, or a list – whose elements may also be integers or other lists.

Note: You may assume that the string is well-formed:

String is non-empty.
String does not contain white spaces.
String contains only digits 0-9, [, - ,, ].
Example 1:

Given s = “324”,

You should return a NestedInteger object which contains a single integer 324.
Example 2:

Given s = “[123,[456,[789]]]”,

Return a NestedInteger object containing a nested list with 2 elements:

1. An integer containing value 123.

2. A nested list containing two elements:
   i. An integer containing value 456.
   ii. A nested list with one element:
   a. An integer containing value 789.

   solution

/**
 * // 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[0]!='[') return NestedInteger(stoi(s));
     int pos=1;
     return dfs(s,pos);
    }
private:
    NestedInteger dfs(string &s,int & pos)
    {
        NestedInteger ni;
        for(;pos<s.length()&&s[pos]!=']';pos++)
        {
            string temp;
            while(pos<s.length()&&s[pos]!='['&&s[pos]!=']'&&s[pos]!=',') temp=temp+s[pos++];
            if(temp!="")
                ni.add(NestedInteger(atoi(temp.c_str())));
            if(s[pos]==']') break;
            if(s[pos]=='[')
                ni.add(dfs(s,++pos));
        }
        return ni;
    }

};

关于NestedInteger 的具体实现，参考：
https://discuss.leetcode.com/topic/54268/straightforward-java-solution-with-explanation-and-a-simple-implementation-of-nestedinteger-for-your-ease-of-testing/2

Another Solution

 class Solution {//use stack
 public:
     NestedInteger deserialize(string s) {
         stack<NestedInteger> stk;
         //NestedInteger ni();
         //stk.push(ni);//上面两句等效为stk.push(NestedInteger());//入栈一个空的NestedInteger类实体
         stk.push(NestedInteger());
         for (auto it = s.begin(); it != s.end(); )
         {
             char c = (*it);
             if (isnumber(c))//是个数字
             {
                 auto it2 = find_if_not(it, s.end(), [](char c){return c == '-' || isdigit(c);});//寻找到从it开始的第一个非数字的位置
                 int val = stoi(string(it, it2));//利用迭代器取子串的方法，取it到it2之间的子串，注意不包括it2所指的位置
                 stk.top().add(NestedInteger(val));
                 it = it2;
             }
             else
             {
                 if (c == '[')
                     stk.push(NestedInteger());
                 else if (c == ']')
                 {
                     NestedInteger ni = stk.top();
                     stk.pop();
                     stk.top().add(ni);
                 }
                 ++it;
             }
         }
         NestedInteger result = stk.top().getList().front();

         return result;

     }
 private:
     bool isnumber(char c)
     {
         return c == '-' || isdigit(c);
     }

The Implementation of NestedInteger

class NestedInteger {
 private:
     vector<NestedInteger> list;
     int m_integer;
     bool m_isInteger;
 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;
};

 NestedInteger::NestedInteger(){
     m_isInteger = false;
 }
 NestedInteger::NestedInteger(int value)
 {
     m_integer = value;
     m_isInteger = true;
 }
 bool NestedInteger::isInteger()const
 {
     return m_isInteger;
 }
 int NestedInteger::getInteger()const
 {
     return m_integer;
 }
 void NestedInteger::setInteger(int value)
 {
     m_integer = value;
     m_isInteger = true;
 }
 void NestedInteger::add(const NestedInteger &ni)
 {
     m_isInteger = false;
     list.push_back(ni);
 }
 const vector<NestedInteger> & NestedInteger::getList() const
 {
     return list;
 }