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.

 

 

Analysis:

One function to parse a list; one function to parse an integer.

 

Solution:

/**
 * // 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.length()==0) return null;
        
        NestedInteger res;
        if (s.charAt(0)=='['){
            res = new NestedInteger();
            parseList(s,0,res);
        } else {
            res = new NestedInteger(0);
            parseInt(s,0,res);
        }
        
        return res;
    }
    
    // Parse a list starting from index @cur
    public int parseList(String s, int cur, NestedInteger res){
        // list always start with '[', skip it
        cur++;
        
        while (s.charAt(cur)!=']'){
            if (s.charAt(cur)=='['){
                // next element is a list.
                NestedInteger next = new NestedInteger();
                cur = parseList(s,cur,next);
                res.add(next);
            } else {
                NestedInteger next = new NestedInteger(0);
                cur = parseInt(s,cur,next);
                res.add(next);
            }
        }
        
        // skip ']'
        cur++;
        
        // skip the following ','
        if (cur<s.length() && s.charAt(cur) == ',') cur++;
        
        return cur;
    }
    
    // Parse an integer typed NestedInteger starting from index @cur
    public int parseInt(String s, int cur, NestedInteger res){
        boolean isNegative = false;
        if (s.charAt(cur) == '-'){
            isNegative = true;
            cur++;
        }
        
        int num = 0;
        while (cur<s.length() && s.charAt(cur) >='0' && s.charAt(cur) <='9'){
            num = num*10+(s.charAt(cur) - '0');
            cur++;
        }
        if (isNegative){
            num = -num;
        }
        res.setInteger(num);
        
        // Skip the following ','
        if (cur<s.length() && s.charAt(cur) == ',') cur++;
        
        return cur;
    }
}