算法-字符串几大经典

字符串经典算法

1、Z字形变换

• 从左向右迭代字符串，我们可以轻松地确定字符位于 Z 字形图案中的哪一行。

• 输入：s = "PAYPALISHIRING", numRows = 4
  输出："PINALSIGYAHRPI"
  解释：
  P     I    N
  A   L S  I G
  Y A   H R
  P     I
  

• class Solution {
      public String convert(String s, int numRows) {
           if (numRows == 1) return s;
  
          List<StringBuilder> rows = new ArrayList<>();
          for (int i = 0; i < Math.min(numRows, s.length()); i++)
              rows.add(new StringBuilder());
  
          int curRow = 0;
          boolean goingDown = false;
  
          for (char c : s.toCharArray()) {
              rows.get(curRow).append(c);
              if (curRow == 0 || curRow == numRows - 1) goingDown = !goingDown;
              curRow += goingDown ? 1 : -1;
          }
  
          StringBuilder ret = new StringBuilder();
          for (StringBuilder row : rows) ret.append(row);
          return ret.toString();
  
      }
  }
  

2、串联所有单词的子串

• 单词长度固定的，计算出截取字符串的单词个数是否和 words 里相等，所以我们可以借用哈希表。一个是哈希表是 words，一个哈希表是截取的字符串，比较两个哈希是否相等！

• 输入：s = "barfoothefoobarman", words = ["foo","bar"]
  输出：[0,9]
  解释：
  从索引 0 和 9 开始的子串分别是 "barfoo" 和 "foobar" 。
  输出的顺序不重要, [9,0] 也是有效答案。
  

• class Solution {
      public List<Integer> findSubstring(String s, String[] words) {
          List<Integer> res = new ArrayList<>();
          if (s == null || s.length() == 0 || words == null || words.length == 0) return res;
          HashMap<String, Integer> map = new HashMap<>();
          int one_word = words[0].length();
          int word_num = words.length;
          int all_len = one_word * word_num;
          for (String word : words) {
              map.put(word, map.getOrDefault(word, 0) + 1);
          }
          for (int i = 0; i < s.length() - all_len + 1; i++) {
              String tmp = s.substring(i, i + all_len);
              HashMap<String, Integer> tmp_map = new HashMap<>();
              for (int j = 0; j < all_len; j += one_word) {
                  String w = tmp.substring(j, j + one_word);
                  tmp_map.put(w, tmp_map.getOrDefault(w, 0) + 1);
              }
              if (map.equals(tmp_map)) res.add(i);
          }
          return res;
      }
  }
  
  //getOrDefault() 方法获取指定 key 对应对 value，如果找不到 key ，则返回设置的默认值。
  

3、字母异位词分组

• 由于互为字母异位词的两个字符串包含的字母相同，因此对两个字符串分别进行排序之后得到的字符串一定是相同的，故可以将排序之后的字符串作为哈希表的键。

• 给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。
  字母异位词 是由重新排列源单词的字母得到的一个新单词，所有源单词中的字母通常恰好只用一次。
  输入: strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
  输出: [["bat"],["nat","tan"],["ate","eat","tea"]]
  

• class Solution {
      public List<List<String>> groupAnagrams(String[] strs) {
          Map<String, List<String>> map = new HashMap<String, List<String>>();
          for (String str : strs) {
              char[] array = str.toCharArray();
              Arrays.sort(array);
              String key = new String(array);
              List<String> list = map.getOrDefault(key, new ArrayList<String>());
              list.add(str);
              map.put(key, list);
          }
          return new ArrayList<List<String>>(map.values());
      }
  }
  
  

4、最长回文子串

• 在状态转移方程中，我们是从长度较短的字符串向长度较长的字符串进行转移的，因此一定要注意动态规划的循环顺序。

• 输入：s = "babad"
  输出："bab"
  解释："aba" 同样是符合题意的答案。
  

• public class Solution {
      public String longestPalindrome(String s) {
          int len = s.length();
          if (len < 2) {
              return s;
          }
          int maxLen = 1;
          int begin = 0;
          // dp[i][j] 表示 s[i..j] 是否是回文串
          boolean[][] dp = new boolean[len][len];
          // 初始化：所有长度为 1 的子串都是回文串
          for (int i = 0; i < len; i++) {
              dp[i][i] = true;
          }
          char[] charArray = s.toCharArray();
          // 递推开始
          // 先枚举子串长度
          for (int L = 2; L <= len; L++) {
              // 枚举左边界，左边界的上限设置可以宽松一些
              for (int i = 0; i < len; i++) {
                  // 由 L 和 i 可以确定右边界，即 j - i + 1 = L 得
                  int j = L + i - 1;
                  // 如果右边界越界，就可以退出当前循环
                  if (j >= len) {
                      break;
                  }
                  if (charArray[i] != charArray[j]) {
                      dp[i][j] = false;
                  } else {
                      if (j - i < 3) {
                          dp[i][j] = true;
                      } else {
                          dp[i][j] = dp[i + 1][j - 1];
                      }
                  }
  
                  // 只要 dp[i][L] == true 成立，就表示子串 s[i..L] 是回文，此时记录回文长度和起始位置
                  if (dp[i][j] && j - i + 1 > maxLen) {
                      maxLen = j - i + 1;
                      begin = i;
                  }
              }
          }
          return s.substring(begin, begin + maxLen);
      }
  }