剑指 Offer 05. 替换空格（Easy）

题目描述

• 请实现一个函数，把字符串 s 中的每个空格替换成"%20"。
• 限制：0 <= s 的长度 <= 10000。

举例说明

• 示例 1：
  • 输入：s = “We are happy.”。
  • 输出：“We%20are%20happy.”。

解题思路

• 在 Java 中，字符串都被设计成不可变类型，即无法直接修改字符串的某一位字符，需要新建一个字符串实现。
• 算法流程：
  • 初始化一个 StringBuilder 对象，记为 res；
  • 遍历列表 s 中的每个字符 c ：
    • 当 c 为空格时，向 res 添加字符串 “%20” ；
    • 当 c 不为空格时，向 res 后添加字符 c；
    • 将列表 res 转化为字符串并返回。
• 代码示例：

  class Solution {
      public String replaceSpace(String s) {
          StringBuilder res = new StringBuilder();
          for (char c : s.toCharArray()) {
              if (c == ' ') {
                  res.append("%20");
              }else {
                  res.append(c);
              }
          }
          return res.toString();
      }
  }
  

• 复杂度分析：
  • 时间复杂度 O(N)：
    • 遍历使用 O(N)，每轮添加（修改）字符操作使用 O(1)；
  • 空间复杂度 O(N)：
    • Java 新建的 StringBuilder 使用了线性大小的额外空间。

剑指 Offer 58 - II. 左旋转字符串（Easy）

题目描述

• 字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。
• 请定义一个函数实现字符串左旋转操作的功能。
  • 比如，输入字符串 “abcdefg” 和数字 2，该函数将返回左旋转两位得到的结果 “cdefgab”。
• 限制：1 <= k < s.length <= 10000。

举例说明

• 示例 1：
  • 输入: s = “abcdefg”, k = 2。
  • 输出: “cdefgab”。
• 示例 2：
  • 输入: s = “lrloseumgh”, k = 6。
  • 输出: “umghlrlose”。

解题思路

• 算法流程：
  • 新建一个 StringBuilder 对象，记为 res；
  • 先向 res 添加 “第 n+1 位至末位的字符”；
  • 再向 res 添加 “首位至第 n 位的字符” ；
  • 将 res 转化为字符串并返回。
• 代码示例：

  class Solution {
      public String reverseLeftWords(String s, int n) {
          StringBuilder res = new StringBuilder();
          for(int i = n; i < s.length(); i++)
              res.append(s.charAt(i));
          for(int i = 0; i < n; i++)
              res.append(s.charAt(i));
          return res.toString();
      }
  }
  

• 复杂度分析：
  • 时间复杂度 O(N)
    • 线性遍历 s 并添加，使用线性时间。
  • 空间复杂度 O(N)
    • 新建的辅助 res 使用 O(N) 大小的额外空间。

剑指 Offer 20. 表示数值的字符串（Medium）

题目描述

• 请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。
• 数值（按顺序）可以分成以下几个部分：
  • 若干空格；
  • 一个小数或者整数（可选）；
  • 一个 ‘e’ 或 ‘E’ ，后面跟着一个整数；
  • 若干空格；
  • 小数（按顺序）可以分成以下几个部分：
    • （可选）一个符号字符（‘+’ 或 ‘-’）；
    • 下述格式之一：
      • 至少一位数字，后面跟着一个点 ‘.’；
      • 至少一位数字，后面跟着一个点 ‘.’ ，后面再跟着至少一位数字；
      • 一个点 ‘.’ ，后面跟着至少一位数字。
  • 整数（按顺序）可以分成以下几个部分：
    • （可选）一个符号字符（‘+’ 或 ‘-’）；
    • 至少一位数字。
  • 部分数值列举如下：
    • [“+100”, “5e2”, “-123”, “3.1416”, “-1E-16”, “0123”]。
  • 部分非数值列举如下：
    • [“12e”, “1a3.14”, “1.2.3”, “±5”, “12e+5.4”]。

举例说明

• 示例 1：
  • 输入：s = “0”。
  • 输出：true。
• 示例 2：
  • 输入：s = “e”。
  • 输出：false。
