二刷力扣--字符串

字符串

摘自Python文档-标准库：
在Python中， 字符串是由 Unicode 码位构成的不可变序列。
由于不存在单独的“字符”类型，对字符串做索引操作将产生一个长度为 1 的字符串。 也就是说，对于一个非空字符串 s, s[0] == s[0:1]。

不存在可变的字符串类型，但是 str.join() 或 io.StringIO 可以被被用来根据多个片段高效率地构建字符串。

字符串常用方法：

1. 查找子串 str.find(_sub_[, _start_[, _end_]])
   返回子字符串 sub 在 s[start:end] 切片内被找到的最小索引。 可选参数 start 与 end 会被解读为切片表示法。 如果 sub 未被找到则返回 -1
2. 拼接字符串 str.join(_iterable_)
   返回一个由 iterable 中的字符串拼接而成的字符串。 如果 iterable 中存在任何非字符串值包括 bytes 对象则会引发 TypeError。 调用该方法的字符串将作为元素之间的分隔。
3. 切割字符串 str.split(_sep=None_, _maxsplit=- 1_)
   返回一个由字符串内单词组成的列表，使用 sep 作为分隔字符串。 如果给出了 maxsplit，则最多进行 maxsplit 次拆分（因此，列表最多会有 maxsplit+1 个元素）。 如果 maxsplit 未指定或为 -1，则不限制拆分次数（进行所有可能的拆分）。
4. 去除前导和末尾字符 str.strip([_chars_])
   返回原字符串的副本，移除其中的前导和末尾字符。 chars 参数为指定要移除字符的字符串。 如果省略或为 None，则 chars 参数默认移除空白符。 实际上 chars 参数并非指定单个前缀或后缀；而是会移除参数值的所有组合。

344.反转字符串

输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。
#双指针

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]
1
2
3
4
5
6
7
8

python中最简单的反转是用 `[::-1]

541. 反转字符串 II

#模拟
给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。

• 如果剩余字符少于 k 个，则将剩余字符全部反转。
• 如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。

按照题意，模拟。

class Solution:
    def reverseStr(self, s: str, k: int) -> str:
        right = 2*k
        n = len(s)
        res = ""
        while right <= n: 
            res += s[right-2*k:right-k][::-1] + s[right-k:right]
            right += 2*k
        right -= 2*k
        if n - len(res) < k:
            res += s[right:][::-1]
        elif n-len(res)>= k:
            res += s[right:right+k][::-1] + s[right+k:]

        return res
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

可以借助Python切片特性简化：

class Solution:
    def reverseStr(self, s: str, k: int) -> str:
        p = 0
        while p < len(s):
            p2 = p + k
            s = s[:p] + s[p: p2][::-1] + s[p2:]
            p = p + 2 * k
        return s
1
2
3
4
5
6
7
8

剑指 Offer 05. 替换空格

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

class Solution:
    def replaceSpace(self, s: str) -> str:
        res = ""
        for c in s:
            if c == " ":
                res += "%20"
            else:
                res += c
        return res
1
2
3
4
5
6
7
8
9

151. 反转字符串中的单词

给你一个字符串 s ，请你反转字符串中 单词 的顺序。

class Solution:
    def reverseWords(self, s: str) -> str:
        s = [x  for x in s.split(" ") if x != ''] 
        return " ".join(s[::-1])
1
2
3
4

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

字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。

class Solution:
    def reverseLeftWords(self, s: str, n: int) -> str:
        s = s[n:] + s[:n]
        return s
1
2
3
4

28. 找出字符串中第一个匹配项的下标

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回 -1 。

最简单的是直接遍历：

class Solution:
    def strStr(self, haystack: str, needle: str) -> int:
        n = len(haystack)
        left = 0
        right = len(needle)
        if right == 0:
            return 0
        while right <= n:
            if haystack[left: right] == needle:
                return left
            left += 1
            right += 1
        return -1

1
2
3
4
5
6
7
8
9
10
11
12
13
14

或者选择进入KMP:
KMP算法名字由发明它的三个人的名字组成，解决字符串的匹配问题。
假设在字符串s中匹配模板t
s：aabaabaaf
t：aabaaf

前缀和后缀：即字符串的一部分。
前缀即a, aa, aab, aaba, aabaa
后缀即f, af, aaf, baaf, abaaf

最长相等前后缀（前缀表next）

利用前缀表，当匹配失败的时候，可以跳到下一个匹配的位置。（本例中，aabaaf匹配失败时，找aabaa的前缀表,得到2，于是下一个匹配b。

class Solution:
    def getNext(s):
        next = [0] * len(s)
        j = 0  # j代表前缀末尾
        next[j] = 0
        for i in range(1,len(s)): # i代表后缀末尾
            while j > 0 and s[i] != s[j]:# 不等时回退j
                j = next[j-1]
            if s[i] == s[j]: # 相等时， j+1
                j += 1
            next[i] = j
        return next


    
    def strStr(self, haystack: str, needle: str) -> int:
        if len(needle) == 0:
            return 0
        next = Solution.getNext(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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

getNext的j=next[j-1]那里不是特别明白，但是背下来了。
next[j]就是记录着j（包括j）之前的子串的相同前后缀的长度。

重复的子字符串

给定一个非空的字符串 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2. find
   如果s由重复子串组成，那么两个s拼接在一起，中间肯定会再出现一个s。
   (当然这只说明了必要性，还要证明充分性。)

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

字符串小结

字符串简单的题很简单，就是双指针、模拟，主要考察对字符串的基本操作。
复杂的会涉及到KMP（在s中找t）。虽然有库函数(find)可以实现这个过程。