leetcode MiniParser
z
 2019-04-09 10:36:27   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
import utils.NestedInteger;

import java.util.Stack;

public class MiniParser {
  /*
  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.

     * // 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 NestedInteger deserialize(String s) {
        if (s.charAt(0) != '[') return new NestedInteger(Integer.parseInt(s));
        Stack<NestedInteger> stack = new Stack<>();
        NestedInteger result = null;

        for (int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            if (ch == '[') {
            // Create a list, add it to outer list and push it to the top of stack anyway

                NestedInteger curr = new NestedInteger();
                if (!stack.empty()) {
                    stack.peek().add(curr);
                }
                stack.push(curr);
            }
            else if (ch == ']'){
            // pop the inner list

                if (!stack.empty()) result = stack.pop();
            }
            else if (Character.isDigit(ch) || ch == '-') {
            // Fetch the number and add to the list on the top.

                String num = "" + ch;
                while (i < s.length() - 1 && Character.isDigit(s.charAt(i + 1))) {
                    num = num + s.charAt(++i);
                }
                stack.peek().add(new NestedInteger(Integer.parseInt(num)));
            }
        }
        return result;
    }
       */
  public NestedInteger deserialize(String s) {
    if(s==null && s.length() == 0)
      return new NestedInteger();
    if (!s.startsWith("[")){
      return new NestedInteger(Integer.valueOf(s));
    }
    Stack<NestedInteger> stack = new Stack<>();
    NestedInteger res = null;
    for (int i=0; i<s.length(); i++){
      char c = s.charAt(i);
      if (c == '['){
        NestedInteger n = new NestedInteger();
        if (!stack.isEmpty()){
          stack.peek().add(n);
        }
        stack.push(n);
      }
      else if (c == ']'){
        res = stack.pop();
      }

      else{
        if (Character.isDigit(c) || c == '-'){
          int num = 0;
          int sign = 1;
          if (c == '-')
            sign = -1;
          else
            num = c - '0';
          while(i+1 < s.length() && Character.isDigit(s.charAt(i+1)) ){
            num = num * 10 + s.charAt(i+1) - '0';
            i++;
          }

          stack.peek().add(new NestedInteger(num*sign));
        }
      }
    }
    return res;
  }
}