代码随想录训练营【字符串篇】

字符串

注：本文代码来自于代码随想录

344.反转字符串

力扣344

C++

class Solution {
public:
    void reverseString(vector<char>& s) {
        for (int i = 0, j = s.size() - 1; i < s.size()/2; i++, j--) {
            swap(s[i],s[j]);
        }
    }
};

Python

掌握使用双指针和使用栈

使用双指针

class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        left, right = 0, len(s) - 1
        
        # 该方法已经不需要判断奇偶数，经测试后时间空间复杂度比用 for i in range(len(s)//2)更低
        # 因为while每次循环需要进行条件判断，而range函数不需要，直接生成数字，因此时间复杂度更低。推荐使用range
        while left < right:
            s[left], s[right] = s[right], s[left]
            left += 1
            right -= 1

使用栈——很妙

为什么stack是一个列表，但可以使用栈的操作pop()

在Python中，列表（list）是一个非常灵活的数据结构，可以支持多种操作，包括作为栈使用。以下是Python列表的一些特点：

• append(item): 将元素item添加到列表的末尾。
• pop(): 移除并返回列表的最后一个元素。

因为append()和pop()操作符合栈的基本操作（分别是压入栈和弹出栈），所以我们可以用列表来模拟栈的行为。这样我们不需要专门的数据结构，也可以实现栈的功能。这种方法简洁且高效，非常适合在实际编程中使用。

class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        stack = []
        for char in s:
            stack.append(char)
        for i in range(len(s)):
            s[i] = stack.pop()
       

使用range

