Leetcode的AC指南 —— 字符串/KMP：28.找出字符串中第一个匹配项的下标

摘要：
Leetcode的AC指南 —— 字符串/KMP：28.找出字符串中第一个匹配项的下标。题目介绍：给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回 -1 。

文章目录

一、题目
二、解析（go）
1、一个简单的AC方法
2、KMP算法：直接使用前缀表作为next数组

三、其他语言版本
Java
C++
Python

一、题目

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

力扣题目链接

示例 1:

输入：haystack = "sadbutsad", needle = "sad"
输出：0
解释："sad" 在下标 0 和 6 处匹配。
第一个匹配项的下标是 0 ，所以返回 0 。

示例 2:

输入：haystack = "leetcode", needle = "leeto"
输出：-1
解释："leeto" 没有在 "leetcode" 中出现，所以返回 -1 。

提示：
1 <= haystack.length, needle.length <= 104
haystack 和 needle 仅由小写英文字符组成

二、解析（go）

1、一个简单的AC方法

思路：让needle在haystack中滑动

go：

func strStr(haystack string, needle string) int {runes := []byte(haystack)for i := 0; i <= len(haystack)-len(needle); i++ {if string(runes[i:len(needle)+i]) == needle {return i}}return -1}

时间复杂度O(n-m)
空间复杂度O(n)

2、KMP算法：直接使用前缀表作为next数组

思路：

构造next数组
1. 初始化：前缀末尾指针before指向第一个字符，第一个子串的前后缀长度next[0]为0
2. 默认before指针之前的字符与behind指针之前的字符相等。
3. 比较before指向的字符与behind指向的字符是否相等。
  - 当不相同时，before指向前一个字符，重新比较，直到before指向第一个字符或者before与behind的字符相等时，结束比较。
  - 当又相同时，before指向下一个字符。
4. before的位置就是最长前后缀长度，更新next数组。
使用next数组做匹配
- 初始化
  - i为文本串起始位置，j为模式串起始位置
  - 得到next数组
- 在文本串中查找模式串，对比i和j分别对应的字符
  - 若i和j相等，则i和j同时后移
  - 若i和j不相等，则j寻找之前匹配的位置，
    - 也就是通过next数组的最大相同子串长度滑动j，确定从模式串的哪个位置开始重新比较
  - 当 j 比完模式串的最后一个字符后，说明模式串在文本串中出现过，返回结果
  - 若文本串遍历结束，j也没有指向模式串的最后一个字符，就返回-1

//直接将前缀表作为next数组
func getnext(next []int, s string) {// before: 前缀末尾，前缀长度// behand：后缀末尾before := 0next[0] = 0for behind := 1; behind < len(s); behind++ {for before > 0 && s[behind] != s[before] { // 前缀与后缀不相等before = next[befor-1]}if s[behind] == s[before] { // 前缀与后缀相等before++}next[behind] = before}
}
// 直接将前缀表作为next数组的匹配实现
func strStr(haystack string, needle string) int {j := 0 // j 为模式串的起始位置, next数组记录的起始位置为0next := make([]int, len(needle))getnext(next, needle)for i := 0; i < len(haystack); i++ { // i从0开始for j > 0 && haystack[i] != needle[j] { // 不匹配j = next[j-1] // j寻找之前匹配的位置}if haystack[i] == needle[j] { // 匹配，j 和 i同时向后移动j++ // i的增加在for循环中}if j == len(needle) { // 文本串haystack中出现了模式串needlereturn i - j + 1}}return -1
}

n为文本串长度，m为模式串长度。
匹配的过程是O(n)，
单独生成next数组，时间复杂度是O(m)。
整个KMP算法的时间复杂度是O(n+m)的。

三、其他语言版本

Java

class Solution {//前缀表（不减一）Java实现public int strStr(String haystack, String needle) {if (needle.length() == 0) return 0;int[] next = new int[needle.length()];getNext(next, needle);int j = 0;for (int i = 0; i < haystack.length(); i++) {while (j > 0 && needle.charAt(j) != haystack.charAt(i)) j = next[j - 1];if (needle.charAt(j) == haystack.charAt(i)) j++;if (j == needle.length()) return i - needle.length() + 1;}return -1;}private void getNext(int[] next, String s) {int j = 0;next[0] = 0;for (int i = 1; i < s.length(); i++) {while (j > 0 && s.charAt(j) != s.charAt(i)) j = next[j - 1];if (s.charAt(j) == s.charAt(i)) j++;next[i] = j; }}
}

C++

class Solution {
public:void getNext(int* next, const string& s) {int j = 0;next[0] = 0;for(int i = 1; i < s.size(); i++) {while (j > 0 && s[i] != s[j]) {j = next[j - 1];}if (s[i] == s[j]) {j++;}next[i] = j;}}int strStr(string haystack, string needle) {if (needle.size() == 0) {return 0;}int next[needle.size()];getNext(next, needle);int j = 0;for (int i = 0; i < haystack.size(); i++) {while(j > 0 && haystack[i] != needle[j]) {j = next[j - 1];}if (haystack[i] == needle[j]) {j++;}if (j == needle.size() ) {return (i - needle.size() + 1);}}return -1;}
};

Python


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