力扣刷题：字符串篇

忘是亡心i 2022-10-16 09:40 216阅读 0赞

### 目录 ###

*  14. 最长公共前缀
 *   *  题目介绍
     *  题目实现
 *  151. 翻转字符串里的单词
 *   *  题目介绍
     *   *   *  \[剑指 Offer 58 - I. 翻转单词顺序\](https://leetcode-cn.com/problems/fan-zhuan-dan-ci-shun-xu-lcof/)
     *  题目实现
 *  242. 有效的字母异位词
 *   *  题目介绍
     *  题目实现
 *  3. 无重复字符的最长子串
 *   *  题目介绍
     *  题目实现
 *  344. 反转字符串
 *   *  题目介绍
     *  题目实现
 *  572. 另一个树的子树
 *   *  题目介绍
     *  题目介绍
 *  8. 字符串转换整数 (atoi)
 *   *  题目介绍
     *  题目实现
 *  面试题 01.09. 字符串轮转
 *   *  题目介绍
     *  题目实现

--------------------

# 14. 最长公共前缀 #

## 题目介绍 ##

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 `""`。

**示例 1：**

输入：strs = ["flower","flow","flight"]
    输出："fl"

**示例 2：**

输入：strs = ["dog","racecar","car"]
    输出：""
    解释：输入不存在公共前缀。

提示：

*  0 <= strs.length <= 200
 *  0 <= strs\[i\].length <= 200
 *  strs\[i\] 仅由小写英文字母组成

来源：力扣（LeetCode）  
链接：https://leetcode-cn.com/problems/longest-common-prefix  
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

## 题目实现 ##

纵向扫描时，从前往后遍历所有字符串的每一列，比较相同列上的字符是否相同，如果相同则继续对下一列进行比较，如果不相同则当前列不再属于公共前缀，当前列之前的部分为最长公共前缀。

![753035295165ae0cba0f43268bcd31c7.png][]

class Solution { 
        public String longestCommonPrefix(String[] strs) { 
            if (strs == null || strs.length == 0) return "";
            for (int i = 0; i < strs[0].length(); i++) { 
                char c = strs[0].charAt(i);
                for (int j = 1; j < strs.length; j++) { 
                    if (i == strs[j].length() || strs[j].charAt(i) != c) { 
                        return strs[0].substring(0, i);
                    }
                }
            }
            return strs[0];
        }
    }

# 151. 翻转字符串里的单词 #

## 题目介绍 ##

给定一个字符串，逐个翻转字符串中的每个单词。

**说明：**

*  无空格字符构成一个 单词 。
 *  输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。
 *  如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。

**示例 1：**

输入："the sky is blue"
    输出："blue is sky the"

**示例 2：**

输入："  hello world!  "
    输出："world! hello"
    解释：输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。

**示例 3：**

输入："a good   example"
    输出："example good a"
    解释：如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。

**示例 4：**

输入：s = "  Bob    Loves  Alice   "
    输出："Alice Loves Bob"

**示例 5：**

输入：s = "Alice does not even like bob"
    输出："bob like even not does Alice"

**提示：**

*  1 <= s.length <= 104
 *  s 包含英文大小写字母、数字和空格 ’ ’
 *  s 中 **至少存在一个** 单词

**相同题目：**

*  #### [剑指 Offer 58 - I. 翻转单词顺序][Offer 58 - I.] ####

来源：力扣（LeetCode）  
链接：https://leetcode-cn.com/problems/reverse-words-in-a-string  
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

## 题目实现 ##

对于这道题目的解法，我们应该做以下两个部分的处理：

1.  消除字符串中的多余空格
2.  对指定范围的字符串逆序

**1、消除字符串中的多余空格**

去除多余空格之前：

![image-20210522120649505][]

去除多余空格之后：

![207096e16b1c6d969e43bbba6a684494.png][]

具体去除做法如下：

*  定义一个指针 `i`，用来从左向右依次扫描数组中的每一个元素。
 *  定义一个指针 `cur`，用来指向去除多余空格后应该指向的位置。
 *  定义一个标志 `space`，用来记录前一个字母是不是一个空格位。

// 消除字符串中的多余空格
    int len = 0;                    // 字符串最终的有效长度
    int cur = 0;                    // 用来记存放字符的位置
    boolean space = true;           // 前一个字符是否为空格，下标 -1 处，代表空格，所以默认 true
    char[] chars = s.toCharArray(); // 用来优化获取字符速度
    for (int i = 0; i < chars.length; i++) { 
        if (chars[i] != ' ') {       // 不等于空格代表是字符
            chars[cur++] = chars[i];// 是字符的话就直接拷贝
            space = false;          // 重置前一个字符非空格
        } else {                     // 到这里来肯定是空格符
            if (space == false) {    // 如果前一个字符非空格
                chars[cur++] = ' '; // 那我就拷贝一个空格符
                space = true;       // 重置前一个字符是空格
            }
        }
    }
    len = space ? (cur - 1) : cur;  // 计算有效字符串的长度

**2、对指定范围的字符串逆序**

![31fd86e39af1889b5608c7e824b12ec4.png][]

// 将[li, ri)范围内的字符串进行逆序
    private void reverse(char[] chars, int li, int ri) { 
        ri--;
        while (li < ri) { 
            char tmp = chars[li];
            chars[li] = chars[ri];
            chars[ri] = tmp;
            li++;
            ri--;
        }
    }

最终完整的代码如下：

class Solution { 
        public String reverseWords(String s) { 
            // 对输入字符串的临界判断
            if (s == null || s.length() == 0) return "";
            // 消除字符串中的多余空格
            int len = 0;                    // 字符串最终的有效长度
            int cur = 0;                    // 用来记存放字符的位置
            boolean space = true;           // 前一个字符是否为空格，下标 -1 处，代表空格，所以默认 true
            char[] chars = s.toCharArray(); // 用来优化获取字符速度
            for (int i = 0; i < chars.length; i++) { 
                if (chars[i] != ' ') {       // 不等于空格代表是字符
                    chars[cur++] = chars[i];// 是字符的话就直接拷贝
                    space = false;          // 重置前一个字符非空格
                } else {                     // 到这里来肯定是空格符
                    if (space == false) {    // 如果前一个字符非空格
                        chars[cur++] = ' '; // 那我就拷贝一个空格符
                        space = true;       // 重置前一个字符是空格
                    }
                }
            }
            len = space ? (cur - 1) : cur;  // 计算有效字符串的长度
            if (len <= 0) return "";        // 代表字符串全部是空格
            // 对指定范围的字符串逆序
            reverse(chars, 0, len);                 // 对整个字符串逆序
            int prevSapceIdx = -1;
            for (int i = 0; i < len; i++) { 
                if (chars[i] != ' ') continue;
                reverse(chars, prevSapceIdx + 1, i);
                prevSapceIdx = i;
            }
            reverse(chars, prevSapceIdx + 1, len);  // 反转最后一个单词
            return new String(chars, 0, len);
        }
    
        // 将[li, ri)范围内的字符串进行逆序
        private void reverse(char[] chars, int li, int ri) { 
            ri--;
            while (li < ri) { 
                char tmp = chars[li];
                chars[li] = chars[ri];
                chars[ri] = tmp;
                li++;
                ri--;
            }
        }
    }

# 242. 有效的字母异位词 #

## 题目介绍 ##

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

**示例 1：**

输入: s = "anagram", t = "nagaram"
    输出: true

**示例 2：**

输入: s = "rat", t = "car"
    输出: false

**说明：**

*  你可以假设字符串只包含小写字母。

**进阶：**

*  如果输入字符串包含 unicode 字符怎么办？你能否调整你的解法来应对这种情况？

来源：力扣（LeetCode）  
链接：https://leetcode-cn.com/problems/valid-anagram  
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

## 题目实现 ##

`t` 是 `s` 的异位词等价于「`两个字符串中字符出现的种类和次数均相等`」。由于字符串只包含 `26` 个小写字母，因此我们可以维护一个长度为 `26` 的频次数组 `table`，先遍历记录字符串 s 中字符出现的频次，然后遍历字符串 `t`，减去 `table` 中对应的频次，如果出现 `--table[tChars[i] - 97] < 0`，则说明 `t` 包含一个不在 `s` 中的额外字符，返回 `false` 即可。

class Solution { 
        public boolean isAnagram(String s, String t) { 
            if (s == null || t == null) return false;
            if (s.length() != t.length()) return false;
            int[] table = new int[26];
            char[] sChars = s.toCharArray();
            char[] tChars = t.toCharArray();
            for (int i = 0; i < sChars.length; i++) { 
                table[sChars[i] - 97]++;
            }
            for (int i = 0; i < tChars.length; i++) { 
                if (--table[tChars[i] - 97] < 0) return false;
            }
            return true;
        }
    }

# 3. 无重复字符的最长子串 #

## 题目介绍 ##

给定一个字符串，请你找出其中不含有重复字符的 **最长子串** 的长度。

**示例 1：**

输入: s = "abcabcbb"
    输出: 3 
    解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。

**示例 2：**

输入: s = "bbbbb"
    输出: 1
    解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。

**示例 3：**

输入: s = "pwwkew"
    输出: 3
    解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
    请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。

**示例 4：**

输入: s = ""
    输出: 0

**提示：**

*  0 <= s.length <= 5 \* 104
 *  s 由英文字母、数字、符号和空格组成

来源：力扣（LeetCode）  
链接：https://leetcode-cn.com/problems/longest-substring-without-repeating-characters  
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

## 题目实现 ##

我们不妨以示例一中的字符串 **abcabcbb** 为例，找出 **从每一个字符开始的，不包含重复字符的最长子串** ，那么其中最长的那个字符串即为答案。对于示例一中的字符串，我们列举出这些结果，其中括号中表示选中的字符以及最长的字符串：

![2824e6fd2cf7d3967943219bf4fc06ad.png][]

发现了什么？如果我们依次递增地枚举子串的起始位置，那么子串的结束位置也是递增的！这里的原因在于，假设我们选择字符串中的第 k 个字符作为起始位置，并且得到了不包含重复字符的最长子串的结束位置为 rk 。那么当我们选择第 k+1 个字符作为起始位置时，首先从 k+1 到 rk 的字符显然是不重复的，并且由于少了原本的第 k 个字符，我们可以尝试继续增大 rk ，直到右侧出现了重复字符为止。

这样一来，我们就可以使用 **滑动窗口** 来解决这个问题了：

*  我们使用两个指针表示字符串中的某个子串（或窗口）的左右边界，其中左指针代表着上文中「枚举子串的起始位置」，而右指针即为上文中的 rk；
 *  在每一步的操作中，我们会将左指针向右移动一格，表示 **我们开始枚举下一个字符作为起始位置** ，然后我们可以不断地向右移动右指针，但需要保证这两个指针对应的子串中没有重复的字符。在移动结束后，这个子串就对应着 **以左指针开始的，不包含重复字符的最长子串** ，我们记录下这个子串的长度；
 *  在枚举结束后，我们找到的最长的子串的长度即为答案。

在上面的流程中，我们还需要使用一种数据结构来判断 **是否有重复的字符** ，常用的数据结构为哈希集合。在左指针向右移动的时候，我们从哈希集合中移除一个字符，在右指针向右移动的时候，我们往哈希集合中添加一个字符。

至此，我们就完美解决了本题。

class Solution { 
        public int lengthOfLongestSubstring(String s) { 
            // 哈希集合，记录每个字符是否出现过
            HashSet<Character> hashSet = new HashSet<>();
            int n = s.length();
            int ans = 0;
            // 右指针rk，初始值为 -1，相当于我们在字符串的左边界的左侧，还没有开始移动
            for (int k = 0, rk = -1; k < n; k++) { 
                if (k != 0) { 
                    // 左指针向右移动一格，移除一个字符
                    hashSet.remove(s.charAt(k - 1));
                }
                while (rk + 1 < n && !hashSet.contains(s.charAt(rk + 1))) { 
                    // 不断地移动右指针
                    hashSet.add(s.charAt(rk + 1));
                    rk++;
                }
                // 第 k 到 rk 个字符是一个极长的无重复字符子串
                ans = Math.max(ans, rk - k + 1);
            }
            return ans;
        }
    }

本题中没有明确说明字符集，因此可以默认为所有 ASCII 码内的字符，提供另一种解题思路：

class Solution { 
        public int lengthOfLongestSubstring(String s) { 
            // 因为本题中字符串只含有英文字母，符号和数字，所以可以使用数组来代替哈希集合
            int[] map = new int[128];
            Arrays.fill(map, -1);
            int ans = 0;
            // 举例子："abcabcbb"
            for (int k = 0, rk = 0; rk < s.length(); rk++) { 
                char curr = s.charAt(rk);
                if (map[curr] > -1) { 
                    // 如果发现该字符出现过，那就让左边界的 k 移动上次出现的位置 + 1
                    // 取两者之中的较大值是防止左边界 k 向左移动，举例子："abba"
                    k = Math.max(k, map[curr] + 1);
                }
                // 记录或者更新 rk 出现的位置
                map[curr] = rk;
                // 第 k 到 rk 个字符是一个极长的无重复字符子串
                ans = Math.max(ans, rk - k + 1);
            }
            return ans;
        }
    }

除此之外，还有一种暴力方法：

class Solution { 
        public int lengthOfLongestSubstring(String s) { 
            if (s == null || s.length() == 0) return 0;
            char[] chars = s.toCharArray();
            int left = 0, right = 0, max = 0;
            HashSet<Character> hashSet = new HashSet<>();
            while (left < chars.length && right < chars.length) { 
                hashSet.clear();
                hashSet.add(chars[left]);
                right = left + 1;
                while (right < chars.length) { 
                    if (!hashSet.contains(chars[right]))
                        hashSet.add(chars[right++]);
                    else break;
                }
                left = left + 1;
                max = Math.max(max, hashSet.size());
            }
            return max;
        }
    }

# 344. 反转字符串 #

## 题目介绍 ##

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 `char[]` 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 `O(1)` 的额外空间解决这一问题。

你可以假设数组中的所有字符都是 `ASCII` 码表中的可打印字符。

示例 1：

输入：["h","e","l","l","o"]
    输出：["o","l","l","e","h"]

示例 2：

输入：["H","a","n","n","a","h"]
    输出：["h","a","n","n","a","H"]

来源：力扣（LeetCode）  
链接：https://leetcode-cn.com/problems/reverse-string  
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

## 题目实现 ##

正常解法：

class Solution { 
        public void reverseString(char[] s) { 
            int left = 0, right = s.length - 1;
            while (left < right) { 
                char temp = s[left];
                s[left++] = s[right];
                s[right--] = temp;
            }
        }
    }

优化解法：

class Solution { 
        public void reverseString(char[] s) { 
            int left = 0, right = s.length - 1;
            while (left < right) { 
                s[left] ^= s[right];
                s[right] ^= s[left];
                s[left++] ^= s[right--];
            }
        }
    }

# 572. 另一个树的子树 #

## 题目介绍 ##

给定两个非空二叉树 `s` 和 `t`，检验 `s` 中是否包含和 `t` 具有相同结构和节点值的子树。`s` 的一个子树包括 `s` 的一个节点和这个节点的所有子孙。`s` 也可以看做它自身的一棵子树。

**示例 1：**

给定的树 `s`：

3
        / \
       4   5
      / \
     1   2

给定的树 `t`：

4 
      / \
     1   2

返回 `true`，因为 `t` 与 `s` 的一个子树拥有相同的结构和节点值。

**示例 2：**

给定的树 `s`：

3
        / \
       4   5
      / \
     1   2
        /
       0

给定的树 `t`：

4
      / \
     1   2

返回 `false`。

来源：力扣（LeetCode）  
链接：https://leetcode-cn.com/problems/subtree-of-another-tree  
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

## 题目介绍 ##

我们将给定的 `s` 树使用后序遍历，序列化为一个字符串，节点之间使用 `!` 分隔，`null` 节点使用 `#` 来代替，如下图：

![8a7d74e7329acd08c24c5cad0b290630.png][]

我们将给定的 `t` 树使用后序遍历，序列化为一个字符串，节点之间使用 `!` 分隔，`null` 节点使用 `#` 来代替，如下图：

![e090dac0bec9cef101f74ef4336ab5b5.png][]

检验 `s` 中是否包含和 `t` 具有相同结构和节点值的子树。就转变为：检验 `s` 序列化后的字符串是否包含 `t` 序列化后的字符串的问题了。

class Solution { 
        public boolean isSubtree(TreeNode root, TreeNode subRoot) { 
            if (root == null || subRoot == null) return false;
            String rootSerialize = postorderSerialize(root);
            String subRootSerialize = postorderSerialize(subRoot);
            return rootSerialize.contains(subRootSerialize);
        }
    
        private String postorderSerialize(TreeNode root) { 
            StringBuilder sb = new StringBuilder();
            postorderSerialize(root, sb);
            return sb.toString();
        }
    
        private void postorderSerialize(TreeNode node, StringBuilder sb) { 
            if (node.left == null) { 
                sb.append("#").append("!");
            } else { 
                postorderSerialize(node.left, sb);
            }
            if (node.right == null) { 
                sb.append("#").append("!");
            } else { 
                postorderSerialize(node.right, sb);
            }
            sb.append(node.val).append("!");
        }
    }

# 8. 字符串转换整数 (atoi) #

## 题目介绍 ##

请你来实现一个 `myAtoi(string s)` 函数，使其能将字符串转换成一个 `32` 位有符号整数（类似 `C/C++` 中的 `atoi` 函数）。

函数 `myAtoi(string s)` 的算法如下：

1.  读入字符串并丢弃无用的前导空格。
2.  检查下一个字符（假设还未到字符末尾）为正还是负号，读取该字符（如果有）。 确定最终结果是负数还是正数。 如果两者都不存在，则假定结果为正。
3.  读入下一个字符，直到到达下一个非数字字符或到达输入的结尾。字符串的其余部分将被忽略。
4.  将前面步骤读入的这些数字转换为整数（即，“123” -> 123， “0032” -> 32）。如果没有读入数字，则整数为 0 。必要时更改符号（从步骤 2 开始）。
5.  如果整数数超过 32 位有符号整数范围 \[−231, 231 − 1\] ，需要截断这个整数，使其保持在这个范围内。具体来说，小于 −231 的整数应该被固定为 −231 ，大于 231 − 1 的整数应该被固定为 231 − 1 。
6.  返回整数作为最终结果。

注意：

*  本题中的空白字符只包括空格字符 ’ ’ 。
 *  除前导空格或数字后的其余字符串外，请勿忽略 任何其他字符。

**示例 1：**

输入：s = "42"
    输出：42
    解释：加粗的字符串为已经读入的字符，插入符号是当前读取的字符。
    第 1 步："42"（当前没有读入字符，因为没有前导空格）
             ^
    第 2 步："42"（当前没有读入字符，因为这里不存在 '-' 或者 '+'）
             ^
    第 3 步："42"（读入 "42"）
               ^
    解析得到整数 42 。
    由于 "42" 在范围 [-2^31, 2^31 - 1] 内，最终结果为 42 。

**示例 2：**

输入：s = "   -42"
    输出：-42
    解释：
    第 1 步："   -42"（读入前导空格，但忽视掉）
                ^
    第 2 步："   -42"（读入 '-' 字符，所以结果应该是负数）
                 ^
    第 3 步："   -42"（读入 "42"）
                   ^
    解析得到整数 -42 。
    由于 "-42" 在范围 [-2^31, 2^31 - 1] 内，最终结果为 -42 。

**示例 3：**

输入：s = "4193 with words"
    输出：4193
    解释：
    第 1 步："4193 with words"（当前没有读入字符，因为没有前导空格）
             ^
    第 2 步："4193 with words"（当前没有读入字符，因为这里不存在 '-' 或者 '+'）
             ^
    第 3 步："4193 with words"（读入 "4193"；由于下一个字符不是一个数字，所以读入停止）
                 ^
    解析得到整数 4193 。
    由于 "4193" 在范围 [-2^31, 2^31 - 1] 内，最终结果为 4193 。

**示例 4：**

输入：s = "words and 987"
    输出：0
    解释：
    第 1 步："words and 987"（当前没有读入字符，因为没有前导空格）
             ^
    第 2 步："words and 987"（当前没有读入字符，因为这里不存在 '-' 或者 '+'）
             ^
    第 3 步："words and 987"（由于当前字符 'w' 不是一个数字，所以读入停止）
             ^
    解析得到整数 0 ，因为没有读入任何数字。
    由于 0 在范围 [-2^31, 2^31 - 1] 内，最终结果为 0 。

**示例 5：**

输入：s = "-91283472332"
    输出：-2147483648
    解释：
    第 1 步："-91283472332"（当前没有读入字符，因为没有前导空格）
             ^
    第 2 步："-91283472332"（读入 '-' 字符，所以结果应该是负数）
              ^
    第 3 步："-91283472332"（读入 "91283472332"）
                         ^
    解析得到整数 -91283472332 。
    由于 -91283472332 小于范围 [-2^31, 2^31 - 1] 的下界，最终结果被截断为 -2^31 = -2147483648 。

**提示：**

*  0 <= s.length <= 200
 *  s 由英文字母（大写和小写）、数字（0-9）、’ ‘、’+’、’-’ 和 ‘.’ 组成

来源：力扣（LeetCode）  
链接：https://leetcode-cn.com/problems/string-to-integer-atoi  
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

## 题目实现 ##

class Solution { 
        public int myAtoi(String s) { 
            // 临界检查
            if (s == null) return 0;
            // 去除空格
            s = s.trim();
            // 临界检查
            if (s.length() == 0) return 0;
            // 字符数组
            char[] chars = s.toCharArray();
            // 符号检查
            int index = 0;
            int symbol = 1;
            if (chars[index] == '-') {           // 如果这个数是正数，并且第一字符为 -
                symbol = -1;
                index++;
            } else if (chars[index] == '+') {    // 如果这个数是正数，并且第一字符为 +
                symbol = +1;
                index++;
            }
            // 转换整数
            int res = 0;
            int maxValue = Integer.MAX_VALUE / 10;
            int minValue = Integer.MIN_VALUE / 10;
            while (index < chars.length) { 
                // 获取当前字符
                char currChar = chars[index++];
                int currValue = currChar - '0';
                // 判断是否合法
                if (currChar < '0' || currChar > '9') { 
                    break;
                }
                // 判断是否越界
                if (res > maxValue || (res == maxValue && currValue > +(Integer.MAX_VALUE % 10))) { 
                    return Integer.MAX_VALUE;
                }
                if (res < minValue || (res == minValue && currValue > -(Integer.MIN_VALUE % 10))) { 
                    return Integer.MIN_VALUE;
                }
                // 合法转换数字
                res = res * 10 + symbol * currValue;
            }
            // 返回结果
            return res;
        }
    }

# 面试题 01.09. 字符串轮转 #

## 题目介绍 ##

字符串轮转。给定两个字符串`s1`和`s2`，请编写代码检查`s2`是否为`s1`旋转而成（比如，waterbottle是erbottlewat旋转后的字符串）。

**示例1：**

输入：s1 = "waterbottle", s2 = "erbottlewat"
     输出：True

**示例2：**

输入：s1 = "aa", s2 = "aba"
     输出：False

**提示：**

*  字符串长度在\[0, 100000\]范围内。

**说明：**

*  你能只调用一次检查子串的方法吗？

来源：力扣（LeetCode）  
链接：https://leetcode-cn.com/problems/string-rotation-lcci  
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

## 题目实现 ##

做这道题需要使用到一个技巧，那就是将s1和s1自己拼接成一个新的字符串，因为s1轮转后的所有结果，都被这个新字符串所包含。

![22ef4cb21dccaf9ce6cf39a2b4a0a339.png][]

class Solution { 
        public boolean isFlipedString(String s1, String s2) { 
            if (s1 == null || s2 == null) return false;
            if (s1.length() != s2.length()) return false;
            return s1.concat(s1).contains(s2);
        }
    }

[753035295165ae0cba0f43268bcd31c7.png]: /images/20221014/9624e45dfc8044b0ba0df6cd88d8e0b0.png
[Offer 58 - I.]: https://leetcode-cn.com/problems/fan-zhuan-dan-ci-shun-xu-lcof/
[image-20210522120649505]: /images/20221014/ad80d5d5e2974e888e21dd258da9fde8.png
[207096e16b1c6d969e43bbba6a684494.png]: /images/20221014/4c71fba2537549c1b8ecdf60ec4f538a.png
[31fd86e39af1889b5608c7e824b12ec4.png]: /images/20221014/616ea18b81c746de90704798a5cc9128.png
[2824e6fd2cf7d3967943219bf4fc06ad.png]: /images/20221014/d8c163d959a641108bec9851962f1024.png
[8a7d74e7329acd08c24c5cad0b290630.png]: /images/20221014/702b5faa976e4ccab4cb552a34c45191.png
[e090dac0bec9cef101f74ef4336ab5b5.png]: /images/20221014/9cd64175dc9742a9809a5eb58a941d2c.png
[22ef4cb21dccaf9ce6cf39a2b4a0a339.png]: /images/20221014/780de77fd40b479ea96ac59d3968c866.png