class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        n = len(s)
        for i in range(n // 2):
            s[i], s[n - i - 1] = s[n - i - 1], s[i]
       

使用reversed

class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        s[:] = reversed(s)
        # 直接s.reverse也是可以的
       

使用切片

class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        s[:] = s[::-1]
        # ?实在是过于简洁了

使用列表推导

class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        s[:] = [s[i] for i in range(len(s) - 1, -1, -1)]
        # 注意左闭右开所以是-1而不是0
       

使用reverse()

class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        # 原地反转,无返回值
        s.reverse()
       

541.反转字符串II

反转字符串II

需要注意的是 i = i +2*k而不是i = i + 1

C++

使用C++库函数reverse的版本如下：

class Solution {
public:
    string reverseStr(string s, int k) {
        for (int i = 0; i < s.size(); i += (2 * k)) {
            // 1. 每隔 2k 个字符的前 k 个字符进行反转
            // 2. 剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符
            if (i + k <= s.size()) {
                reverse(s.begin() + i, s.begin() + i + k );
            } else {
                // 3. 剩余字符少于 k 个，则将剩余字符全部反转。
                reverse(s.begin() + i, s.end());
            }
        }
        return s;
    }
};

下面是卡哥写的reverse函数, 左闭右闭区间：

class Solution {
public:
    void reverse(string& s, int start, int end) {
        for (int i = start, j = end; i < j; i++, j--) {
            swap(s[i], s[j]);
        }
    }
    string reverseStr(string s, int k) {
        for (int i = 0; i < s.size(); i += (2 * k)) {
            // 1. 每隔 2k 个字符的前 k 个字符进行反转
            // 2. 剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符
            if (i + k <= s.size()) {
                reverse(s, i, i + k - 1);
                continue;
            }
            // 3. 剩余字符少于 k 个，则将剩余字符全部反转。
            reverse(s, i, s.size() - 1);
        }
        return s;
    }
};

另一种思路的解法

class Solution {
public:
    string reverseStr(string s, int k) {
        int n = s.size(),pos = 0;
        while(pos < n){
            //剩余字符串大于等于k的情况
            if(pos + k < n) reverse(s.begin() + pos, s.begin() + pos + k);
            //剩余字符串不足k的情况 
            else reverse(s.begin() + pos,s.end());
            pos += 2 * k;
        }
        return s;
    }
};

Python

转换为列表，切片操作

在Python中，函数内部是可以定义另一个函数的，这种现象称为嵌套函数。嵌套函数具有以下特点：

1. 作用域限制：嵌套函数只能在包含它的函数内部被调用，外部是无法直接调用的。
2. 访问外部变量：嵌套函数可以访问包含它的函数的作用域内的变量，这称为闭包。
   reverse_substring 函数被定义在 reverseStr 函数内部，这是为了实现以下目的：

• 代码封装：reverse_substring 函数仅用于翻转子字符串，这个功能是 reverseStr 函数的一部分，但不需要对外公开。将其定义在内部可以隐藏实现细节，使得主函数 reverseStr 的逻辑更加清晰。
• 局部作用域：由于 reverse_substring 仅在 reverseStr 中使用，定义在内部可以避免污染全局命名空间。
  在 reverseStr 函数中，通过循环以每2k个字符为一个单位，对前k个字符进行翻转。这是通过调用内部的 reverse_substring 函数实现的。
  总的来说，嵌套函数是一种常见的编程技巧，用于组织代码和实现特定的功能，这种方式是合理且有效的。

class Solution:
    def reverseStr(self, s: str, k: int) -> str:
        """
        1. 使用range(start, end, step)来确定需要调换的初始位置
        2. 对于字符串s = 'abc'，如果使用s[0:999] ===> 'abc'。字符串末尾如果超过最大长度，则会返回至字符串最后一个值，这个特性可以避免一些边界条件的处理。
        3. 用切片整体替换，而不是一个个替换.
        """
        def reverse_substring(text):
            # 这一部分是自定义的reverse函数
            left, right = 0, len(text) - 1
            while left < right:
                text[left], text[right] = text[right], text[left]
                left += 1
                right -= 1
                return text
        
        res = list(s)
        # 字符串在Python中是不可变的（immutable），所以为了修改字符串中的字符，需要先将其转换为列表（列表是可变的）。

        for cur in range(0, len(s), 2 * k): # 直到超过len(s)为止，但左闭右开，实际值不会超过最末尾的值。
            # 如果len(s)是30，k是2，那么range(0, 30, 4)将生成0, 4, 8, 12, 16, 20, 24, 28。
            res[cur: cur + k] = reverse_substring(res[cur: cur + k])
        
        return ''.join(res)
    # ''.join(res)将列表res转换回字符串并返回。

我更习惯这样写：

class Solution:

    def reverse_substring(self, t:list) -> list:
        # 翻转列表
        left, right = 0, len(t) - 1
        while left < right:
            t[left], t[right] = t[right], t[left]
            left += 1
            right -= 1
        return t

    def reverseStr(self, s: str, k: int) -> str:
        res = list(s)# 先转换为列表

        for cur in range(0, len(s), 2*k):
            res[cur:cur + k] = self.reverse_substring(res[cur:cur + k])
        
        return ''.join(res)

双指针法:

字符串不可变，但是切片操作不是修改原字符串而是生成新的字符串。

需要注意s = s[:p] + s[p: p2][::-1] + s[p2:]的最后一部分，是把后面所有的全都加上而不是只加了[K: 2*K+1]

class Solution:
    def reverseStr(self, s: str, k: int) -> str:
        # 初始化指针 p 为 0
        p = 0
        # 当 p 小于字符串长度时继续循环
        while p < len(s):
            # 计算第二个指针 p2，为当前指针 p 加上 k
            p2 = p + k
            # 通过切片操作和字符串拼接创建一个新的字符串
            s = s[:p] + s[p: p2][::-1] + s[p2:]
            # 通过字符串拼接操作（+），将上述三部分连接成一个新的字符串。这个新的字符串赋值给变量 s，从而实现了“修改”字符串的效果。
           
			# 将指针 p 向前移动 2k
            p = p + 2 * k
        # 返回最终的字符串
        return s

替换数字

卡码网54

首先扩充数组到每个数字字符替换成 “number” 之后的大小。

然后从后向前替换数字字符，也就是双指针法，过程如下：i指向新长度的末尾，j指向旧长度的末尾。

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

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

这么做有两个好处：

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

这种方法避免了从前向后替换时需要不断移动元素的问题，因为从后向前替换时，每个位置只被访问和写入一次，时间复杂度是O(n)，其中n是字符串的长度。

C++

#include <iostream>
using namespace std;
int main() {
    string s;
    while (cin >> s) {
        int sOldIndex = s.size() - 1;
        int count = 0; // 统计数字的个数
        for (int i = 0; i < s.size(); i++) {
            if (s[i] >= '0' && s[i] <= '9') {
                count++;
            }
        }
        // 扩充字符串s的大小，也就是将每个数字替换成"number"之后的大小
        s.resize(s.size() + count * 5);
        int sNewIndex = s.size() - 1;
        // 从后往前将数字替换为"number"
        while (sOldIndex >= 0) {
            if (s[sOldIndex] >= '0' && s[sOldIndex] <= '9') {
                s[sNewIndex--] = 'r';
                s[sNewIndex--] = 'e';
                s[sNewIndex--] = 'b';
                s[sNewIndex--] = 'm';
                s[sNewIndex--] = 'u';
                s[sNewIndex--] = 'n';
            } else {
                s[sNewIndex--] = s[sOldIndex];
            }
            sOldIndex--;
        }
        cout << s << endl;       
    }

Python

if lst[i].isdigit():# 没见过的函数，记一下

class Solution:
    def change(self, s):
        lst = list(s) # Python里面的string也是不可改的，所以也是需要额外空间的。空间复杂度：O(n)。
        for i in range(len(lst)):
            if lst[i].isdigit():
                # 没见过的函数，记一下
                lst[i] = "number"
        return ''.join(lst)

完整的可以运行的代码如下：

class Solution:
    def change(self, s:str) -> str:
        li = list(s)
        for i in range(len(li)):
            if li[i].isdigit():
                li[i] = 'number'
        return ''.join(li)
    
solution = Solution()
s = input()
print(solution.change(s))

151.翻转字符串里的单词

力扣151

解题思路如下：

• 移除多余空格
• 将整个字符串反转
• 将每个单词反转

举个例子，源字符串为："the sky is blue "

• 移除多余空格 : “the sky is blue”
• 字符串反转：“eulb si yks eht”
• 单词反转：“blue is sky the”

C++

双指针

class Solution {
public:
    void reverse(string& s, int start, int end){ //翻转，区间写法：左闭右闭 []
        for (int i = start, j = end; i < j; i++, j--) {
            swap(s[i], s[j]);
        }
    }

    void removeExtraSpaces(string& s) {//去除所有空格并在相邻单词之间添加空格, 快慢指针。
        int slow = 0;   //整体思想参考https://programmercarl.com/0027.移除元素.html
        for (int i = 0; i < s.size(); ++i) { //
            if (s[i] != ' ') { //遇到非空格就处理，即删除所有空格。
                if (slow != 0) s[slow++] = ' '; //手动控制空格，给单词之间添加空格。slow != 0说明不是第一个单词，需要在单词前添加空格。
                while (i < s.size() && s[i] != ' ') { //补上该单词，遇到空格说明单词结束。
                    s[slow++] = s[i++];
                }
            }
        }
        s.resize(slow); //slow的大小即为去除多余空格后的大小。
    }

    string reverseWords(string s) {
        removeExtraSpaces(s); //去除多余空格，保证单词之间之只有一个空格，且字符串首尾没空格。
        reverse(s, 0, s.size() - 1);
        int start = 0; //removeExtraSpaces后保证第一个单词的开始下标一定是0。
        for (int i = 0; i <= s.size(); ++i) {
            if (i == s.size() || s[i] == ' ') { //到达空格或者串尾，说明一个单词结束。进行翻转。
                reverse(s, start, i - 1); //翻转，注意是左闭右闭 []的翻转。
                start = i + 1; //更新下一个单词的开始下标start
            }
        }
        return s;
    }
};

Python:

先删除空白，然后整个反转，最后单词反转。

因为字符串是不可变类型，所以反转单词的时候，需要将其转换成列表，然后通过join函数再将其转换成列表，所以空间复杂度不是O(1)

# 记住这种字符串处理方法
class Solution:
    def reverseWords(self, s: str) -> str:
        # 删除前后空白
        s = s.strip()
        # 反转整个字符串
        s = s[::-1]
        # 将字符串拆分为单词，并反转每个单词
        s = ' '.join(word[::-1] for word in s.split())
        return s

使用双指针

class Solution:
    def reverseWords(self, s: str) -> str:
        # 将字符串拆分为单词，即转换成列表类型
        words = s.split()

        # 反转单词
        left, right = 0, len(words) - 1
        while left < right:
            words[left], words[right] = words[right], words[left]
            # words[left]是一个单词，是list中的元素
            left += 1
            right -= 1

        # 将列表转换成字符串
        return " ".join(words)

拆分字符串 + 反转列表

class Solution:
    def reverseWords(self, s):
        words = s.split() #type(words) --- list
        words = words[::-1] # 反转单词
        return ' '.join(words) #列表转换成字符串

右旋字符串

卡码网55

使用整体反转+局部反转就可以实现反转单词顺序的目的

思路就是 通过 整体倒叙，把两段子串顺序颠倒，两个段子串里的的字符在倒叙一把，负负得正，这样就不影响子串里面字符的顺序了

C++

// 版本一
#include<iostream>
#include<algorithm>
using namespace std;
int main() {
    int n;
    string s;
    cin >> n;
    cin >> s;
    int len = s.size(); //获取长度

    reverse(s.begin(), s.end()); // 整体反转
    reverse(s.begin(), s.begin() + n); // 先反转前一段，长度n
    reverse(s.begin() + n, s.end()); // 再反转后一段

    cout << s << endl;

} 

// 版本二 
#include<iostream>
#include<algorithm>
using namespace std;
int main() {
    int n;
    string s;
    cin >> n;
    cin >> s;
    int len = s.size(); //获取长度
    reverse(s.begin(), s.begin() + len - n); // 先反转前一段，长度len-n ，注意这里是和版本一的区别
    reverse(s.begin() + len - n, s.end()); // 再反转后一段
    reverse(s.begin(), s.end()); // 整体反转
    cout << s << endl;

}

Python

#获取输入的数字k和字符串
k = int(input())
s = input()

#通过切片反转第一段和第二段字符串
#注意：python中字符串是不可变的，所以也需要额外空间
s = s[len(s)-k:] + s[:len(s)-k]
print(s)

k = int(input())
s = input()

print(s[-k:] + s[:-k])

28. 实现 strStr()

力扣28

Python：

（版本一）前缀表（减一）

class Solution:
    def getNext(self, next, s):
        j = -1
        next[0] = j
        for i in range(1, len(s)):
            while j >= 0 and s[i] != s[j+1]:
                j = next[j]
            if s[i] == s[j+1]:
                j += 1
            next[i] = j
    
    def strStr(self, haystack: str, needle: str) -> int:
        if not needle:
            return 0
        next = [0] * len(needle)
        self.getNext(next, needle)
        j = -1
        for i in range(len(haystack)):
            while j >= 0 and haystack[i] != needle[j+1]:
                j = next[j]
            if haystack[i] == needle[j+1]:
                j += 1
            if j == len(needle) - 1:
                return i - len(needle) + 1
        return -1

（版本二）前缀表（不减一）

class Solution:
    def getNext(self, next: List[int], s: str) -> None:
        j = 0
        next[0] = 0
        for i in range(1, len(s)):
            while j > 0 and s[i] != s[j]:
                j = next[j - 1]
            if s[i] == s[j]:
                j += 1
            next[i] = j
    
    def strStr(self, haystack: str, needle: str) -> int:
        if len(needle) == 0:
            return 0
        next = [0] * len(needle)
        self.getNext(next, needle)
        j = 0
        for i in range(len(haystack)):
            while j > 0 and haystack[i] != needle[j]:
                j = next[j - 1]
            if haystack[i] == needle[j]:
                j += 1
            if j == len(needle):
                return i - len(needle) + 1
        return -1

（版本三）暴力法

class Solution(object):
    def strStr(self, haystack, needle):
        """
        :type haystack: str
        :type needle: str
        :rtype: int
        """
        m, n = len(haystack), len(needle)
        for i in range(m):
            if haystack[i:i+n] == needle:
                return i
        return -1    

（版本四）使用 index

class Solution:
    def strStr(self, haystack: str, needle: str) -> int:
        try:
            return haystack.index(needle)
        except ValueError:
            return -1

（版本五）使用 find

class Solution:
    def strStr(self, haystack: str, needle: str) -> int:
        return haystack.find(needle)
	

459.重复的子字符串

力扣459

Python：

（版本一） 前缀表 减一

class Solution:
    def repeatedSubstringPattern(self, s: str) -> bool:  
        if len(s) == 0:
            return False
        nxt = [0] * len(s)
        self.getNext(nxt, s)
        if nxt[-1] != -1 and len(s) % (len(s) - (nxt[-1] + 1)) == 0:
            return True
        return False
    
    def getNext(self, nxt, s):
        nxt[0] = -1
        j = -1
        for i in range(1, len(s)):
            while j >= 0 and s[i] != s[j+1]:
                j = nxt[j]
            if s[i] == s[j+1]:
                j += 1
            nxt[i] = j
        return nxt

（版本二） 前缀表 不减一

class Solution:
    def repeatedSubstringPattern(self, s: str) -> bool:  
        if len(s) == 0:
            return False
        nxt = [0] * len(s)
        self.getNext(nxt, s)
        if nxt[-1] != 0 and len(s) % (len(s) - nxt[-1]) == 0:
            return True
        return False
    
    def getNext(self, nxt, s):
        nxt[0] = 0
        j = 0
        for i in range(1, len(s)):
            while j > 0 and s[i] != s[j]:
                j = nxt[j - 1]
            if s[i] == s[j]:
                j += 1
            nxt[i] = j
        return nxt

（版本三） 使用 find

class Solution:
    def repeatedSubstringPattern(self, s: str) -> bool:
        n = len(s)
        if n <= 1:
            return False
        ss = s[1:] + s[:-1] 
        print(ss.find(s))              
        return ss.find(s) != -1

（版本四） 暴力法

class Solution:
    def repeatedSubstringPattern(self, s: str) -> bool:
        n = len(s)
        if n <= 1:
            return False
        
        substr = ""
        for i in range(1, n//2 + 1):
            if n % i == 0:
                substr = s[:i]
                if substr * (n//i) == s:
                    return True
                
        return False