[LeetCode 385] Mini Parser (Medi

/**
 * // 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();
 * }
 */
class Solution {
    public NestedInteger deserialize(String s) {
        
        if (s == null || s.length () == 0) {
            return new NestedInteger ();
        }
        
        int sigma = 1;
        int number = 0;
        
        char[] strList = s.toCharArray ();
        Stack<NestedInteger> tracker = new Stack<> ();
        
        for (int i = 0; i < strList.length; i++) {
            char ch = strList[i];
            if (Character.isDigit (ch)) {
                while (i < strList.length && Character.isDigit(strList[i])) {
                    number = number * 10 + strList[i] - '0';
                    i++;
                }
                i--;
                
                if (!tracker.isEmpty ()) {
                    NestedInteger temp = tracker.pop ();
                    temp.add (new NestedInteger (sigma * number));
                    tracker.push (temp);
                    sigma = 1;
                    number = 0;
                }
                
                
            } else if (ch == '-') {
                sigma = -1;
            } else if (ch == '[') {
                tracker.push (new NestedInteger ());
            } else if ( ch == ']') {

                NestedInteger top = tracker.pop ();
                if (!tracker.isEmpty ()) {
                    NestedInteger temp2 = tracker.pop ();
                    temp2.add (top);
                    tracker.push (temp2);
                }
                else {
                    return top;
                }

            }
        }
        
        return new NestedInteger (sigma * number);
    }
}