BF、KMP、BM、Sunday算法讲解
字串的定位操作通常称作串的模式匹配，是各种串处理系统中最重要的操作之一。
事实上也就是从一个母串中查找一模板串，判定是否存在。
现给出四种匹配算法包括BF（即二维循环匹配算法）、KMP、BM、Sunday算法，着重讲KMP算法，其他算法尽量详细讲解，有兴趣的读者可自行查找其它相关资料了解其它算法，当然本文也会推荐一些网址供读者参考。
事实上本博文也是作者阅读了其它博文，然后根据自己的在理解过程中遇到的问题加以阐述，总结而来的，尤其是多次阅读了July的博文。
本文可能会给一部分读者阅读带来不便，所以在本文开始部分就推荐读者相关博文，若读者已经掌握了相关算法，就不要浪费时间继续浏览本博文了，干点其他有意义的事吧：
July博文（强力推荐）http://blog.****.net/v_july_v/article/details/7041827
注：为方面书写，S称作母串，T称作模板串
一、BF：二维循环匹配算法
算法比较简单，不再给予相关解释，直接给出代码，如下：
int Search(const string& S, const string& T) {
int i = ;
int j = ;
while(S[i] != ‘\’ && T[j] != ‘\’) {
if(S[i] == T[j]) {
++ i;
++ j;
} else {
i = i - j + ;
j = ;
}
}
if(T[j] == ‘\’)
return i - j;
return -;
}
从代码可以看出，此算法的时间复杂度为O()，相当耗时，一般不采用此算法。但是读者一
定要明确知道此算法的运行过程，KMP算法就是在此基础上改进而来的。
二、KMP算法
此算法是D.E.Knuth与V.R.Pratt 和J.H.Morris同时发现的，取三人名字首字母便得到了KMP，
也称作为克努特-莫里斯-普拉特操作。此算法的时间复杂度为O(n+m)，n为S的长度，m为T的长
度。
假设S为
BBCABCDABABCDABCDABDE
T为
ABCDABD
如果按照二维匹配算法，那么过程如下：
第一步，从S与T首字符开始匹配
B B C A B C D A B A B C D A B C D A B D E
↨
A B C D A B D
第二步，匹配到此处（为方便说明，省去了不必要的匹配过程）
B B C A B C D A B A B C D A B C D A B D E
↨
A B C D A B D
第三步，根据首字符相匹配可得，可以继续执行T遍历，查找S中的子串
B B C A B C D A B A B C D A B C D A B D E
↨
A B C D A B D
到了此处我们发现出现了不匹配现象，如果按照二维循环匹配算法，那么下一步必然会这样：
（1）
B B C A B C D A B A B C D A B C D A B D E
↨
A B C D A B D
紧接着又会出现不匹配，直到运行到下面的结果：
（2）
B B C A B C D A B A B C D A B C D A B D E
↨
A B C D A B D
让我们算一下，从第三步下标的位置到（2）这一步T的下标共移动了几次呢？？答案是6次
（但愿我没算错）！！如果我们直接从第三步移动到（2）这一步是不是只需要一次就可以了呢
，这样算下去的话,能减少多少不必要的匹配时间！！
因此，KMP算法诞生了，按照以上的步骤（运行到第三步后直接调转到（2）），给出相关代码：
int KMP_Search(const string& S, const string& T) {
int i = ;
int j = -;
int sLen = S.size();
int tLen = T.size();
while(i < sLen && j < tLen) {
if(j == - || S[i] == T[j]) {
++ i;
++ j;
} else {
j = next[j];
}
}
if(j == tLen)
return i - j;
return -;
}
以上代码可以看出，关键的实现在于next数组，所以读者会问next数组里面保存了什么，能
够实现这么强大的功能？？下面将给予解答……
事实上next[k]数组保存了T前k-1位相等的后缀和前缀的最大长度，next[0]为-1。
以T为”ABCDABD”为例，即：
|
k值 |
前缀 |
后缀 |
最长相等的前缀与后缀 |
next[k] |
|
0 |
空 |
空 |
空 |
-1 |
|
1 |
空 |
空 |
空 |
0 |
|
2 |
A |
B |
空 |
0 |
|
3 |
A、AB |
C、BC |
空 |
0 |
|
4 |
A、AB、ABC |
D、CD、BCD |
空 |
0 |
|
5 |
A、AB、ABC、ABCD |
A、DA、CDA、BCDA |
A |
1 |
|
6 |
A、AB、ABC、ABCD、ABCDA |
B、AB、DAB、CDAB、BCDAB |
AB |
2 |
|
7 |
A、AB、ABC、ABCD、ABCDA、ABCDAB |
D、BD、ABD、DABD、CDABD、BCDABD |
空 |
0 |
接着，读者可能会问为什么要保存它？？
不得不说，上述表格中的数据确实说明不了什么，而且还有可能使读者更加困惑，不过没关
系，请耐心继续往下看，一会就会明白了……
借用第三步得到的状态：
B B C A B C D A B A B C D A B C D A B D E
↨
A B C D A B D
S与T分别匹配到A与D处，如果按照二维匹配算法，下一步就会这样：
B B C A B C D A B A B C D A B C D A B D E
↨
A B C D A B D
S的’B’与T的’A’匹配辨别，事实上就是（加重部分）的匹配，
B B C A B C D A B A B C D A B C D A B D E
↨
A B C D A B D
不成功匹配字符串”BCDABA”中的”BCDAB”正好是T中匹配成功的部分，也就是T中
”ABCDAB”的字串，也是”ABCDAB”的一个后缀，这个后缀正在与”ABCDAB”进行匹配，
那么所可能匹配成功的最大长度则是”ABCDAB”删去最后一个字符得到字符串”ABCDA”
的长度，这个串也是”ABCDAB”的一个前缀，这也就是相当于”ABCDAB”的前缀和后缀在
匹配，讲到这里，读者应该似乎明白了点什么吧，上述表格似乎有点说法，是吧？？那么，
接着说，既然是一个字符串的前缀和后缀进行匹配，也就是”BCDAB”和”ABCDA”进行匹配，
即：
B C D A B B C D A B B C D A B
↨ ↨ ↨
A B C D A A B C D A A B C D A
B C D A B B C D A B
↨ ↨
A B C D A A B C D A
其实以上五个匹配过程也可以这样看：
B C D A B C D A B D A B
↨ ↨ ↨
A B C D A A B C D A B C
A B B
↨ ↨
A B A
你发现了什么？？
好吧，那我说一下我的发现：前缀”ABCDA”一直在与后缀”BCDAB”匹配，如果匹配不成功
，那么前缀”ABCDA”的前缀就再与后缀”BCDAB”的后缀继续匹配……所能匹配成功的最大长度
就是这一步：
B C D A B
↨
A B C D A
这一步所得到的最大长度就是1，回到next数组，此时的k值恰好为5，next[5]为1，继续匹
配将会得到：
B C D A B
↨
A B C D A
此时，k为6，next[k]为2！！
讲到这里，不知道读者是否明白？？我已经尽力让读者明白了，如果仍不明白，看来我的表
述能力存在缺陷，有待提高……
总结起来，就是上述表格所描述的那样，T的前k-1位的后缀和前缀一直在匹配。
希望读者能够好好理解一下上述过程，如果实在不理解，可以留言抑或参考推荐的博文。
OK，下一步用代码求解next数组。
void getNext(const string& T) {
next[] = -;
int i = ;
int j = -;
while(T[i] != ‘\’) {
if(j == - || T[i] == T[j]) { // 这个if应该难不倒读者
++ i;
++ j;
next[i] = j;
} else { // 关键在这里，如果不相等，那么j就
j = next[j]; // 必须回退
}
}
}
到了这里，至于代码为什么要这么写需要读者自己独立思考一下了……
至于时间复杂度为什么是O(n+m)就不给予证明了，推荐的July博文有明确证明。
注：n为S长度，m为T长度
下面再给出next数组的优化。
读者可能会问next数组为什么需要优化？？在这里举出一个例子进行说明：
假设母串S为
aaabaaaab
模板串T为
aaaab
当匹配到这里的时候：
a a a b a a a a b
↨
a a a a b
按照上述next数组保存的结果进行匹配，可以发现S[3] != T[3]，那么下一步就需要根据
next[3] = 2进行匹配，然后再根据next[2] = 1进行匹配……直到匹配到T的首字符仍然匹配不
成功为止。那么在求解next数组的时候就可以预判一下，使得在上述匹配不成功的时候直接
滑向首字符，省去不必要的匹配过程。也就是说在S[i] == T[j] 时，当S[i + 1] == T[j + 1] 时，
不需要再和T[j]相比较，而是与T[next[j]]进行比较。那么，next数组求解可以改为下述代码：
void getNextval(const string& T) {
next[] = -;
int i = ;
int j = -;
while(T[i] != ‘\’) {
if(j == - || T[i] == T[j]) {
++ i;
++ j;
// 修改部分如下
if(T[i] != T[j])
next[i] = j;
else next[i] = next[j];
} else {
j = next[j];
}
}
}
ok，整理一下KMP完整代码：
void getNext(const string& T) {
next[] = -;
int i = ;
int j = -;
while(T[i] != ‘\’) {
if(j == - || T[i] == T[j]) {
++ i;
++ j;
next[i] = j;
} else {
j = next[j];
}
}
}
void getNextval(const string& T) {
next[] = -;
int i = ;
int j = -;
while(T[i] != ‘\’) {
if(j == - || T[i] == T[j]) {
++ i;
++ j;
if(T[i] != T[j])
next[i] = j;
else next[i] = next[j];
} else {
j = next[j];
}
}
}
int KMP_Search(const string& S, const string& T) {
int i = ;
int j = -;
int sLen = S.size();
int tLen = T.size();
while(i < sLen && j < tLen) {
if(j == - || S[i] == T[j]) {
++ i;
++ j;
} else {
j = next[j];
}
}
if(j == tLen)
return i - j;
return -;
}
ok， kmp算法介绍完毕，下面介绍BM算法~
三、BM算法
事实上KMP算法并不是最快的匹配算法，BM算法(1977年，Robert S.Boyer和J
Strother Moore提出)要比KMP算法快，它的时间复杂度为O(n)（平均性能为O(n)，
但有时也会达到O(n * m)，而且书写代码要复杂，不细心的读者很容易写错），BM算法
采用从右向左比较的方法，同时应用到了两种启发式规则，即坏字符规则 和好后缀规则 ，
来决定向右跳跃的距离。
例如：
第一步：
A B C D E F G H I
↨
C D E F G F
然后向前匹配：
A B C D E F G H I
↨
C D E F G F
这就是从后往前匹配。
BM算法定义了两种规则：
注：为方面书写，S称作母串，T称作模板串
注：规则读一遍即可，下述图文解释匹配过程可完全解释规则含义。
注：网页上关于BM算法的规则说明原理都是一样的，只不过是表述不同。
A B C D E F G H I
↨
C D E F E F
如上图所示，蓝色字符串“EF”就是好后缀，黄色字符“D”就是坏字符。
1）坏字符规则
在BM算法从右向左扫描的过程中，若发现某个字符x不匹配，则按如下两种情况讨论：
I.如果字符x在T中没有出现，那么从字符x开始的m个文本显然不可能与S在此处的字符
匹配成功，直接全部跳过该区域即可。
II.如果x在T中出现，选择最右该字符进行对齐。
2）好后缀规则
若发现某个字符不匹配的同时，已有部分字符匹配成功，则按如下两种情况讨论：
I.如果在T中其他位置存在与好后缀相同的子串，选择最边右的子串，将S左移使该子
串与好后缀对齐（相当于T右移）。
II.如果在T中任何位置不存在与好后缀相同的字串，查找是T中否存在某一前缀与好后
缀相匹配，如果有选择最长前缀与S对齐，相当于S左移或者T右移；如果不存在，那么直
接跳过该后缀，T的首字符与S好后缀的下一字符对齐。
坏字符规则图文解释：
(1)
A B C D E F G H
↨
H I J K
不匹配，直接跳过，得到：
A B C D E F G H
↨
H I J K
(2)
A B C D E F G
↨
A D D F
字符"D"在T中存在，那么得到：
A B C D E F G
↨
A D D F
好后缀规则图文解释：
(1)
A B C D E F G H I J K
↨
A E F A E F
字符"A"与"D"不匹配，好后缀"EF"在T中存在，那么得到：
A B C D E F G H I J K
↨
A E F A E F
(2)
A B C D E F G H I J K L
↨
F G F A E F G
T中存在前缀“FG”与后缀“FG”相匹配，那么得到：
A B C D E F G H I J K L
↨
F G F A E F G
如果是这样：
A B C D E F G H I J K L M N
↨
F A F A E F G
不存在前缀与任一后缀匹配，那么得到：
A B C D E F G H I J K L M N
↨
F A F A E F G
ok，原理说明完毕，下面就是代码求解：
注：网上诸多作者均给出了详细求解代码，可是求解代码比较晦涩难懂，没有比较好的注释
以帮助读者完全理解，所以在此根据编者自己的理解，给出了晦涩代码段的相关注释。
先给出BM算法的匹配代码：
注：bmG表示好后缀数组，bmB表示坏字符数组
int BM(const string& S, const string& T, int bmG[], int bmB[]) {
int sLen = S.size() - T.size();
int tLen = T.size();
int i = ;
get_bmB(T, bmB);
get_bmG(T, bmG);
while(i <= sLen) {
int j = tLen - ;
// 出现不匹配字符或者匹配成功循环结束
for( ; j > - && S[i + j] == T[j]; --j) ;
// 匹配成功
if(j == -)
return i;
// 选择好后缀与坏字符中移位最大者，tLen - 1 - j表示的是该字符距字符串尾部的距离，bmB[S[i + j]]表示的是该字符
// 出现在T中的最右位置距字符串尾部的距离。
i += max(bmG[j], bmB[S[i + j]] - (tLen - - j));
}
return -;
}
那么，下面就需要求解bmG数组和bmB数组了，由于求解bmG数组比较麻烦，所以先给出
bmB数组的求解代码：
void get_bmB(const string& T, int bmB[]) {
int tLen = T.size();
// MAXSIZE 表示字符种类数目
// 坏字符不存在T中时，直接后移此片段
for(int i = ; i < MAXSIZE; ++ i) {
bmB[i] = tlen;
}
// 坏字符存在T中时，选择T中最右字符存在的位置
for(int i = ; i < tLen; ++i) {
bmB[T[i]] = tLen - - i;
}
}
代码很简单，读者稍加理解应该没问题。
OK，下面给出bmG数组的求解代码：
// bmGLength[i]代表的是T在以该字符为后缀的字符串与T的后缀所能匹配的最大长度
int bmGlength[N];
void get_bmG(const string& T, int bmG[]) {
// 求解好后缀数组那么必先得到匹配不成功处好后缀的长度是多少
get_bmGLength(T, bmGLength);
// 那么按照好后缀的原理，先默认选择匹配不成功之处不存在好后缀的情况
int tLen = T.size();
for(int i = ; i < tLen; ++ i) {
bmG[i] = tLen;
}
// 注：以下代码中i之所以 < tLen - 1是因为下标tLen - 1处不存在好后缀，只有坏字符
// 然后是选择匹配不成功之处T中存在包含该字符的前缀与好后缀相匹配的情况
int j = ;
for(int i = tLen - ; i >= ; -- i) {
// 若存在前缀与后缀相匹配，那么此处所保存的数值必然是i + 1
if(bmGLength[i] == i + ) {
for(; j < tLen - - i; ++ j) {
// 还没有变化过时方可赋值
if(bmG[j] == tLen)
bmG[j] = tLen - - i;
}
}
}
// 最后就是不匹配处T中存在与好后缀相匹配的字符串,选择最右
// 字符串
for(int i = ; i < tLen - ; ++ i) {
bmG[tLen - - bmGLenth[i]] = tLen - - i;
}
}
那么接着给出bmGLength数组的求解代码：
注：代码中有很多地方尤其是数组下标中加了相关括号，这是方便读者理解的地方，希望
读者要稍加注意
void get_bmGLength(const string& T, int bmGLength[]) {
int tLen = T.size();
bmGLength[tLen - ] = tLen;
for(int i = tLen - ; i >= ; -- i) {
int j = i;
while(j >= && T[j] == T[tLen - - (i - j)])
-- j;
bmGLenth[i] = i - j;
}
}
不难发现，此代码的时间复杂度为O(n2)，事实上我们可以优化一下，优化成O(n)，
下见代码：
为方便读者理解，先说一下以下代码的原理：
如果i所到的最远处cur与pre不等，那么就存在最小循环节在[cur, pre]和[cur, tLen - 1]中，
这个最小循环节内部（指除去最右字符剩下的字符）的字符必然不是完全匹配（也就是从此
字符开始与后缀进行匹配，必然匹配不到一个循环节的长度），这些不完全匹配的字符所能
匹配的最大长度在每个循环节中必然相同；而完全匹配的字符（也就是最右字符）所能匹配
的最大长度的差值必然是循环节的整数倍。
不知道这样说对不对，若有不对之处还请读者指正，若在理还请读者细细品味。
这个原理也仅是读者通过代码进行理解而得到的，至于原来最先想出此优化代码的程序员已
不可考，其根本原理也已不可知。
void get_bmGLength(const string& T, int bmGLength[]) {
int tLen = T.size();
bmGLength[tLen - ] = tLen;
int cur = tLen - ; // 保存当前下标i所到的最远位置
int pre; // 保存下标i先前的位置
for(int i = tLen - ; i >= ; -- i) {
// i > cur 是因为i必须要曾经遍历到过下标cur方可
// (tLen - 1 - pre)表示先前i到T尾字符的长度
// bmGLength[i + (tLen - 1 - pre)] < i - cur这个条件为什么要加上，
// 我也不明白，不过去掉这个条件，按照原理是成立的，加上也没有错，给出一个题目链接，读者可以测试一下编者说的是否正确
// http://acm.hdu.edu.cn/showproblem.php?pid=1711
/* 网上源代码：
if(i > cur && bmGLength[i + (tLen - 1 - pre)] < i - cur) {
bmGLength[i] = bmGLength[i + (tLen - 1 - pre)];
continue;
}
*/
// 原理代码：
if(i > cur) {
bmGLength[i] = bmGLength[i + (tLen - - pre)];
continue;
}
// i所到的最远的位置必然是i最小时
cur = min(cur, i);
pre = i;
while(cur >= && T[cur] == T[tLen - - (pre - cur)])
-- cur;
bmGLenth[i] = pre - cur;
}
}
OK，讲解完毕，下面给出BM完整代码：
void get_bmB(const string& T, int bmB[]) {
int tLen = T.size();
for(int i = ; i < MAXSIZE; ++ i) {
bmB[i] = tlen;
}
for(int i = ; i < tLen; ++i) {
bmB[T[i]] = tLen - - i;
}
}
void get_bmGLength(const string& T, int bmGLength[]) {
int tLen = T.size();
bmGLength[tLen - ] = tLen;
for(int i = tLen - ; i >= ; -- i) {
int j = i;
while(j >= && T[j] == T[tLen - - (i - j)])
-- j;
bmGLenth[i] = i - j;
}
}
void get_bmGLength(const string& T, int bmGLength[]) {
int tLen = T.size();
bmGLength[tLen - ] = tLen;
int cur = tLen - ;
int pre;
for(int i = tLen - ; i >= ; -- i) {
/* 网上源代码：
if(i > cur && bmGLength[i + (tLen - 1 - pre)] < i - cur) {
bmGLength[i] = bmGLength[i + (tLen - 1 - pre)];
continue;
}
*/
// 原理代码：
if(i > cur) {
bmGLength[i] = bmGLength[i + (tLen - - pre)];
continue;
}
cur = min(cur, i);
pre = i;
while(cur >= && T[cur] == T[tLen - - (pre - cur)])
-- cur;
bmGLenth[i] = pre - cur;
}
}
int bmGlength[N];
void get_bmG(const string& T, int bmG[]) {
get_bmGLength(T, bmGLength);
int tLen = T.size();
for(int i = ; i < tLen; ++ i) {
bmG[i] = tLen;
}
int j = ;
for(int i = tLen - ; i >= ; -- i) {
if(bmGLength[i] == i + ) {
for(; j < tLen - - i; ++ j) {
if(bmG[j] == tLen)
bmG[j] = tLen - - i;
}
}
}
for(int i = ; i < tLen - ; ++ i) {
bmG[tLen - - bmGLenth[i]] = tLen - - i;
}
}
int BM(const string& S, const string& T, int bmG[], int bmB[]) {
get_bmB(T, bmB);
get_bmG(T, bmG);
int sLen = S.size() - T.size();
int tLen = T.size();
int i = ;
while(i <= sLen) {
int j = tLen - ;
for(; j > - && S[i + j] == T[j]; --j) ;
if(j == -)
return i;
i += max(bmG[j], bmB[S[i + j]] - (tLen - - j));
}
return -;
}
ok，BM算法介绍完毕，下面介绍Sundy算法，最简单的算法。
四、Sunday算法
Sunday算法是Daniel M.Sunday于1990年提出的字符串模式匹配。相对比较KMP和BM
算法而言，简单了许多。
原理与BM算法相仿，有点像其删减版，所以其时间复杂度和BM算法差不多，平均性能的
时间复杂度也为O(n)，最差情况的时间复杂度为O(n * m)，但是要容易理解。
匹配原理：从前往后匹配，如果遇到不匹配情况判断母串S参与匹配的最后一位的下一位字符
，如果该字符出现在模板串T中，选择最右出现的位置进 行对齐；否则直接跳过该匹配区域。
原理看着都这么繁琐，而且难懂，还是给读者上图吧：
母串S：
S E A R C H S U B S T R I N G
模板串T：
S U B S T R I N G
开始匹配：
S E A R C H S U B S T R I N G
↨
S U B S T R I N G
继续下一字符匹配：
S E A R C H S U B S T R I N G
↨
S U B S T R I N G
出现不匹配情况，查找母串参与匹配的最后一位字符的下一字符，上图中S中最后一位参与
匹配的字符是颜色为蓝色的字符’B’，其下一字符为’S’，在T中，字符’S’出现两次，按照原理，
选择最右位置出现的’S’进行对齐，那么可以得到：
S E A R C H S U B S T R I N G
↨
S U B S T R I N G
直接跳过大片区域。
假设母串S为：
S E A R C H S U B Z T R I N G
那么当匹配到上述情况时，字符’Z’在T中没有出现，那么就可以得到下面的情况：
S E A R C H S U B Z T R I N G
↨
S U B S T R I N G
跳过的区域很大吧。
ok，这就是其原理的两种情况，很简单吧，下面给出代码解释：
注：S表示母串，T表示模板串
int moveLength[MAXSIZE]; // 匹配不成功时的移动步长，默认初始化
int Sunday(const string& S, const string &T) {
getMoveLength(T);
int tLen = T.size();
int sLen = S.size();
int i = ; // S遍历下标
while(i < sLen) {
int j = ;
// 符合条件下标就继续右移
for( ; j < tLen && i + j < sLen && S[i + j] == T[j]; ++ j) ;
// 遍历结束，判断遍历情况
if(j >= tLen) return i;
// 查找不成功，那么S下标右移
if(i + tLen >= sLen)
return -;
i += moveLength[S[i + tLen]];
}
return -;
}
匹配过程很简单，相信读者很容易理解。
那么，需要求解moveLength数组，下面给出其求解代码：
int MAXSIZE = ; // 字符串种类数，视情况而定
void getMoveLength(const string &T) {
int tLen = T.size();
// 默认S中的任何字符均不出现在T中，那么每次移动的距离为T的长度 + 1
for(int i = ; i < MAXSIZE; ++ i)
moveLength[i] = tLen + ;
// 查找能够出现在T中的字符，若一个字符出现多次，选择最右位置的字符，所以T的下标遍历从0开始
for(int i = ; T[i]; ++ i)
moveLength[T[i]] = tLen - i;
}
ok,代码解释完毕，非常简单。
下面给出完整代码：
int MAXSIZE = ;
int moveLength[MAXSIZE]; void getMoveLength(const string &T) {
int tLen = T.size();
for(int i = ; i < MAXSIZE; ++ i)
moveLength[i] = tLen + ;
for(int i = ; T[i]; ++ i)
moveLength[T[i]] = tLen - i;
}
int Sunday(const string& S, const string &T) {
getMoveLength(T);
int tLen = T.size();
int sLen = S.size();
int i = ;
while(i < sLen) {
int j = ;
for( ; j < tLen && i + j < sLen && S[i + j] == T[j]; ++ j) ;
if(j >= tLen) return i;
if(i + tLen > sLen)
return -;
i += moveLength[S[i + tLen]];
}
return -;
}
BF、KMP、BM、Sunday算法均介绍完毕，若读者有不明之处抑或博文有误之类，请尽情留言，编者看到后会及时回复及修改博文。
希望读者理解四种算法之后能够自己独立手写其核心代码，对读者加深印象以及其核心原理很有裨益。
最后再次列举推荐博文以及相关书籍（当然也曾读到过一些博文以及书籍，从编者角度来说不易理解，便没有推荐，还望见谅）：
July博文（再次推荐） http://blog.****.net/v_july_v/article/details/7041827
算法导论（第三版），机械工业出版社，Thomas H. Cormen ... 著，殷建平...译
暂时推荐上面比较稀少的博文与书籍，若有读者能够推荐给编者比较好的博文及书籍抑或日后看到，定会添加于上。
2014年11月5日