我想说一句“我日，我讨厌KMP！”。
KMP虽然经典，但是理解起来极其复杂，好不容易理解好了，便起码来巨麻烦！
老子就是今天图书馆在写了几个小时才勉强写了一个有bug的、效率不高的KMP，特别是计算next数组的部分。
其实，比KMP算法速度快的算法大把大把，而且理解起来更简单，为何非要抓住KMP呢？笔试出现字符串模式匹配时直接上sunday算法，既简单又高效，何乐而不为？
说实话，想到sunday算法的那个人，绝对是发散思维，绝对牛。当我在被KMP折磨的够呛的时候，我就琢磨，有没有别的好算法呢？？琢磨了半天也没想出个所以然来。笨啊，脑子不够发散。
下面贴上一位兄弟写的算法总结，很简单(建议KMP部分就不用看了，看了费脑子)。
参见：http://hi.baidu.com/willamette/blog/item/02bd0b5599c8b4c0b645ae06.html
趁着做Presentation的功夫，顺便做一个总结
字符串匹配：
---willamette
在匹配串中寻找模式串是否出现，注意和最长公共子序列相区别(LCS: Longest Common Substring)
-：Brute Force(BF或蛮力搜索)算法：
这是世界上最简单的算法了。
首先将匹配串和模式串左对齐，然后从左向右一个一个进行比较，如果不成功则模式串向右移动一个单位。
速度最慢。
那么，怎么改进呢？
我们注意到Brute Force算法是每次移动一个单位，一个一个单位移动显然太慢，是不是可以找到一些办法，让每次能够让模式串多移动一些位置呢？
当然是可以的。
我们也注意到，Brute Force是很不intelligent的，每次匹配不成功的时候，前面匹配成功的信息都被当作废物丢弃了，当然，就如现在的变废为宝一样，我们也同样可以将前面匹配成功的信息利用起来，极大地减少计算机的处理时间，节省成本。^_^
注意，蛮力搜索算法虽然速度慢，但其很通用，文章最后会有一些更多的关于蛮力搜索的信息。
-: KMP算法
首先介绍的就是KMP算法。
原始论文：Knuth D.E., Morris J.H., and Pratt V.R., Fast pattern matching in strings, SIAM Journal on Computing, 6(2), 323-350, 1977.
这个算法实在是太有名了，大学上的算法课程除了最笨的Brute Force算法，然后就介绍了KMP算法。也难怪，呵呵。谁让Knuth D.E.这么world famous呢，不仅拿了图灵奖，而且还写出了计算机界的Bible (业内人士一般简称TAOCP).稍稍提一下，有个叫H.A.Simon的家伙，不仅拿了Turing Award，顺手拿了个Nobel Economics Award，做了AI的爸爸，还是Chicago Univ的Politics PhD，可谓全才。
KMP的具体描述略去，教科书一大把。
-：Horspool算法
Horspool算法。
当然，有市场就有竞争，字符串匹配这么大一个市场，不可能让BF和KMP全部占了，于是又出现了几个强劲的对手。
第一个登场的是
论文：Horspool R.N., 1980, Practical fast searching in strings, Software - Practice & Experience, 10(6):501-506
Horspool算法的思想很简单的。不过有个创新之处就是模式串是从右向左进行比较的。很好很强大，为后来的算法影响很大。
匹配串：abcbcsdxzcxx
模式串：cbcac
这个时候我们从右向左进行对暗号，c-c，恩对上了，第二个b-a，不对啊，我们应该怎么办？难道就这么放弃么。于是，模式串从不匹配的那个字符开始从右向左寻找匹配串中不匹配的字符b的位置，结果发现居然有，赶快对上赶快对上，别耽误了。
匹配串：abcbcsdxzcxx
模式串：cbcac
然后继续从最右边的字符从右向左进行比较。这时候，我们发现了，d-c不匹配啊，而且模式穿里面没有噢，没办法，只好移动一个模式串长度的单位了。
匹配串：abcbcsdxzcxx
模式串：cbcac
-：Boyer-Moore算法
对于BM算法，下面推荐一个讲解非常优秀的文章，可谓图文并茂啊，而且还是个MM写的。
最后一个是Sunday算法，实际上比Boyer-Moore还快，呵呵。长江后浪推前浪。
原始论文：Daniel M. Sunday, A very fast substring search algorithm, Communications of the ACM, v.33 n.8, p.132-142, Aug. 1990
看原始论文的题目，D.M. Sunday貌似是故意想气气Boyer-Moore两位大牛似的。呵呵。不过实际上的确Sunday算法的确比BM算法要快，而且更简单。
Sunday的算法思想和Horspool有些相似，但是。当出现不匹配的时候，却不是去找匹配串中不匹配的字符在模式串的位置，而是直接找最右边对齐的右一位的那个字符在模式串的位置。
比如：
匹配串：abcbczdxzc
模式串：zbcac
恩，这里我们看到b-a没有对上，我们就看匹配串中的z在模式串的位置，然后，嘿嘿。
匹配串：abcbczdxzc
模式串：zbcac
如果模式串中的没有那个字符怎么办呢？很简单，跳过去呗。
匹配串：abcbcedxzcs
模式串：zbcac
e不在模式串中出现
那么我们就
匹配串：abcbcedxzcs
模式串：zbcac
(2009/10/20补充)
RK算法
某一天在图书馆的一本算法分析设计书上翻到的。思路很新颖！和大家分享下。
在串匹配的简单算法中，把文本每m个字符构成的字符段作为一个字段，和模式进行匹配检查。如果能对一个长度为m的字符
串赋以一个Hash函数。那么显然只有那些与模式具有相同hash函数值的文本中的字符串才有可能与模式匹配，这是必要条件
，而没有必要去考虑文本中所有长度为m的字段，因而大大提高了串匹配的速度。因此RK算法的思想和KMP，BM，Sunday等思
路迥然不同！
(事实上，之前的串匹配方法，是将模式串的一个一个字符作为小的特征去分别进行匹配，而RK算法则是将串整体作为一个
特征！难就难在单个字符的特征很容易想得到，整体作为一个特征就没那么容易想得到了)
如果把整体作为一个特征，那么如何快速的求出这个整体特征的特征值？？
模式串的特征值仅需求一次即可。对于文本中的任意m个字符构成的字串如何快速的求特征就是个难点了。
抛砖引玉，这里给出一个简单的特征计算。 将字符串的每一个字符看做一个数，那么这个字符串的就是一个数字数组，通
过积分向量可以快速任意一个长度子字符串的向量和。可以把字符串的对应的字符数组的元素和看做这个字符串整体特征。
这个特征是可以再O(1)的时间内求出的。其实原始的RK算法里面是把字符串看做一个26进制数在计算特征的。这里就不啰
嗦了，有兴趣的可以深入查找
aabseesds 模式串 ees
ees
发现 see向量和 == ees的向量和
然后就对see和ees做逐个字符的比较。发现不匹配继续往下走
aabseesds 模式串 ees
ees
发现 ees向量和 == ees的向量和
然后就对ees和ees做逐个字符的比较。发现匹配OK。
另外还有 字符串匹配自动机 后缀树算法(分在线和非在线两种)等 见如下文章。不能说那个比那个更好，各个算法都有自己的优势及最佳应用场合。参考：
http://blog.csdn.net/yifan403/archive/2009/06/16/4272793.aspx
另外，关于多模式字符串匹配 有AC算法(字符串匹配自动机思想) WM算法(BM在多模式的推广应用)
参考：
http://blog.csdn.net/ijuliet/category/498465.aspx 该女子的blog有很多好文章。
===============================================================================
一个sunday算法的实现
http://hi.baidu.com/azuryy/blog/item/10d3d3460b97af0e6b63e5cd.html
头文件定义：
class Sunday
{
public:
Sunday();
~Sunday();
public:
int find(const char* pattern, const char* text);
private:
void preCompute(const char* pattern);
private:
//Let's assume all characters are all ASCII
static const int ASSIZE = 128;
int _td[ASSIZE] ;
int _patLength;
int _textLength;
};
源文件
Sunday::Sunday()
{
}
Sunday::~Sunday()
{
}
void Sunday::preCompute(const char* pattern)
{
for(int i = 0; i < ASSIZE; i++ )
_td[i] = _patLength + 1;
const char* p;
for ( p = pattern; *p; p++)
_td[*p] = _patLength - (p - pattern);
}
int Sunday::find(const char* pattern, const char* text)
{
_patLength = strlen( pattern );
_textLength = strlen( text );
if ( _patLength <= 0 || _textLength <= 0)
return -1;
preCompute( pattern );
const char *t, *p, *tx = text;
while (tx + _patLength <= text + _textLength)
{
for (p = pattern, t = tx; *p; ++p, ++t)
{
if (*p != *t)
break;
}
if (*p == 0)
return tx-text;
tx += _td[tx[_patLength]];
}
return -1;
}
简单测试下：
int main()
{
char* text = "blog.csdn,blog.net";
char* pattern = "csdn,blog" ;
Sunday sunday;
printf("The First Occurence at: %d/n",sunday.find(pattern,text));
return 1;
}
strstr的实现。
需要说明的是strstr是c语言提供的使用Brute Force实现的字符串匹配，简单、通用是其最大的优点。时间复杂度是O(mn)
// 下面是Microsoft的实现
//经典算法
//比KMP算法简单,没有KMP算法高效
char * __cdecl strstr (
const char * str1,
const char * str2
)
{
char *cp = (char *) str1;
char *s1, *s2;
if ( !*str2 )
return((char *)str1);
while (*cp)
{
s1 = cp;
s2 = (char *) str2;
while ( *s1 && *s2 && !(*s1-*s2) )
s1++, s2++;
if (!*s2)
return(cp);
cp++;
}
return(NULL);
}
strstr
glibc里的strstr函数用的是brute-force(naive)算法，它与其它算法的区别是strstr不对pattern(needle)进行预处理，所以用起来很方便。理论复杂度O
(mn), 实际上，平均复杂度为O(n), 大部分情况下高度优化的算法性能要优于基于自动机的匹配算法，关于串匹配算法可参考http://www-igm.univ-mlv.fr/~lecroq/string/。 glibc中使用了(1)Stephen R. van den Berg的实现，在他的基础上，(2)Tor Myklebusthttp://sources.redhat.com/ml/libc-alpha/2006-07/msg00028.html给出了更复杂的实现，当然也更高效。
BF有一个重要性质是事先不用知道串的长度，而基于跳跃的算法是需要用字符串长度来判断结束位置的。如何快速的确定字符串结束位置，可参考http://www.cppblog.com/ant/archive/2007/10/12/32886.html，写的很仔细。
将两种思想结合起来，可以做出更快的strstr(3)。约定(1) 为strstrBerg; (2) 为strstrBergo，(3)为lstrstr，(4)为glibc中的strstr，简单测试了一下：
从长度为2k的文本中查找长度为1、2、9的模式串，结果如下
1 2 9
(1)0.000006 0.000006 0.000012
(2)0.000007 0.000004 0.000008
(3)0.000002 0.000002 0.000005
(4)0.000005 0.000005 0.000011
下载strstr和测试程序，
下载后执行 :
unzip testStrstr.zip
cd testStrstr
make test
基于sse2的strstr函数 是用sse2指令集对strstr的优化