力扣算法系统刷题详细题解记录二（字符串、双指针法、栈与队列）

力扣算法系统刷题题解记录二（字符串、双指针法、栈与队列）

前言

参考顺序和资料：《代码随想录》
二刷要认真做笔记啦，加油！
笔记模板：

#### 解题思路
 #### 示意图
 #### 代码

四、字符串

344.字符串反转

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

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

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

示例 1：
输入：[“h”,“e”,“l”,“l”,“o”]
输出：[“o”,“l”,“l”,“e”,“h”]

解题思路

如果题目关键的部分直接用库函数就可以解决，建议不要使用库函数。

毕竟面试官一定不是考察你对库函数的熟悉程度， 如果使用python和java 的同学更需要注意这一点，因为python、java提供的库函数十分丰富。

如果库函数仅仅是 解题过程中的一小部分，并且你已经很清楚这个库函数的内部实现原理的话，可以考虑使用库函数。

建议大家平时在leetcode上练习算法的时候本着这样的原则去练习，这样才有助于我们对算法的理解。

不要沉迷于使用库函数一行代码解决题目之类的技巧，不是说这些技巧不好，而是说这些技巧可以用来娱乐一下。

真正自己写的时候，要保证理解可以实现是相应的功能。
在反转链表中，使用了双指针的方法。

那么反转字符串依然是使用双指针的方法，只不过对于字符串的反转，其实要比链表简单一些。

因为字符串也是一种数组，所以元素在内存中是连续分布，这就决定了反转链表和反转字符串方式上还是有所差异的。

示意图

代码

class Solution {
    public void reverseString(char[] s) {
         int left = 0;
         int right = s.length-1;    //left和right双指针是下标
         while(left<right){
             char temp = s[left];
             s[left] = s[right];
             s[right] = temp; 
             left++;
             right--;
         }
    }
}

541.字符串反转

给定一个字符串 s 和一个整数 k，从字符串开头算起, 每计数至 2k 个字符，就反转这 2k 个字符中的前 k 个字符。
如果剩余字符少于 k 个，则将剩余字符全部反转。
如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。
示例:
输入: s = “abcdefg”, k = 2
输出: “bacdfeg”

解题思路

每隔2k个字符的前k的字符，写了一堆逻辑代码或者再搞一个计数器，来统计2k，再统计前k个字符。
其实在遍历字符串的过程中，只要让 i += (2 * k)，i 每次移动 2 * k 就可以了，然后判断是否需要有反转的区间。
因为要找的也就是每2 * k 区间的起点，这样写，程序会高效很多。
所以当需要固定规律一段一段去处理字符串的时候，要想想在在for循环的表达式上做做文章。

示意图

代码

class Solution {
    public String reverseStr(String s, int k) {
        char[] ch = s.toCharArray();
        for(int i = 0; i < ch.length; i += 2 * k){
            int start = i;
            //这里是判断尾数够不够k个来取决end指针的位置
            int end = Math.min(ch.length - 1, start + k - 1);	
            //判断尾数的个数是否小于k个 尾数的个数和k-1个相比
            //用异或运算反转 
            while(start < end){
                ch[start] ^= ch[end];
                ch[end] ^= ch[start];
                ch[start] ^= ch[end];
                start++;
                end--;
            }
        }
        return new String(ch);
    }
}

以下是代码的具体分析：
char[] ch = s.toCharArray();：将字符串 s 转换为字符数组 ch，以便进行字符级别的操作。
for(int i = 0; i < ch.length; i += 2 * k)：通过循环遍历字符串 ch，每次递增 i 的值为 2k，以处理长度为 2k 的子串。
int start = i;：将 start 初始化为当前子串的起始索引 i。
int end = Math.min(ch.length - 1, start + k - 1);：计算子串的结束索引 end。这里使用 Math.min() 函数来判断子串是否不足 k 个字符，如果是，则将 end 设置为子串的最后一个字符索引，否则设置为 start + k - 1。
while(start < end)：进入一个循环，该循环通过异或运算来反转子串中的字符。
ch[start] ^= ch[end]; ch[end] ^= ch[start]; ch[start] ^= ch[end];：这三行代码使用异或运算来反转 ch[start] 和 ch[end] 两个字符的值，实现字符交换。
start++; end–;：递增 start，递减 end，用于处理下一对字符。
return new String(ch);：将字符数组 ch 转换回字符串，并作为方法的返回值。
总体而言，这段代码通过划分长度为 2k 的子串，然后使用异或运算反转子串中的字符，最终将整个字符串的一部分进行了反转操作。

5.* 剑指offer 替换空格