• 示例 3：
  • 输入：s = “.”。
  • 输出：false。
• 示例 4：
  • 输入：s = " .1 "。
  • 输出：true。

解题思路

• 本题使用有限状态自动机。
  • 根据字符类型和合法数值的特点，先定义状态，再画出状态转移图，最后编写代码即可。
  • 字符类型：
    • 空格、数字 [0-9] 、正负号 [±] 、小数点 、幂符号 [e, E]。
  • 状态定义：
    • 按照字符串从左到右的顺序，定义以下 9 种状态。
      • 开始的空格；
      • 幂符号前的正负号；
      • 小数点前的数字；
      • 小数点、小数点后的数字；
      • 当小数点前为空格时，小数点、小数点后的数字；
      • 幂符号；
      • 幂符号后的正负号；
      • 幂符号后的数字；
      • 结尾的空格。
  • 结束状态：
    • 合法的结束状态有 2, 3, 7, 8。
      
• 算法流程：
  • 初始化：
    • 状态转移表 states：
      • 设 states[i]，其中 i 为所处状态，states[i] 使用哈希表存储可转移至的状态。
      • 键值对 (key,value) 含义：若输入 key，则可从状态 i 转移至状态 value。
    • 当前状态 p：起始状态初始化为 p=0。
  • 状态转移循环：遍历字符串 s 的每个字符 c。
    • 记录字符类型 t：分为四种情况。
      • 当 c 为正负号时，执行 t = ‘s’;
      • 当 c 为数字时，执行 t = ‘d’;
      • 当 c 为 e, E 时，执行 t = ‘e’;
      • 当 c 为 ., 空格 时，执行 t = c （即用字符本身表示字符类型）;
      • 否则，执行 t = ‘?’ ，代表为不属于判断范围的非法字符，后续直接返回 false。
    • 终止条件： 若字符类型 t 不在哈希表 states[p] 中，说明无法转移至下一状态，因此直接返回 False。
    • 状态转移： 状态 p 转移至 states[p][t]。
  • 返回值：跳出循环后，若状态 p∈2,3,7,8，说明结尾合法，返回 True，否则返回 False。
• 代码示例：

  class Solution {
      public boolean isNumber(String s) {
          Map[] states = {
              new HashMap<>() {{ put(' ', 0); put('s', 1); put('d', 2); put('.', 4); }}, // 0.
              new HashMap<>() {{ put('d', 2); put('.', 4); }},                           // 1.
              new HashMap<>() {{ put('d', 2); put('.', 3); put('e', 5); put(' ', 8); }}, // 2.
              new HashMap<>() {{ put('d', 3); put('e', 5); put(' ', 8); }},              // 3.
              new HashMap<>() {{ put('d', 3); }},                                        // 4.
              new HashMap<>() {{ put('s', 6); put('d', 7); }},                           // 5.
              new HashMap<>() {{ put('d', 7); }},                                        // 6.
              new HashMap<>() {{ put('d', 7); put(' ', 8); }},                           // 7.
              new HashMap<>() {{ put(' ', 8); }}                                         // 8.
          };
          int p = 0;
          char t;
          for(char c : s.toCharArray()) {
              if(c >= '0' && c <= '9') t = 'd';
              else if(c == '+' || c == '-') t = 's';
              else if(c == 'e' || c == 'E') t = 'e';
              else if(c == '.' || c == ' ') t = c;
              else t = '?';
              if(!states[p].containsKey(t)) return false;
              p = (int)states[p].get(t);
          }
          return p == 2 || p == 3 || p == 7 || p == 8;
      }
  }
  

• 复杂度分析：
  • 时间复杂度 O(N)： 其中 N 为字符串 s 的长度，判断需遍历字符串，每轮状态转移的使用 O(1) 时间。
  • 空间复杂度 O(1)： states 和 p 使用常数大小的额外空间。

剑指 Offer 67. 把字符串转换成整数（Medium）

题目描述

