Leetcode: Mini Parser

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.

 1 /**
 2  * // This is the interface that allows for creating nested lists.
 3  * // You should not implement it, or speculate about its implementation
 4  * public interface NestedInteger {
 5  *     // Constructor initializes an empty nested list.
 6  *     public NestedInteger();
 7  *
 8  *     // Constructor initializes a single integer.
 9  *     public NestedInteger(int value);
10  *
11  *     // @return true if this NestedInteger holds a single integer, rather than a nested list.
12  *     public boolean isInteger();
13  *
14  *     // @return the single integer that this NestedInteger holds, if it holds a single integer
15  *     // Return null if this NestedInteger holds a nested list
16  *     public Integer getInteger();
17  *
18  *     // Set this NestedInteger to hold a single integer.
19  *     public void setInteger(int value);
20  *
21  *     // Set this NestedInteger to hold a nested list and adds a nested integer to it.
22  *     public void add(NestedInteger ni);
23  *
24  *     // @return the nested list that this NestedInteger holds, if it holds a nested list
25  *     // Return null if this NestedInteger holds a single integer
26  *     public List<NestedInteger> getList();
27  * }
28  */
29 public class Solution {
30     public NestedInteger deserialize(String s) {
31         if (!s.startsWith("[")) {
32             return new NestedInteger(Integer.parseInt(s));
33         }
34         NestedInteger res = new NestedInteger();
35         Stack<NestedInteger> st = new Stack<NestedInteger>();
36         st.push(res);
37         int start = 1;
38         for (int i=1; i<s.length(); i++) {
39             char c = s.charAt(i);
40             if (c == ‘[‘) {
41                 NestedInteger ni = new NestedInteger();
42                 st.peek().add(ni);
43                 st.push(ni);
44                 start = i+1;
45             }
46             else if (c==‘,‘ || c==‘]‘) {
47                 if (i > start) {
48                     int val = Integer.parseInt(s.substring(start, i));
49                     st.peek().add(new NestedInteger(val));
50                 }
51                 start = i+1;
52                 if (c == ‘]‘) st.pop();
53             }
54         }
55         return res;
56     }
57 }