请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

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

解题思路

如果想把这道题目做到极致，就不要只用额外的辅助空间了！

**首先扩充数组到每个空格替换成"%20"之后的大小。
然后从后向前替换空格，也就是双指针法，**过程如下：

i指向新长度的末尾，j指向旧长度的末尾。
为什么要从后向前填充，从前向后填充不行么？

从前向后填充就是O(n^2)的算法了，因为每次添加元素都要将添加元素之后的所有元素向后移动。

其实很多数组填充类的问题，都可以先预先给数组扩容带填充后的大小，然后在从后向前进行操作。

这么做有两个好处：

不用申请新数组。
从后向前填充元素，避免了从前向后填充元素时，每次添加元素都要将添加元素之后的所有元素向后移动的问题。

示意图

代码

//使用一个新的对象，复制 str，复制的过程对其判断，是空格则替换，否则直接复制，类似于数组复制
public static String replaceSpace(String s) {
        if (s == null) {
            return null;
        }
        //选用 StringBuilder 单线程使用，比较快，选不选都行
        StringBuilder sb = new StringBuilder();
        //使用 sb 逐个复制 s ，碰到空格则替换，否则直接复制
        for (int i = 0; i < s.length(); i++) {
            //s.charAt(i) 为 char 类型，为了比较需要将其转为和 " " 相同的字符串类型
            //if (" ".equals(String.valueOf(s.charAt(i)))){}
            if (s.charAt(i) == ' ') {
                sb.append("%20");
            } else {
                sb.append(s.charAt(i));
            }
        }
        return sb.toString();
    }

//方式二：双指针法
public String replaceSpace(String s) {
    if(s == null || s.length() == 0){
        return s;
    }
    //扩充空间，空格数量2倍
    StringBuilder str = new StringBuilder();
    for (int i = 0; i < s.length(); i++) {
        if(s.charAt(i) == ' '){
            str.append("  ");
        }
    }
    //若是没有空格直接返回
    if(str.length() == 0){
        return s;
    }
    //有空格情况 定义两个指针
    int left = s.length() - 1;//左指针：指向原始字符串最后一个位置
    s += str.toString();
    int right = s.length()-1;//右指针：指向扩展字符串的最后一个位置
    char[] chars = s.toCharArray();
    while(left>=0){
        if(chars[left] == ' '){
            chars[right--] = '0';
            chars[right--] = '2';
            chars[right] = '%';
        }else{
            chars[right] = chars[left];
        }
        left--;
        right--;
    }
    return new String(chars);
}

复杂度分析：
这段代码的时间复杂度是O(n)，其中n是输入字符串s的长度。这是因为代码使用了一个循环来遍历输入字符串s中的每个字符，并在需要替换空格时执行替换操作。每个字符都会被访问一次，因此时间复杂度是线性的。

空间复杂度也是O(n)，其中n是输入字符串s的长度。代码使用了一个StringBuilder对象sb来构建结果字符串，其长度与输入字符串s的长度相同，因为每个字符都被复制到结果字符串中。因此，空间复杂度与输入字符串的大小成正比。

知识点 StringBuilder

• StringBuilder
  StringBuilder是Java中的一个可变字符串类，它允许进行高效的字符串拼接和修改操作。StringBuilder的实例是可变的，可以在不创建新对象的情况下进行修改，这在处理大量字符串拼接时非常高效。
  在这段代码中，StringBuilder sb = new StringBuilder();的意思是创建一个空的StringBuilder对象，用于构建结果字符串。随后，在循环中，每当需要替换空格时，就使用**sb.append()方法将"%20"添加到StringBuilder中。**通过不断追加字符串而不创建新的字符串对象，可以避免频繁的内存分配和复制操作，从而提高性能。最后，通过调用sb.toString()方法，将StringBuilder对象转换为一个普通的字符串，以便返回结果。

• 为什么用单线程
  在这段代码中，使用StringBuilder是因为它在单线程环境下的性能表现更好。**StringBuilder是java.lang包下的一个类，专门用于字符串的拼接和修改操作。**它是线程不安全的，意味着它没有内建的同步机制来处理多线程同时访问的情况。
  在这段代码中，并没有涉及到多线程操作，因此选择了StringBuilder而不是线程安全的StringBuffer。使用StringBuilder可以获得更好的性能，因为它不需要额外的同步开销。在单线程环境下，StringBuilder能够以更高的效率执行字符串的拼接和修改操作。
  如果在多线程环境中使用，应该考虑使用StringBuffer类，它是StringBuilder的线程安全版本，可以在多线程环境下安全地进行操作。

