第385题---Mini Parse

• 题意描述：给定一个嵌套整数列表的字符串，返回的他的NestedInteger类的结构体，反序列化？

• 思路：遍历字符串，判断是不是’[‘,如果是，则进入parseList函数，不是则进入parseNum函数；

  • parseList函数，判断是不是[，如果是，则进入parseList函数，递归了，如果是-或者数，进入parseNum函数，如果是，跳过，如果是]break，结束
  • parseNum函数，判断正负，从index 遍历，获得数值，返回构造的NestedInteger类对象

• 代码

  /**
   * // This is the interface that allows for creating nested lists.
   * // You should not implement it, or speculate about its implementation
   * class NestedInteger {
   *   public:
   *     // Constructor initializes an empty nested list.
   *     NestedInteger();
   *
   *     // Constructor initializes a single integer.
   *     NestedInteger(int value);
   *
   *     // Return true if this NestedInteger holds a single integer, rather than a nested list.
   *     bool isInteger() const;
   *
   *     // Return the single integer that this NestedInteger holds, if it holds a single integer
   *     // The result is undefined if this NestedInteger holds a nested list
   *     int getInteger() const;
   *
   *     // Set this NestedInteger to hold a single integer.
   *     void setInteger(int value);
   *
   *     // Set this NestedInteger to hold a nested list and adds a nested integer to it.
   *     void add(const NestedInteger &ni);
   *
   *     // Return the nested list that this NestedInteger holds, if it holds a nested list
   *     // The result is undefined if this NestedInteger holds a single integer
   *     const vector<NestedInteger> &getList() const;
   * };
   */
  class Solution {
  public:
      NestedInteger deserialize(string s) {
          int index = 0;
          char c = s[index];
          if (c == '[') {
              return parseList(s, index);
          } else {
              return parseNum(s, index);
          }
      }
      
      NestedInteger parseList(string &s, int &index) {
          index ++; // eat '['
          NestedInteger root;
          while(index < s.size()) {
              char c = s[index];
              if (c == '[') {
                  root.add(parseList(s, index));
              } else if (c == '-' || isNumber(c)) {
                  root.add(parseNum(s, index));
              } else if (c == ',') {
                  index ++;
              } else if (c == ']') {
                  break;
              }
          }
          index ++;
          return root;
      }
      
      NestedInteger parseNum(string &s, int &index) {
          int n = 0;
          int positive = 1;
          if(s[index] == '-') {
              positive = -1;
              index ++;
          }
          
          while(index < s.size()) {
              char c = s[index];
              if (isNumber(c)) {
                  n = 10 * n + c - '0';
                  index ++;
              } else {
                  break;
              }
          }
          return NestedInteger(n * positive);
      }
      
      bool isNumber(char c) {
          return '0' <= c  && c <= '9';
      }
  };