题目
分析
概述
这道题是要在 haystack 字符串中找到 needle 字符串。下面会给出的三种解法,这三种解法都基于滑动窗口。
子串逐一比较的解法最简单,将长度为 L 的滑动窗口沿着 haystack 字符串逐步移动,并将窗口内的子串与 needle 字符串相比较,时间复杂度为 O((N - L)L)
显示上面这个方法是可以优化的。双指针方法虽然也是线性时间复杂度,不过它可以避免比较所有的子串,因此最优情况下的时间复杂度为 O(N),但最坏情况下的时间复杂度依然为 O((N - L)L)。
有 O(N)复杂度的解法嘛?答案是有的,有两种方法可以实现:
- Rabin-Karp,通过哈希算法实现常数时间窗口内字符串比较。
- 比特位操作,通过比特掩码来实现常数时间窗口内字符串比较。
方法一:子串逐一比较 - 线性时间复杂度
最直接的方法 - 沿着字符换逐步移动滑动窗口,将窗口内的子串与 needle 字符串比较。
实现
class Solution {
public int strStr(String haystack, String needle) {
int L = needle.length(), n = haystack.length();
for (int start = 0; start < n - L + 1; ++start) {
if (haystack.substring(start, start + L).equals(needle)) {
return start;
}
}
return -1;
}
}
复杂度分析
- 时间复杂度:O((N - L)L),其中 N 为 haystack 字符串的长度,L 为 needle 字符串的长度。内循环中比较字符串的复杂度为 L,总共需要比较 (N - L) 次。
- 空间复杂度:O(1)。
方法二:双指针 - 线性时间复杂度
上一个方法的缺陷是会将 haystack 所有长度为 L 的子串都与 needle 字符串比较,实际上是不需要这么做的。
首先,只有子串的第一个字符跟 needle 字符串第一个字符相同的时候才需要比较。
其次,可以一个字符一个字符比较,一旦不匹配了就立刻终止。
如下图所示,比较到最后一位时发现不匹配,这时候开始回溯。需要注意的是,pn 指针是移动到 pn = pn - curr_len + 1 的位置,而 不是 pn = pn - curr_len 的位置。
这时候再比较一次,就找到了完整匹配的子串,直接返回子串的开始位置 pn - L。
算法
- 移动 pn 指针,直到 pn 所指向位置的字符与 needle 字符串第一个字符相等。
- 通过 pn,pL,curr_len 计算匹配长度。
- 如果完全匹配(即 curr_len == L),返回匹配子串的起始坐标(即 pn - L)。
- 如果不完全匹配,回溯。使 pn = pn - curr_len + 1, pL = 0, curr_len = 0。
实现
class Solution {
public int strStr(String haystack, String needle) {
int L = needle.length(), n = haystack.length();
if (L == 0) return 0;
int pn = 0;
while (pn < n - L + 1) {
// find the position of the first needle character
// in the haystack string
while (pn < n - L + 1 && haystack.charAt(pn) != needle.charAt(0)) ++pn;
// compute the max match string
int currLen = 0, pL = 0;
while (pL < L && pn < n && haystack.charAt(pn) == needle.charAt(pL)) {
++pn;
++pL;
++currLen;
}
// if the whole needle string is found,
// return its start position
if (currLen == L) return pn - L;
// otherwise, backtrack
pn = pn - currLen + 1;
}
return -1;
}
}
复杂度分析
- 时间复杂度:最坏时间复杂度为 O((N - L)L),最优时间复杂度为 O(N)。
- 空间复杂度:O(1)。
方法三: Rabin Karp - 常数复杂度
有一种最坏时间复杂度也为 O(N)的算法。思路是这样的,先生成窗口内子串的哈希码,然后再跟 needle 字符串的哈希码做比较。
这个思路有一个问题需要解决,如何在常数时间生成子串的哈希码?
滚动哈希:常数时间生成哈希码
生成一个长度为 L 数组的哈希码,需要 O(L)时间。
如何在常数时间生成滑动窗口数组的哈希码?利用滑动窗口的特性,每次滑动都有一个元素进,一个出。
由于只会出现小写的英文字母,因此可以将字符串转化成值为 0 到 25 的整数数组: arr[i] = (int)S.charAt(i) - (int)'a'
。按照这种规则,abcd
整数数组形式就是 [0, 1, 2, 3]
,转换公式如下所示。
h 0 = 0 × 2 6 3 + 1 × 2 6 2 + 2 × 2 6 1 + 3 × 2 6 0 h_0 = 0 \times 26^3 + 1 \times 26^2 + 2 \times 26^1 + 3 \times 26^0 h0=0×263+1×262+2×261+3×260
可以将上面的公式写成通式,如下所示。其中 c_ic**i 为整数数组中的元素,a = 26a=26,其为字符集的个数。
h 0 = c 0 a L − 1 + c 1 a L − 2 + . . . + c i a L − 1 − i + . . . + c L − 1 a 1 + c L a 0 0 h_0 = c_0 a^{L - 1} + c_1 a^{L - 2} + ... + c_i a^{L - 1 - i} + ... + c_{L - 1} a^1 + c_L a^00 h0=c0a