459.重复的子字符串

给定一个非空的字符串，判断它是否可以由它的一个子串重复多次构成。给定的字符串只含有小写英文字母，并且长度不超过10000。
示例 1:
输入: “abab”
输出: True
解释: 可由子字符串 “ab” 重复两次构成。
示例 2:
输入: “aba”
输出: False
示例 3:
输入: “abcabcabcabc”
输出: True
解释: 可由子字符串 “abc” 重复四次构成。 (或者子字符串 “abcabc” 重复两次构成。

解题思路

只需要判断，以第一个字母为开始的子串就可以，所以一个for循环获取子串的终止位置就行了。 而且遍历的时候 都不用遍历结束，只需要遍历到中间位置，因为子串结束位置大于中间位置的话，一定不能重复组成字符串。
当一个字符串s：abcabc，内部由重复的子串组成，那么这个字符串的结构一定是这样的：

也就是由前后相同的子串组成。

那么既然前面有相同的子串，后面有相同的子串，用 s + s，这样组成的字符串中，后面的子串做前串，前后的子串做后串，就一定还能组成一个s，如图：

所以判断字符串s是否由重复子串组成，只要两个s拼接在一起，里面还出现一个s的话，就说明是由重复子串组成。
当然，我们在判断 s + s 拼接的字符串里是否出现一个s的的时候，要刨除 s + s 的首字符和尾字符，这样避免在s+s中搜索出原来的s，我们要搜索的是中间拼接出来的s。
代码如下：

class Solution {
public:
    bool repeatedSubstringPattern(string s) {
        string t = s + s;
        t.erase(t.begin()); t.erase(t.end() - 1); // 掐头去尾
        if (t.find(s) != std::string::npos) return true; // r
        return false;
    }
};

时间复杂度: O(n)
空间复杂度: O(1)
不过这种解法还有一个问题，就是 我们最终还是要判断 一个字符串（s + s）是否出现过 s 的过程，大家可能直接用contains，find 之类的库函数。 却忽略了实现这些函数的时间复杂度（暴力解法是m * n，一般库函数实现为 O(m + n)）。
时间复杂度: O(n)
空间复杂度: O(1)
不过这种解法还有一个问题，就是 我们最终还是要判断 一个字符串（s + s）是否出现过 s 的过程，大家可能直接用contains，find 之类的库函数。 却忽略了实现这些函数的时间复杂度（暴力解法是m * n，一般库函数实现为 O(m + n)）。

示意图

代码

class Solution {
    public boolean repeatedSubstringPattern(String s) {
        if (s.equals("")) return false;  // 如果原串为空，则返回false

        int len = s.length();  // 原串长度
        s = " " + s;  // 原串加个空格(哨兵)，使下标从1开始，这样j从0开始，也不用初始化了
        char[] chars = s.toCharArray();  // 将原串转换为字符数组
        int[] next = new int[len + 1];  // next数组用于记录最长相同前后缀的长度

        // 构造 next 数组过程，j从0开始(空格)，i从2开始
        for (int i = 2, j = 0; i <= len; i++) {
            // 匹配不成功，j回到前一位置 next 数组所对应的值
            while (j > 0 && chars[i] != chars[j + 1]) j = next[j];
            // 匹配成功，j往后移
            if (chars[i] == chars[j + 1]) j++;
            // 更新 next 数组的值
            next[i] = j;
        }

        // 最后判断是否是重复的子字符串，这里 next[len] 即代表next数组末尾的值
        if (next[len] > 0 && len % (len - next[len]) == 0) {
            return true;
        }
        return false;
    }
}

这段代码实现了一个检测是否存在由子串重复构成的方法。下面是详细注释解释：
如果原串为空，则返回false。
初始化原串长度和字符数组。
创建next数组，用于记录最长相同前后缀的长度。
开始构造next数组：
循环从2到原串长度，i为当前位置，j为前一个位置的最长相同前后缀长度。
当前字符与前一个位置的字符不匹配时，将j回溯到前一个位置的next值所对应的位置。
当前字符与前一个位置的字符匹配时，将j向后移动。
更新next数组的值为j。
最后判断是否是重复的子字符串：
如果next数组末尾的值大于0，并且原串长度能够整除（原串长度-最长相同前后缀长度），则说明存在由子串重复构成的情况，返回true。
否则返回false。
这段代码利用了KMP算法中的next数组，通过构造next数组来判断是否存在由子串重复构成的情况。

为什么i从2开始？
在给定的代码中，i从2开始的原因是为了构造next数组。在KMP算法中，next数组的第一个值是默认为0的，而next[1]是用于记录第一个字符的最长相同前后缀长度的。由于next[1]的值无需进行比较和更新，因此在循环中可以跳过该位置，直接从i=2开始。

在构造next数组的过程中，i表示当前位置，j表示前一个位置的最长相同前后缀长度。通过比较chars[i]和chars[j+1]的值来更新j和next[i]。通过跳过i=1的位置，可以方便地处理j的更新逻辑，并确保next[1]的值为0。

所以，i从2开始是为了方便处理next数组的构造过程，并确保next[1]的值为0。

KMP 算法

为什么要KMP算法？

解决字符串匹配的问题。

KMP算法介绍

在一个串中查找是否出现过另一个串，这是KMP的看家本领。那么寻找重复子串怎么也涉及到KMP算法了呢？

KMP算法中next数组为什么遇到字符不匹配的时候可以找到上一个匹配过的位置继续匹配，靠的是有计算好的前缀表。 前缀表里，统计了各个位置为终点字符串的最长相同前后缀的长度。
那么 最长相同前后缀和重复子串的关系又有什么关系呢。
前缀是指不包含最后一个字符的所有以第一个字符开头的连续子串；如：abcdef 中的前缀有a,ab,abc,abcd,abcde
后缀是指不包含第一个字符的所有以最后一个字符结尾的连续子串。如：abcdef 中的后缀有f,ef,def,cdef,bcdef
在由重复子串组成的字符串中，最长相等前后缀不包含的子串就是最小重复子串，这里拿字符串s：abababab 来举例，ab就是最小重复单位，如图所示：

步骤一：因为 这是相等的前缀和后缀，t[0] 与 k[0]相同， t[1] 与 k[1]相同，所以 s[0] 一定和 s[2]相同，s[1] 一定和 s[3]相同，即：，s[0]s[1]与s[2]s[3]相同 。
步骤二： 因为在同一个字符串位置，所以 t[2] 与 k[0]相同，t[3] 与 k[1]相同。
步骤三： 因为 这是相等的前缀和后缀，t[2] 与 k[2]相同 ，t[3]与k[3] 相同，所以，s[2]一定和s[4]相同，s[3]一定和s[5]相同，即：s[2]s[3] 与 s[4]s[5]相同。
步骤四：循环往复。
所以字符串s，s[0]s[1]与s[2]s[3]相同， s[2]s[3] 与 s[4]s[5]相同，s[4]s[5] 与 s[6]s[7] 相同。
正是因为 最长相等前后缀的规则，当一个字符串由重复子串组成的，最长相等前后缀不包含的子串就是最小重复子串。

简单推理

这里再给出一个数学推导，就容易理解很多。
假设字符串s使用多个重复子串构成（这个子串是最小重复单位），重复出现的子字符串长度是x，所以s是由n * x组成。
因为字符串s的最长相同前后缀的长度一定是不包含s本身，所以 最长相同前后缀长度必然是m * x，而且 n - m = 1，（这里如果不懂，看上面的推理）
所以如果 nx % (n - m)x = 0，就可以判定有重复出现的子字符串。
next 数组记录的就是最长相同前后缀 字符串：KMP算法精讲 (opens new window)这里介绍了什么是前缀，什么是后缀，什么又是最长相同前后缀)， 如果 next[len - 1] != -1，则说明字符串有最长相同的前后缀（就是字符串里的前缀子串和后缀子串相同的最长长度）。
最长相等前后缀的长度为：next[len - 1] + 1。(这里的next数组是以统一减一的方式计算的，因此需要+1，两种计算next数组的具体区别看这里：字符串：KMP算法精讲 (opens new window))
数组长度为：len。
如果len % (len - (next[len - 1] + 1)) == 0 ，则说明数组的长度正好可以被 (数组长度-最长相等前后缀的长度) 整除 ，说明该字符串有重复的子字符串。
数组长度减去最长相同前后缀的长度相当于是第一个周期的长度，也就是一个周期的长度，如果这个周期可以被整除，就说明整个数组就是这个周期的循环。
强烈建议大家把next数组打印出来，看看next数组里的规律，有助于理解KMP算法

如何找到最小重复子串

为啥一定是开头的ab呢。 其实最关键还是要理解 最长相等前后缀，如图：

next[len - 1] = 7，next[len - 1] + 1 = 8，8就是此时字符串asdfasdfasdf的最长相同前后缀的长度。

(len - (next[len - 1] + 1)) 也就是： 12(字符串的长度) - 8(最长公共前后缀的长度) = 4， 4正好可以被 12(字符串的长度) 整除，所以说明有重复的子字符串（asdf）。