LeetCode 385. Mini Parse

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.

Subscribe to see which companies asked this question

---

【题目分析】

用String的形式给定一个嵌套的list，然后实现对这个字符串的反序列化。给定的字符串满足下列要求：

1. 非空

2. 不包含空格

3. 只包含0-9,[,],- 这几种字符

---

【思路】

对于嵌套的形式，我们要把一对中括号括起来的内容嵌套进中括号外面的内容中。

我们使用栈来保存之前的内容，当前一对中括号的内容如果构造完毕，就把它嵌套进栈中之前的一个元素。为此我们需要做以下几件事情：

1. 遍历字符串

2. 如果当前字符是'['则新建一个NestedInteger入栈

3. 如果当前字符是0-9或者-，则加入到当前数字字符串序列中

4. 如果当前字符是','或者']'，如果数字字符串非空，则把该数字加入到栈顶的NestedInteger中，如果当前字符是']'则还要把栈顶元素弹出并添加到新的栈顶元素中

5. 遍历结束后如果最后的数字序列非空，则把该数字加入栈顶元素并返回栈顶元素，否则直接返回栈顶元素。

---

【java代码】

 /**
  * // This is the interface that allows for creating nested lists.
  * // You should not implement it, or speculate about its implementation
  * public interface NestedInteger {
  *     // Constructor initializes an empty nested list.
  *     public NestedInteger();
  *
  *     // Constructor initializes a single integer.
  *     public NestedInteger(int value);
  *
  *     // @return true if this NestedInteger holds a single integer, rather than a nested list.
  *     public boolean isInteger();
  *
  *     // @return the single integer that this NestedInteger holds, if it holds a single integer
  *     // Return null if this NestedInteger holds a nested list
  *     public Integer getInteger();
  *
  *     // Set this NestedInteger to hold a single integer.
  *     public void setInteger(int value);
  *
  *     // Set this NestedInteger to hold a nested list and adds a nested integer to it.
  *     public void add(NestedInteger ni);
  *
  *     // @return the nested list that this NestedInteger holds, if it holds a nested list
  *     // Return null if this NestedInteger holds a single integer
  *     public List<NestedInteger> getList();
  * }
  */
 public class Solution {
     public NestedInteger deserialize(String s) {
         Stack<NestedInteger> sk = new Stack<>();
         StringBuilder sb = new StringBuilder();
         for (int i = 0; i < s.length(); i++) {
             char ch = s.charAt(i);
             if(ch == '[') {
                 sk.push(new NestedInteger());
             }
             else if((ch >= '0' && ch <= '9') || ch == '-') {
                 sb.append(ch);
             }
             else {
                 if(sb.length() >= 1) {
                     int num = Integer.parseInt(sb.toString());
                     NestedInteger ni = new NestedInteger(num);
                     NestedInteger top = sk.peek();
                     top.add(ni);
                     sb.delete(0, sb.length());
                 }
                 if(ch == ']') {
                     NestedInteger top = sk.pop();
                     if(sk.isEmpty()) return top;
                     NestedInteger newtop = sk.peek();
                     newtop.add(top);
                 }
             }
         }
         if (sb.length() >= 1)
             return new NestedInteger(Integer.parseInt(sb.toString()));
         return sk.peek();
     }
 }