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.

思路：这题需要注意的时候，数都是以NestedInteger(num)加进去的。算法就是用stack，遇见左括号，就新建一个object，然后遇见数，就new NestedInteger(num)加到stack的最上层的那个object中，然后遇见右括号的时候，把数加到peek()的中后，把peek pop出来，然后判断一下，如果stack还有，则把pop出来的 元素加到peek中，如果stack空了，则表明pop出来的就是最终结果。另外，还要处理的就是只有数字的情况，那么就直接返回一个object。然后需要注意的一点是负数的情况，用Integer.parseInt，可以包含在内，所以不需要处理。

/**
 * // 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) {
        if(s == null || s.length() ==0) return null;
        String temp = "";
        Stack<NestedInteger> stack = new Stack<NestedInteger>();
        for(int i=0; i<s.length(); i++){
            char c = s.charAt(i);
            if(c == '['){
                stack.push(new NestedInteger());
            } else if(c == ']'){
                if(!temp.equals("")){
                    stack.peek().add(new NestedInteger(Integer.parseInt(temp)));
                    temp = "";
                }
                NestedInteger top = stack.pop();
                if(stack.size()>0){
                    stack.peek().add(top); 
                } else {
                    return top;
                }
            } else if(c == ','){
                if(!temp.equals("")){
                    stack.peek().add(new NestedInteger(Integer.parseInt(temp)));
                    temp = "";
                }
            } else { // c == 0-9 & '-'
                temp += c;
            }
        }
        
        // if only contains number;
        if(!temp.equals("")){
            return new NestedInteger(Integer.parseInt(temp));
        }
        return null;
    }
}