提示:本文仅做简单介绍,部分图来自网络,侵删
导入
leetcode 28
找出字符串中第一个匹配项的下标
问题描述:给你两个字符串 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 仅由小写英文字符组成
方法一:Broute Force
暴力算法
class Solution {
public:
int strStr(string haystack, string needle) {
int m = haystack.size();
int n = needle.size();
for(int i = 0; i <= m - n; i ++){
int k = 0; // needle 字符串计数
int j = i;
while(k < n && haystack[j] == needle[k]) {
j ++;
k ++;
}
if(k == n) {
return i;
}
}
return -1;
}
};
方法二:KMP
算法
详见 串的模式匹配
class Solution {
public:
int strStr(string haystack, string needle) {
// KMP by myself!
int s_len = haystack.length();
int p_len = needle.length();
if(p_len == 0) {
return 0;
}
vector<int> next(p_len, 0);
for(int j = 0, i = 1; i < p_len; i ++){
// j代表前缀最后一个字符(j也代表最长相等前后缀),i代表后缀最后一个字符
while(j > 0 && needle[j] != needle[i]) {
// 当前的前后缀字符不相等,前缀回退
j = next[j - 1];
}
if(needle[j] == needle[i]) {
// 当前的前后缀字符相等,前缀加一(最长相同前后缀加一)
j ++;
}
// 更新 next 数组
next[i] = j;
}
// 模式匹配
for(int i = 0, j = 0; i < s_len; i ++) {
while(j > 0 && haystack[i] != needle[j]) {
j = next[j - 1];
}
if(haystack[i] == needle[j]) {
j ++;
}
if(j == p_len) {
return i - p_len + 1;
}
}
return -1;
}
};
方法三:api
大法好
class Solution {
public:
int strStr(string haystack, string needle) {
return haystack.find(needle);
}
};
一、串类型的定义
字符串string
:由零个或多个字符组成的有序数列。串中字符数量称为串的长度,零个字符称为空串,任意连续的字符组成的子序列在串中称为子串,相应的包含子串的字符串称为主串,字符串属于线性表,字符在串中的序号称为该字符的位置,当两个串的所有字符值都相等则称这两个串相等。
s = 'a1a2a3a4a5……an' (n >= 0)
二、串的表示和实现
typedef struct {
char *ch;
int length;
}string;
串的基本操作
略略略
三、串的模式匹配
- 字符串的前缀:从主串下标0开始的子串称为主串的前缀;
- 字符串的后缀:从主串下标大于0的位置到结尾的子串称为主串的后缀;
- 目标串:也就是主串,简单说就是那条比较长的串;
- 模式串:也就是那条短的,用来匹配的串;
- kmp算法的目的:在O(m+n)的时间复杂度的内进行串匹配,也就是在目标串中找到模式串,并返回目标串中模式串的第一个字符下标;
next数组的含义:
next[i] = k
表示p[0…i]这个串中,前缀与后缀相同的情况下,前缀的最长长度为k,例如:p[8] = {a, c, d, e, f, a, c, d, e}
,这里next[6] = 2 (p[6] = c, a c = a c),
next[8] = 4 (p[8] = e, a c d e = a c d e)
求next数组,法一(删):
若p[x] = p[now],显然等式 next[x] = n[x-1] + 1成立;
若 p[x] != p[now],当next[x - 1] = 0的时候看一下p[0]与p[x],若相等next[x] = 1,否则为0;当next[x - 1] != 0的时候,等式next[x] = n[x-1] + 1成立。
void get_next(int next[]){
next[0] = 0;//第一个肯定是0
int x = 1;//我们从p[1]开始递归
int now = 0;//next[x-1] = now
while(x < m){
if(p[x] == p[now]){
next[x] = now + 1;//若相等,则直接加一
now ++;//now也加一计算下一个
x++;//计算下一个
}else if(now != 0){//不相等的情况,递归计算次一级的长度
now = next[now - 1];
}else{//now = 0 表示上一次循环计算次一级长度的时候不存在,表示找以p[x-1]结尾的串的前缀与后缀相等的情况已经找完了
//找完了都满足不了p[x] == p[now + 1]这时直接x++进入下一个字符,next[x] = 0
//可以将上面的例子中a串中的字符c改为字符d帮助理解,也可以从x = 1 , now = 0处开始理解
x++;
}
}
}
求next数组,法二:
next[0] = 0;
// j 指向前缀末尾位置(j 亦代表最长相等前后缀),i 指向后缀末尾位置
for(int i = 1, j = 0; i < p.length(); i++){
// 1)前后缀不相同
while(j && p[i] != p[j]) {
// 当前字符不相等,前缀回退到上一个,循环回退直至当前的前缀和后缀字符相等
// 注意,前缀 j 不能越界
j = next[j - 1];
}
// 2 )前后缀相同
// 前缀后移(最长相等前后缀加一)
if(p[i] == p[j]) {
j++;
}
// 3)更新next数组值
next[i] = j;
}
KMP思想:在一次整体匹配失败后我们必定可以得到一些匹配成功的串,我们发现在后面的匹配尝试中,这些匹配成功的串只要出现后缀不等于前缀的情况,那这些尝试就必定是失败的,于是我们可以直接跳过这些尝试,直接进行后缀等于前缀的尝试,至于这个尝试是不是失败我们根据经验是不知道的,我们接着递归这个过程,直到匹配完全。
快找个视频看看,在这是整不明白的,哈哈哈