代码随想录字符串——实现strStr（）

题目

实现 strStr() 函数。

给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置
(从0开始)。如果不存在，则返回 -1。

示例 1: 输入: haystack = “hello”, needle = “ll” 输出: 2

示例 2: 输入: haystack = “aaaaa”, needle = “bba” 输出: -1

说明: 当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。 对于本题而言，当 needle
是空字符串时我们应当返回 0 。这与C语言的 strstr() 以及 Java的 indexOf() 定义相符。

思路

本题是KMP经典题目

• KMP的主要思想：当出现字符串不匹配时，可以知道一部分之前已经匹配的文本内容，可以利用这些信息避免从头再去做匹配了
• next数组：就是一个前缀表，前缀表是用来回退的，它记录了模式串与主串(文本串)不匹配的时候，模式串应该从哪里开始重新匹配。
• 前缀表：记录下标 i 之前（包括下标 i ）的字符串中，有多大长度的相同前缀后缀
• 最长公共（相等）前后缀：前缀是指不包含最后一个字符的所有以第一个字符开头的连续子串，后缀是指不包含第一个字符的所有以最后一个字符结尾的连续子串，如字符串a的最长相等前后缀为0（没有最长相等前、后缀）。 字符串aa的最长相等前后缀为1（最长相等的前缀、后缀字符串是a）。 字符串aaa的最长相等前后缀为2（最长相等的前缀、后缀字符串是aa）。
• 前缀表为什么可以找到上次匹配的位置并且跳过：因为找到了最长相等的前缀和后缀，匹配失败的位置是后缀子串的后面一位，那么我们找到与其相同的前缀的后面一位重新匹配就可以了。如‘aabaabaaf’中匹查找模式串‘aabaaf’，会在下标=5的地方即主串中的‘b’那里第一次匹配失败，而‘b’的前面是后缀字串，那么可以找到与其相同的前缀字串后面，即下标=2的‘b’开始匹配即可
• 前缀表的计算：下标 i 之前（**包括 i **）的字符串中，有多大长度的相同前缀后缀。
  
  PS：next数组和前缀表的关系，next数组可以就是前缀表，也可以是前缀表的值减一之后用作next数组（很多实现都是用这个，即右移一位，初始位置从-1开始）
• 时间复杂度：O（n+m），其中n为文本串长度，m为模式串长度，因为在匹配的过程中，根据前缀表不断调整匹配的位置是O(n)，之前还要单独生成next数组是O(m)。

构造next数组：

1. 初始化

定义两个指针 i 和 j ，i 指向后缀末尾的位置， j 指向前缀末尾的位置，即 j 表示前缀的长度,注意：这里的 i 和 j 都是在模式串一个中移动的，为了构造next数组,匹配过程中的 i 和 j 是分别在主串和模式串中移动的

//next[i] 表示 i（包括i）之前最长相等的前后缀长度（其实就是j）
 int j = -1;//这里前缀表全部减一
 next[0] = j;//初始值从-1开始

2. 处理前后缀不相同的情况
因为 j 初始化为-1，那么 i 从1
开始，进行s[i] 与 s[j+1]的比较（因为i 指向后缀末尾，j 指向前缀末尾，所以最开始 j + 1
和 i 比较）

for(int i =1;i < s.length(); i++){
}

如果s[i] 与 s[j+1]不相同，表示出现了前后缀末尾不相同的情况，要向前回退。

因为next[ j ]就是记录着 j（包括 j ）之前的子串的相同前后缀的长度，那么 s[i] 与 s[j+1] 不相同，就要找 j+1前一个元素在next数组里的值（就是找next[j]）。

while(j >= 0 && s.charAt(i) != s.charAt(j+1)){//也可以把s用toCharArray()转化成字符数组，然后s[i] != s[j+1]操作
	j = next[j];// j 向前回退
}

3. 处理前后缀相同的情况
如果 s[i] 与 s[j + 1] 相同，那么就同时向后移动 i 和 j ，说明找到了相同的前后缀，同时还要将 j（前缀的长度）赋给next[ i ], 因为next[i]要记录相同前后缀的长度。

if(s.charAt(i) == s.charAt(j+1)){
	j++;
}
next [i] = j;//

整体构建next代码如下

void getNext(int[] next,String s){
	int j = -1;//初始化
	netx[0] = j;
	for(int i = 1; i < s.length(); i++){//注意 i 从1 开始
		while(j >= 0 && s.charAt(i) != s.charAt(j+1)){//当前后缀不相同时
			j = next[j];//j进行回退
		}
		if(s.charAt(i) == s.charAt(j+1)){//如果前后缀相同
			j++;//i 和 j 同时后移
		}
		next[i] = j;// 将j（前缀的长度）赋给next[i]
	}
}

使用next数组进行匹配 :
在主串（文本串）s 中找是否出现过模式串 t。

定义两个下标， j 指向模式串起始位置（初始值仍然是-1），i 指向文本串起始位置。

1、i 从0开始遍历主串：

for(int i = 0; i < s.length(); i++){//注意和构造next数组的时候区分开，两种情况下下标起始位置不同
}

2、将 s[i] 与 t [j + 1] （因为 j 从-1开始的） 进行比较。

（1）如果 s[i] 与 t[j + 1] 不相同，j就要从next数组里寻找下一个匹配的位置：

while(j >= 0 && s.charAt(i) != t.charAt(j+1)){//i 和 j 分别在主串和模式串中移动
	j = next[j];
}

（2）如果 s[i] 与 t[j + 1] 相同，那么i 和 j 同时向后移动：

if(s.charAt(i) == t.charAt(j+1)){
	j++;//指针同时移动，i的增加在for循环里
}

如果 j 指向了模式串 t 的末尾，那么就说明模式串t完全匹配文本串s里的某个子串了。

本题要返回主串中找出模式串出现的第一个位置（从0开始），所以返回主串匹配模式串的位置 i 减去模式串的长度，就是主串中出现模式串的第一个位置：

if(j == (t.length() - 1)){
	return (i - t.length() + 1);
}

使用next数组，用模式串匹配主串的整体代码如下：

int j = -1;
for(int i = 0; i < s.length();i++){//注意i从0就开始
	while(j >= 0 && s.charAt(i) != t.charAt(j+1)){//如果不匹配
		j = next[j];//j 寻找之前匹配的位置
	}
	if(s.charAt(i) == t.charAt(j+1)){//匹配，j和i同时向后移动
		j++;// i的增加在for循环里
	}
	if(j == (t.length() - 1)){//主串s中出现了模式串t
		return (i- t.length() + 1);
	}
}

最终实现strStr（）的整体代码如下：

// 方法一
class Solution {
    public void getNext(int[] next, String s){
        int j = -1;
        next[0] = j;
        for (int i = 1; i < s.length(); i++){
            while(j >= 0 && s.charAt(i) != s.charAt(j+1)){
                j=next[j];
            }

            if(s.charAt(i)==s.charAt(j+1)){
                j++;
            }
            next[i] = j;
        }
    }
    public int strStr(String s, String t) {
        if(s.length()==0){
            return 0;
        }

        int[] next = new int[t.length()];
        getNext(next, t);
        int j = -1;
        for(int i = 0; i<s.length();i++){
            while(j>=0 && s.charAt(i) != t.charAt(j+1)){
                j = next[j];
            }
            if(s.charAt(i)==t.charAt(j+1)){
                j++;
            }
            if(j == t.length()-1){
                return (i-t.length()+1);
            }
        }

        return -1;
    }
}