实现strstr(****)

版本一

求next数组(个人最习惯的写法)

构造next数组其实就是计算模式串s，前缀表的过程。」 主要有如下三步：
1、初始化
2、处理前后缀不相同的情况
3、处理前后缀相同的情况

   void getNext(int* next,const string &s){
	//初始化
	//next[i] 表示 i（包括i）之前的子串最长相等的前后缀长度（其实就是j）
	//所以初始化next[0] = j 。
	int j=0;
	next[0]=j;
    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;
	}
}

代码实现

class Solution {
public:
   void getNext(int* next,const string &s){
	int j=0;
	next[0]=j;
    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; // // 因为next数组里记录的起始位置为-1
        for (int i = 0; i < haystack.size(); i++) { // 注意i就从0开始
            while(j > 0 && haystack[i] != needle[j]) { // 不匹配
                j = next[j-1]; // j 寻找之前匹配的位置
            }
            if (haystack[i] == needle[j ]) { // 匹配，j和i同时向后移动 
                j++; 
            }
            if (j == (needle.size() ) ) { // 文本串s里出现了模式串t
                return (i - needle.size() + 1); 
            }
        }
        return -1;
    }
};

版本二

求next数组(-1操作)

如果我们这样写

void getNext(int* next, const string& s){
    int j = 0;
    next[0] = j;
    for(int i = 1; i < s.size(); i++) { // 注意i从1开始
        while (j >= 0 && s[i] != s[j]) { // 前后缀不相同了
            j = next[j]; // 向前回溯
        }
        if (s[i] == s[j]) { // 找到相同的前后缀
            j++;
        }
        next[i] = j; // 将j（前缀的长度）赋给next[i]
    }
}

那么构造前缀表的时候会陷入死循环，而不是文本串 与 模式串匹配的时候陷入死循环。

此时i与j并不相同，那么j需要回退，此时j = 1，而next[1]=1，j = next[j]陷入死循环。

初始化

定义两个指针i和j，j指向前缀末尾位置（严格来说是末尾位置减一的位置），i指向后缀末尾位置。
然后还要对next数组进行初始化赋值，如下：

int j = -1;
next[0] = j;

j 为什么要初始化为 -1呢，是因为之前说过 前缀表要统一进行减一的操作

next[i] 表示 i（包括i）之前的子串最长相等的前后缀长度（其实就是j）所以初始化next[0] = j 。

处理前后缀不相同的情况

因为j初始化为-1，所以遍历模式串s的循环下表i 要从 1开始，进行s[i] 与 s[j+1]的比较。

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

如果 s[i] 与 s[j+1]不相同，也就是遇到 前后缀末尾不相同的情况，就要向前回溯。

怎么回溯呢？

next[j]就是记录着j（包括j）之前的子串的相同前后缀的长度。

那么 s[i] 与 s[j+1] 不相同，就要找 j+1前一个元素在next数组里的值（就是next[j]）。

while (j >= 0 && s[i] != s[j + 1]) { // 前后缀不相同了
    j = next[j]; // 向前回溯
}

处理前后缀相同的情况

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

if (s[i] == s[j + 1]) { // 找到相同的前后缀
    j++;
}
next[i] = j;

Next数组代码实现

   void getNext(int* next,string &s){
	int j=-1;
	next[0]=j;
    for(int i=1;i<s.size();i++){// 注意i从1开始
    	//j>=0是因为j初始值为-1，当ab，j+1指向a的时候，不加j>=0这个条件，j会回退到当前位置的前一个位置所对应的next数组的值，即j=next[j+1-1](j=next[-1])的位置造成内存越界。
		while(j>=0 && s[i]!=s[j+1]){// 前后缀不相同了
			j=next[j];// 向前回溯
		}
		if(s[i]==s[j+1]){// 找到相同的前后缀
			j++;
		}
		next[i]=j;//将j（前缀的长度）赋给next[i]
	}
}

整体代码实现

class Solution {
public:
   //根据模式串求next数组
   void getNext(int* next,string &s){
	int j=-1;
	next[0]=j;
    for(int i=1;i<s.size();i++){
    	//j>=0是因为j初始值为-1，当ab，j+1指向a的时候，不加j>=0这个条件，j会回退到当前位置的前一个位置所对应的next数组的值，即j=next[j+1-1](j=next[-1])的位置造成内存越界。
		while(j>=0 && s[i]!=s[j+1]){
			j=next[j];
		}
		if(s[i]==s[j+1]){
			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; // // 因为next数组里记录的起始位置为-1
        for (int i = 0; i < haystack.size(); i++) { // 注意i就从0开始
            while(j > 0 && haystack[i] != needle[j]) { // 不匹配
                j = next[j-1]+1; // j 寻找之前匹配的位置
            }
            if (haystack[i] == needle[j]) { // 匹配，j和i同时向后移动 
                j++; 
            }
            if (j == (needle.size() ) ) { // 文本串s里出现了模式串t
                return (i - needle.size() + 1); 
            }
        }
        return -1;
    }
};

个人建议使用版本一 易理解