目录
3.4 实现 strStr (选修字符串匹配算法：KMP) (未完)
三、字符串简介
3.1 最长公共前缀
3.1.1 问题描述
3.1.2 求解过程
法一：注意是“公共”前缀，而 不是“出现次数最多的”前缀，因此，每次只需要判断前缀切片出现次数是否等于列表中字符串总数即可。一旦前缀切片出现频次小于字符串总数，则不满足公共，停止寻找。(审题很重要！)
2020/06/04 - 24.13% - 使用了太多技巧，复杂度太高！效率很低！且冗余计算很多！
class Solution:
def longestCommonPrefix(self, strs: List[str]) -> str:
num = len(strs) # 字符串总数
if num == 0: # 特殊情况 []
return ""
if num == 1: # 特殊情况 [""] ["ab"]
return strs[0]
f = "" # 初始化输出前缀字符串
max_len = len(max(strs, key=lambda x: len(x))) # 最长字符串长度
for i in range(1, max_len+1): # 使用切片不会有 index out of range 的问题
f_temp, n_temp = collections.Counter(map(lambda y: y[:i], strs)).most_common()[0]
if n_temp == num: # 如果该前缀出现频次=字符串总数
f = f_temp # 将其作为输出前缀字符串
else:
return f
return f
法二：注意到，作为“公共”前缀，事实上根本不需要那么多技巧和遍历。只需要选其中一个单词切片，遍历数组依次对比以确定当前切片是否是“公共”的。一旦发现非公共，直接返回当前切片。否则，扩大切片范围再遍历一次。
2020/06/04 - 77.66% - 思路有对，可以继续优化！
class Solution:
def longestCommonPrefix(self, strs: List[str]) -> str:
if len(strs) == 0:
return ""
result = "" # 初始化输出结果
first_str = strs[0] # 首单词
for i in range(1, len(first_str)+1): # 根据参考答案, 使用 find 可以简化 for 后操作
cur_front = first_str[:i] # 当前前缀
#for j in range(1, length): # 用单纯的 for 比 enumerate 慢 20%
# if strs[j][:i] != cur_front:
for _, cur_str in enumerate(strs):
if cur_str[:i] != front: # 但凡发现一个不一样, 直接 return
return result
result = cur_front # 遍历数组, 确定公共前缀
return result
法三：参考写法，太强了，充分利用 Python 特性：zip() 拉链函数 + * 打包 + 集合 set 等实现最优化，化繁为简，佩服！经过观察，最快的方法 无一不是使用 zip() 函数。
2020/06/04 - 99.99% - 最快！
class Solution:
def longestCommonPrefix(self, strs: List[str]) -> str:
res = ""
# 通过 zip 缝合所有元素, 超过最短的部分会被截断
for i in zip(*strs):
#print(i)
if len(set(i)) == 1: # 使用集合判断当前位置字符是否公共
res += i[0]
else:
break
return res
3.2 最长回文子串
3.2.1 问题描述
3.2.2 求解过程
法一：朴素法，从宽到窄的滑动窗口，依次对其中的字符串切片进行正、逆序比较。一旦符合比较，就是当前最长的回文字符串了，直接返回之。否则，找到最后也没有，就随意返回一个字符。复杂度 O(n^3)。
2020/06/04 - 36.83% - 看来不怎么样！(4752 ms太低效了)
class Solution:
def longestPalindrome(self, s: str) -> str:
length = len(s)
if length <= 1: # 特殊情况如 "" "a"
return s
times = 1 # 首次用全长窗口, 只需要比较1次
for width in range(length, 0, -1): # 滑动窗口宽度-1
for start in range(times): # 滑动窗口移动次数 times
window = s[start:start+width] # 滑动窗口内字符串切片
if window == window[::-1]: # 正序逆序比较
return window
times += 1 # 滑动窗口宽度-1时,移动次数+1
return s[0] # 如果一直找不到就随意返回一个字符
法二：参考答案，原理待回顾。
2020/06/04 - 99.94% - 最快！(52 ms)
class Solution:
def longestPalindrome(self, s: str) -> str:
length = len(s)
if length < 2 or s == s[::-1]:
return s
else:
max_length = 1
start_pointer = 0
for i in range(1, length):
even = s[i-max_length: i+1] # 切片
odd = s[i-max_length-1: i+1] # 切片
if (i - max_length-1 >= 0) and (odd == odd[::-1]):
start_pointer = i - max_length - 1
max_length += 2
continue
if (i - max_length >= 0) and (even == even[::-1]):
start_pointer = i - max_length
max_length += 1
return s[start_pointer: start_pointer+max_length]
3.3 翻转字符串里的单词
3.3.1 问题描述
3.3.2 求解过程
法一：朴素法，使用 split(" ") 将原字符串以 " " 为间隔划分为字符串列表，使用 [::-1] 反转字符串列表。注意，此时字符串列表仍包含有空字符串。为此，通过 for 循环筛选出非空字符串并加入结果字符串 res 中，然后加入字符串间隔空格。最后，使用 str.rstrip() 删除末端空格。复杂度 O(n)。
2020/06/06 - 90.57% - 朴素的思路
class Solution:
def reverseWords(self, s: str) -> str:
res = ""
tmp = s.split(" ")[::-1]
for word in tmp:
if word:
res += word
res += " "
return res.rstrip()
法二：组合 Python 字符串方法 split() 和 join() 实现拆分和重组，通过 list[::-1] 反转中间形式的字符串列表。复杂度 O(n)。
2020/06/06 - 99.99% - 虽然最快，但是太依赖内建方法。
class Solution:
def reverseWords(self, s: str) -> str:
if not s:
return ""
word_list = s.split()[::-1] # 获取所有有效的字符串列表并反转
strs = " ".join(word_list) # 将列表元素以" "为间隔合成新字符串
return strs
# return " ".join(s.split()[::-1]) # 以上可一言以蔽之
3.4 实现 strStr (选修字符串匹配算法：KMP)
3.4.1 问题描述
3.4.2 求解过程
法一：(基准) 直接使用 Python 字符串内置方法 str.find() 实现查找匹配。如果这样写，面试官肯定要把你踢出去的......
2020/06/07 - 60.60% - 看来还不是最快的！
class Solution:
def strStr(self, haystack: str, needle: str) -> int:
return haystack.find(needle)
法二：(暴力匹配改) 不同于每次都在 haystack 上滑动窗口取出切片来与 needle 比较的暴力匹配方式，本方法先试探性比较首字母，倘若相同才有兴趣比较全部，从而节省了大量时间。复杂度 O(n) 吗？(怎么算啊？)
202/06/08 - 97.06% - 看来还行
class Solution:
def strStr(self, haystack: str, needle: str) -> int:
if not needle: # len(needle) == 0 返回 0
return 0
lenh = len(haystack)
lenn = len(needle)
if lenh < lenn: # 如果长度不够肯定不行返回 -1
return -1
for i in range(lenh-lenn+1): # 遍历
if haystack[i] == needle[0]: # 只有首字母相同才有兴趣比较其余部分
if haystack[i:i+lenn] == needle:
return i
return -1
法三：(KMP 算法)：待续。。。