日升时奋斗，日落时自省
目录
一、BF暴力算法
暴力算法是普通的模式匹配算法
针对一个主串和一个子串，子串是否能跟主串的某一段进行完全匹配，直白点就是子串在主串中出现。（并且返回子串第一次出现的下标位置）
BF思想：就是将目标串S的第一个字符与模式串T的第一个字符进行匹配，若相等，则继续比较S的第二个字符和T的第二个字符再进行比较，依次下去，如果不相等的话，S需要退回，退回多少？当前T字符串位置-1（后面通过例题来解释当前现象）
例题演示：给出字符串 ”ababcabcdabcde”作为主串， 然后给出子串： ”abcd”,现在我们需要查找子串是否在主串中出现，出现返回主串中的第一个匹配的下标，失败返回-1 ;
下面给出图解：
这里附一下代码：
//暴力算法
public static int BF(String str,String sub){
if(str==null||sub==null){ //稍微谨慎一点 如果字符串任意一个为空的话就不用找了， 直接返回
return -1;
}
int strlen=str.length();
int sublen=sub.length();
if(strlen==0||sublen==0){ //字符串虽然存在但是没有字符存在 也就找不到 直接返回
return -1;
}
int i=0;
int j=0;
//首先就是整体遍历
while(i<strlen&&j<sublen){
//如果两个相等的话 就可以直接走了
//如果两个主串和子串的字符相等的话 主串 和 子串都进行++ ，进行两个字符串的下一个字符比较
if(str.charAt(i)==sub.charAt(j)){
i++;
j++;
}else{
//如果不等呢 那子串就从0开始，重新和主串比较
//主串回退 :那前面有一段肯定是跟子串一模一样的 ，所以主串当前下标位置减去 子串当前位置下标回到了原来字符串相等的位置，但是还需要在该位置加一 进行下一次新的比较开始
i=i-j+1;
j=0;
}
}
//只有子串走完了才算是找到 所以大于或者等于都在其内
if(j>=sublen){
return i-j; //为什么是 i-j 因为返回当前已经找到的子串的第一个下标 用当前下标减去子串长度
}
//没有找到的话 ，就是子串没有走完呗
return -1;
}
public static void main(String[] args) {
System.out.println(BF("ababcabcdabcde", "abcd"));
}这里有一个位置理解可能有点困难，结合案例 自己画画图，理解比较快捷
代码配有注释：
这里再次解释一下 ，该段代码
while(i<strlen&&j<sublen){
//如果两个相等的话 就可以直接走了
//如果两个主串和子串的字符相等的话 主串 和 子串都进行++ ，进行两个字符串的下一个字符比较
if(str.charAt(i)==sub.charAt(j)){
i++;
j++;
}else{
//如果不等呢 那子串就从0开始，重新和主串比较
//主串回退 :那前面有一段肯定是跟子串一模一样的 ，所以主串当前下标位置减去 子串当前位置下标回到了原来字符串相等的位置，但是还需要在该位置加一 进行下一次新的比较开始
i=i-j+1;
j=0;
}
}这里的i表示的是主串当前字符的位置，j表示子串当前字符的位置
首先就是判断主串当前位置字符和子串当前位置字符是否相同 就是这里的 if（）语句。
如果不同呢：这里就是判断的难点
以上面图中提及的一个案例进行解释
对返回值代码这里做一个解释：
if(j>=sublen){
return i-j; //为什么是 i-j 因为返回当前已经找到的子串的第一个下标 用当前下标减去子串长度
}为什么是 i-j 下标
（1）首先就是 题目要求返回的是 “主串中的第一个匹配的下标”
那还是用图来解释：
时间复杂度：O(m*n) 就是子串的长度 * 主串的长度
二、KMP算法
1、next数组
KMP算法 相比于BF暴力算法就时间复杂度就更优了
KMP算法核心解释：主要就是匹配失败后BF又从新比较了很多次，尽量减少模式串与主串的匹配次数以达到快速匹配的目的，主要通过一个next数组来接收回退的值
区别： KMP 和 BF唯一不一样的地方就在KMP算法中主串i并不会回退，并且j也不会移动到0位置，给子串j的配一个next数组来记录回退的下标，直接回退到能连续的位置（图解）
那来看一下，子串是如何回退的，如果主串当前字符和子串当前字符相同，就与BF暴力算法相同，相等就直接让两者都进行加加。
重在：如果两个字符不同的情况下如何处理更优，BF算法中子串会进行回退，那如何回退能提高效率，每次回退的到上一个子串的长度。
那这个子串又是如何确定的呢：其实不难发现子串当前位置的字符与当前主串位置的字符不相同，说明前面是有一部分是相同的，那最长的相同就是从开头到当前字符的前一个位置，所以能推出前面能够比配的字符是以0下标位置的字符作为开始字符，以i-1下标位置的字符作为结束字符，从前开始找这样的子集（如下图解释）
原理基本如上，那用next数组如何来存放这些回退的下标呢
这里以举出；两个实例来，来帮助理解（这里是为了帮助我们理解next数组，他们都是子串，只是为了演示清楚，所以子串很长）
例子1的 字符串： ”ababcabcdabcde”
例子2的 字符串：”abcabcabcabcdabcde”
代码解释：
//KMP算法
/*str 主字符串
sub 子字符串
pos 主字符串的位置
* */
public static int KMP(String str,String sub,int pos){
if(str==null||sub==null){ //判断是否为空
return -1;
}
int strlen=str.length();
int sublen=sub.length();
if(strlen==0||sublen==0){ //字符串是否没有长度
return -1;
}
if(pos<0||pos>=strlen){ //主串当前下标是否 越界 不能小于0 不能大于主串的长度
return -1;
}
int i=pos; //主串的下标
int j=0; //子串的下标
int[] next=new int[sublen]; //next数组是给子串用的话 ，前面说了 主串在匹配失败后是不会回退的
getNext(next,sub); //next数组处理
//遍历两个字符串
while(i<strlen&&j<sublen){
//如果两个字符串当前字符都是相同的，都进行加加 开始比较两个字符串的下一个字符
if(j==-1||(str.charAt(i)==sub.charAt(j))){
i++;
j++;
}else{
//子串回退位置 主串不再回退，相比 BF算法
//j 接收 next数组值回退的下标
j=next[j];
}
}
//返回字符串第一次初识的位置 与BF暴力算法相同
if(j>=sublen){
return i-j;
}
return -1;
}
public static void getNext(int[] next,String sub){
next[0]=-1; //这里我们把 next数组的第一个值定为 -1
next[1]=0; // 自然 next数组的第二个下标值就是 0 因为他能回退的位置就只第一个位置就是 0 为位置
int i=2; //这里是我们自己提前了一个位置 因为 next数组 0 和 1位置已经有值了 i就从2开始
int k=0; //回退的位置的下标
//遍历字符串
while(i<sub.length()){ //next数组还没有遍历完
//如果回退位置的字符和当前位置的前一个字符相同的话，就说明条件满足，可以进行加加
//同时也就是说明可以继续next数组的回退值也可以进行加加
if((k==-1)||sub.charAt(k)==sub.charAt(i-1)){
next[i]=k+1;
i++;
k++;
}else{
//如果回退位置的字符和当前位置的前一个字符是不同的呢
//那就说明当前字符对应的next数组回退下标是不对的，需要在向前再进行回退
k=next[k];
}
}
}
public static void main(String[] args) {
System.out.println(KMP("ababcabcdabcde","abcd",0));//5
System.out.println(KMP("ababcabcdabcde","abcde",0));//9
System.out.println(KMP("ababcabcdabcde","ab",0)); //0
}这里解释下代码中的难点，前面的手动理论如果能够明白的话，其实也就不难理解这里的next数组
什么时候才会用到当前next数组呢，回退的时候就会用到，所以我们这里解释
回退位置是我们通过一个方法把next数组提前就预备好了，这个位置的代码应该不会很难理解，主要是next数组回退值如何处理
详细说next数组怎么设置回退值的
首先就是代码上定义了很多的变量，而且还给next数组的前两位赋值了，可能友友们就不是很理解（图解）
那如何遍历能让next数组对应到应有的回退值呢
其他位置的代码和BF暴力算法的基本相同
时间复杂度O(m+n) 回退不在像BF算法中那样回退到0从新开始，按照需求回退，每次最后把子串走完所以时间复杂度就是 子串长度加上主串长度
2、next数组优化（nextval）
其实也不难发现next数组虽然知道了回退值，但是还是会造成多次回退只是相比于BF算法回退次数减少了，但是不算是最优的，以为回退可能也会回退多次，不如一次就回退完，不用二次回退
举例解释：
这里只修改了getNext代码：
public static void getNext(int[] next,String sub){
next[0]=-1;
next[1]=0;
int i=2;
int k=0;
while(i<sub.length()){ //next数组还没有遍历完
if((k==-1)||sub.charAt(k)==sub.charAt(i-1)){
i++;
k++;
//
if(sub.charAt(i-1)!=sub.charAt(k)){
next[i-1]=k; //当前位置如果不相同 就把本值移下来
}else {
next[i-1]=next[k]; //如果是相同的就把回退位置的next赋给当下新值
}
}else{
k=next[k];
}
}
}和原来的next数组有部分的变化，就是没有直接进行next[i]=k+1,因为这里next数组并没有处理完，所以还需要处理，如果当前的字符的前一个字符和回退位置的字符是相同的，那么就把回退位置的字符的next值给当前位置，减少了回退的次数，一次回退到位，如果当前的字符的前一个字符和回退位置的字符是不相同的，说明无可回退的位置；就把原来回退的下标赋给当前的next就行，next[i-1]=k，这里不好理解，可以结合前面举的例子，来理解代码，理论明白了，代码也就不远了
2407
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