• 写一个函数 StrToInt，实现把字符串转换成整数这个功能。
  • 首先，该函数会根据需要丢弃无用的开头空格字符，直到寻找到第一个非空格的字符为止。
  • 当我们寻找到的第一个非空字符为正或者负号时，则将该符号与之后面尽可能多的连续数字组合起来，作为该整数的正负号；
  • 假如第一个非空字符是数字，则直接将其与之后连续的数字字符组合起来，形成整数。
  • 该字符串除了有效的整数部分之后也可能会存在多余的字符，这些字符可以被忽略，它们对于函数不应该造成影响。
• 注意
  • 假如该字符串中的第一个非空格字符不是一个有效整数字符、字符串为空或字符串仅包含空白字符时，则你的函数不需要进行转换。
  • 在任何情况下，若函数不能进行有效的转换时，请返回 0。
  • 不能使用 atoi 或者其他类似的库函数。
  • 假设我们的环境只能存储 32 位大小的有符号整数，那么其数值范围为 [$-2^{31}$, $2^{31}-1$]。
  • 如果数值超过这个范围，请返回 INT_MAX ($2^{31}-1$) 或 INT_MIN ($-2^{31}$) 。

举例说明

• 示例 1:
  • 输入: “42”。
  • 输出: 42。
• 示例 2:
  • 输入: " -42"。
  • 输出: -42。
  • 解释: 第一个非空白字符为 ‘-’, 它是一个负号。我们尽可能将负号与后面所有连续出现的数字组合起来，最后得到 -42 。
• 示例 3:
  • 输入: “4193 with words”。
  • 输出: 4193。
  • 解释: 转换截止于数字 ‘3’ ，因为它的下一个字符不为数字。
• 示例 4:
  • 输入: “words and 987”。
  • 输出: 0。
  • 解释: 第一个非空字符是 ‘w’, 但它不是数字或正、负号。因此无法执行有效的转换。
• 示例 5:
  • 输入: “-91283472332”。
  • 输出: -2147483648。
  • 解释: 数字 “-91283472332” 超过 32 位有符号整数范围。 因此返回 INT_MIN ($-2^{31}$)) 。

解题思路

• 字符串可能包含下面三种类型：
  • 空格，在转换的时候需要过滤掉；
  • 正负号，如果是正号则忽略，是负号则需要记录这个正负号状态；
  • 任意字符，我们只需要"0"到"9"这几个字符。
• 当字符串大于最大的 32 位整数，或者小于最小的 32 位整数，后面就不用判断了。
• 题目要求是只能存储 32 位大小的有符号整数，所以不能用 long 做存储，而且需要提前判断整数的大小。
• 算法流程：
  • 过滤掉前面若干个空格(如果有的话)；
  • 判断正号、负号位，如果是负号则记录下状态，表示输入的是负数；
  • 循环判断后面的字符串是否是 0 到 9，如果是则累加这个值；
  • 当前的值跟最大、最小 32 位整数比较看是否溢出；
  • 循环结束后，根据负号的标志位返回对应的正数或负数。
• 代码示例：

  class Solution {
      public int strToInt(String str) {
          int cur = 0;
          int len = str.length();
          int res = 0;
          int sign = 1;
          if (str == null || len <= 0) {
              return 0;
          } 
  
          while (cur < len && str.charAt(cur) == ' ') {
              cur++;
          }
  
          if (cur == len) {
              return 0;
          }
  
  		if(str.charAt(cur) == '-') {
  			sign = -1;
  		}
  		
  		if(str.charAt(cur) == '-' || str.charAt(cur) == '+') {
  			cur++;
  		}
  
          while (cur < len && str.charAt(cur) >= '0' && str.charAt(cur) <= '9') {
              int temp = str.charAt(cur) - '0';
              if ((res > Integer.MAX_VALUE / 10 || (res == Integer.MAX_VALUE / 10 && temp > Integer.MAX_VALUE % 10))) {
                  return Integer.MAX_VALUE;
              }
              if ((res < Integer.MIN_VALUE / 10 || (res == Integer.MIN_VALUE / 10 && temp > -(Integer.MIN_VALUE % 10)))) {
                  return Integer.MIN_VALUE;
              }
              res = res * 10 + sign * temp;
              cur++;
          }
  
          return res;
      }
  }
  

• 复杂度分析：
  • 时间复杂度：O(N)，这里 N 为字符串的长度；
  • 空间复杂度：O(1)。