从C++strStr到字符串匹配算法
字符串的匹配先定义两个名词：模式串和文本串。我们的任务就是在文本串中找到模式串第一次出现的位置，如果找到就返回位置的下标，如果没有找到返回-1.其实这就是C++语言里面的一个函数：
extern char *strstr(char *str1, const char *str2);
对于这个函数的解释：
str1: 被查找目标 str2: 要查找对象 返回值：如果str2是str1的子串，则返回str2在str1的首次出现的地址； 如果str2不是str1的子串，则返回NULL。 例如： char str[]="1234xyz"; char *str1=strstr(str,"34"); cout << str1 << endl; 显示的是: 34xyz
返回值是一个指针，这个指针指向文本串中第一次出现模式串的位置。
字符串查找的暴力算法
先看LeetCode上的一道题目，实现这个函数 int strStr(string haystack, string needle); ，要求返回文本串中出现模式串的下标值。
1.如果模式串为NULL，那么直接返回0. 2.如果模式串的长度大于文本串，那么一定查找不到，返回-1. 3.如果存在的话，查找的范围可以限定在文本串的0~s.size()-p.size();
所以暴力算法的代码实现：
int strStr(string haystack, string needle)
{
int i = 0;
//模式串为空
if(needle.empty())
{
return 0;
}
//文本串的大小小于模式串
if(haystack.size() < needle.size())
{
return -1;
}
//确定查找的范围
for(i = 0; i <= haystack.size()-needle.size(); ++i)
{
int j = 0;
for(j = 0; j < needle.size(); ++j)
{
if(haystack[i+j] != needle[j])
{
break;
}
}//for
if(j == needle.size())
{
return i;
}
}//for
if(i == haystack.size()-needle.size() + 1)
{
return -1;
}
}
字符串查找的KMP算法
上面的暴力算法，在查找失败以后都要进行回溯，下面再给出一个版本，明显的看到i,j的回溯：
int strStr(string haystack, string needle)
{
int sLen = haystack.size();
int pLen = needle.size();
int i = 0;
int j = 0;
while(i < sLen && j < pLen)
{
if(haystack[i] == needle[j])
{
++i;
++j;
}
else
{
i = i - j + 1;
j = 0;
}
}//while
if(j == pLen)
{
return i - j;
}
else
{
return -1;
}
}
假设我们已经知道了KMP的next数组，所以每次失配以后，i不回溯，j回溯到next[j]指定的位置。也就是 j = next[j]; 。
int KmpSearch(char *s, char *p)
{
int i = 0;
int j = 0;
int sLen = strlen(s);
int pLen = strlen(p);
while(i < sLen && j < pLen)
{
//如果j = -1，或者当前字符匹配成功（即S[i] == P[j]），都令i++，j++
if(j == -1 || s[i] == p[j])
{
i++;
j++;
}
else
{
//如果j != -1，且当前字符匹配失败（即S[i] != P[j]），则令 i 不变，j = next[j]
//next[j]即为j所对应的next值
j = next[j];
}
}//while
if(j == pLen)
{
return i - j;
}
else
{
return -1;
}
}
对于上面的j=-1和next[0]=-1作下面的解释：
说完了KMP的大的框架，下面就得说一下next数组的求解过程了：
void GetNext(char *p, int *next)
{
int pLen = strlen(p);
int j = 0;
int k = -1;
next[0] = -1;
while(j < pLen - 1)
{
//p[k]表示前缀，p[j]表示后缀
if(k == -1 || p[j] == p[k])
{
++k;
++j;
next[j] = k;//表示在j这个字符之前，能够构成公共前后缀的最大字符数
}
else
{
k = next[k];//回溯之前已经有过匹配的前缀
}
}
}
KMP算法的一个改进
上面的KMP算法已经能够很好的跑出结果来了，但是还可以改进，看下面的一个字符串的匹配：
改进的代码实现：
void GetNextVal(char *p, int *next)
{
int pLen = strlen(p);
int j = 0;
int k = -1;
next[0] = -1;
while(j < pLen - 1)
{
//p[k]表示前缀，p[j]表示后缀
if(k == -1 || p[j] == p[k])
{
++k;
++j;
if(p[j] != p[k])
{
next[j] = k;//表示在j这个字符之前，能够构成公共前后缀的最大字符数
}
else
{
next[j] = next[k];//因为不能出现p[j] = p[next[j]]，所以当出现时需要继续递归，k = next[k] = next[next[k]]
}
}
else
{
k = next[k];//回溯之前已经有过匹配的前缀
}
}
}
再来看一个极端的情况：
