LeetCode 385. Mini Parser(java)

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.

我的思路：用两个栈，stack1[String], Stack2[NestedInteger]，先通过split函数得到所有的数字，然后从右向左遍历字符串，四种情况进行分析，每次得到一个完整的NestedInteger List以后就放进stack2里，等待下次被装箱。

/**
 * // 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) {
        //special case
        NestedInteger res = new NestedInteger();
        if (s.length() == 0) return res;
        //general case
        String[] ss = s.split(",|\\[|\\]");
        List<String> nums = new ArrayList<>();
        for (String str : ss) {
            if (!str.equals("")) {
                nums.add(str);
            }
        }
        int index = nums.size() - 1;
        Stack<String> stack = new Stack<>();
        Stack<NestedInteger> stack2 = new Stack<>();
        for (int i = s.length() - 1; i >= 0; i--) {
            char c = s.charAt(i);
            if (c == ']') {
                stack.push("]");
            } else if (c == '['){
                NestedInteger cur = new NestedInteger();
                while (stack.peek() != "]") {
                    cur.add(stack2.pop());
                    stack.pop();
                }
                stack.pop();
                stack.push("N");
                stack2.push(cur);
            } else if (c == ','){
                continue;
            } else {
                String str = nums.get(index);
                i = i - str.length() + 1;
                stack.push(nums.get(index--));
                int num = stringToNum(str);
                NestedInteger temp = new NestedInteger(num);
                stack2.push(temp);
            }
        }
        return stack2.pop();
    }
    public int stringToNum(String s) {
        int negative = 0, num = 0;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c == '-') {
                negative = 1;
                continue;
            }
            num = num * 10 + c - '0';
        }
        return negative == 0 ? num : -num;
    }
}