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

最新推荐文章于 2024-10-04 14:10:29 发布

南巷逸清风

最新推荐文章于 2024-10-04 14:10:29 发布

阅读量611

点赞数 16

分类专栏： LeetCode 文章标签： leetcode 算法 c++ python

本文链接：https://blog.csdn.net/weixin_50878507/article/details/142309579

版权

LeetCode 专栏收录该内容

41 篇文章 0 订阅

订阅专栏

题目描述

给你两个字符串 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 <= 10^4
haystack 和 needle 仅由小写英文字符组成

思路

本题是KMP 经典题目。

KMP的作用

KMP主要应用在字符串匹配上。其的经典思想是:当出现字符串不匹配时，可以记录一部分之前已经匹配的文本内容，利用这些信息避免从头再去做匹配。

前缀表

前缀表是用来回退的，它记录了模式串与主串(文本串)不匹配的时候，模式串应该从哪里开始重新匹配。next数组就是一个前缀表。

前缀表会记录下标i之前（包括i）的字符串中，有多大长度的相同前缀后缀。

最长相等前后缀

前缀是指不包含最后一个字符的所有以第一个字符开头的连续子串。

后缀是指不包含第一个字符的所有以最后一个字符结尾的连续子串。

前缀表要求前后缀的长度相同，所以字符串s的最长相等前后缀为0。字符串ss的最长相等前后缀为1。字符串sss的最长相等前后缀为2。

寻找最长相等前缀和后缀子字符串的原因是是后缀子字符串的后面就是匹配失败的位置，而且后缀子字符串能够当作新的前缀。

如何计算前缀表

前缀表的每个值与模式串的每个字符一一对应，每个值的含义是下标i之前（包括i）的字符串中，有多大长度的相同前缀后缀。

当字符不匹配的时候应该指针应该移动的位置

找到字符串首次不匹配的位置，此时我们要看它的前一个字符的前缀表的数值是多少，这个值就是最长相等前后缀，然后就可以将模式串的下标移动到这个值的位置继续匹配（包括该值的位置对应的字符）。

next数组

next数组既可以就是前缀表，也可以是前缀表统一减一（右移一位，初始位置为-1）。

核心就是找到冲突的首个位置，它的前一位便是继续匹配的开始下标。也就是说，如果将next数组向右移动一位，令next[0]恒为-1，那么匹配串中冲突的位置对应的值就是继续匹配的开始下标。

构造next数组

定义一个函数getNext来构建next数组，函数参数为指向next数组的指针，和一个字符串。

构造next数组其实就是计算模式串s，前缀表的过程。主要有如下三步：

初始化
处理前后缀不相同的情况
处理前后缀相同的情况

1.初始化

定义两个指针i和j，j指向前缀末尾位置，i指向后缀末尾位置。

笔者将j初始化为0，next[0]=j。

next[i] 表示 i（包括i）之前最长相等的前后缀长度。（其实就是j）

2.处理前后缀不相同的情况

因为j初始化为0，那么i就从1开始（从0开始没有必要，因为next[0]已经初始化为0了），进行s[i] 与 s[j]的比较。

如果s[i]与s[j]不相同，也就是遇到前后缀末尾不相同的情况，就要向前回退，即令j=next[j-1]。

3.处理前后缀相同的情况

如果s[i]与s[j]相同，说明找到了相同的前后缀，那么就同时向后移动i和j。

同时每轮遍历还要将j（前缀的长度）赋给next[i], 因为next[i]要记录相同前后缀的长度。

使用next数组来做匹配

定义两个下标，j指向模式串起始位置即j=0，i指向文本串起始位置即i=0。

i从0开始，遍历文本串。如果s[i]与t[j]不相同，j就要从next数组里寻找之前匹配的位置。如果s[i]与 t[j]相同，那么i和j同时向后移动。如果j指向了模式串t的末尾，那么就说明模式串t完全匹配文本串s里的某个子串了。

代码

C++版：（不减一）

class Solution {
public:
    // 不减去1的实现方式
    void getNext(int* next,string& s){
        int j=0;
        next[0]=0;
        // 从i=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) {
        // KMP 算法经典题目
        // 定义next数组
        vector<int> next(needle.size());
        getNext(&next[0], 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 = 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:
        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