这里写自定义目录标题

• KMP算法中next数组的计算（和前缀表的计算）
• • 基础知识
  • • BF算法
    • KMP算法
  • next数组
  • • 一、前缀表和next数组的关系
    • 二、为什么有些next数组是0,1开头，而有些next数组是-1,0开头
    • 三、如何计算KMP算法中的next数组（附python实现）
    • • 方法一：通过前缀表计算next数组（最易理解）
      • 方法二：直接计算next数组（和方法一没有本质区别）
      • 方法三：动态求解next数组

KMP算法中next数组的计算（和前缀表的计算）

解决问题：

• 前缀表和next数组的关系
• 为什么有些next数组是0,1开头，而有些next数组是-1,0开头
• 如何计算KMP算法中的next数组

注：本文不讲解KMP算法的实现，只涉及next数组的计算

基础知识

• 模式匹配： 从某个字符串中找出与一个给定子串相同的子串的位置。简单说就是从一个字符串中找出是否含有另一个字符串，若存在则返回位置。常用的模式匹配算法有：BF（朴素模式匹配算法或暴力匹配算法）、BM算法、RK算法、KMP算法。

• 主串： 待查找的字符串。

• 模式串（子串）： 模式匹配就是要从主串中找到子串。

• KMP算法： 是一种改进BF算法的模式匹配算法。KMP算法的核心是利用匹配失败后的信息，尽量减少模式串与主串的匹配次数以达到快速匹配的目的。

• 前缀： 字符串的开头，例如字符串abcd的前缀为a, ab, abc, abcd。在KMP算法中使用的前缀为真前缀，既不包括原字符串abcd的前缀。（真前缀：a, ab, abc）

• 后缀： 字符串的结尾，在KMP算法中同样使用的是真后缀。

• 最长公共前后缀： 最长的相等的前缀与后缀，例如字符串ABCxyzABC的最长公共前后缀为ABC

• 前缀表： 存储每一个前缀的最长公共前后缀的长度。

• next数组： KMP算法通过这个数组来决定向右移动几位。每一位记录值的含义是如果在此处失配，模式串向右移动到next值的位置。例如：主串为aabcabcc，模式串为：abab，模式串的next数组计算得-1, 0, 0, 1。若在index=2的字符a处失配，next值为0，将模式串index=0移动到现在的index=2处，再进行匹配。

BF算法

BF算法就是暴力匹配算法，是最好理解的算法。就是对主串一位一位的做判断，匹配失败则将模式串向后移动一位，如下图所示。

由图可见染色的部分有22块，也就是匹配了22次才找到。在极端条件下BF算法要匹配(N-M+1)*M次（其中N为主串长度，M为模式串长度），所以BF算法的时间复杂度为O(M*N)。

KMP算法

KMP算法优化了BM算法，通过一次尽可能多的向右移动来减少匹配次数。KMP算法的时间复杂度只有O(M+N)。

KMP算法利用了最长公共前后缀的值来进行移动，如下图所示：

可以看到，已经匹配过的aba就不用再次进行匹配，而是从index=3的b继续匹配，相较于BF算法节省了大量匹配操作。在KMP算法中，每次移动的位置都由在此处匹配的字符其前缀的最长公共前后缀决定。

next数组

一、前缀表和next数组的关系

前缀表存储每一个前缀的最长公共前后缀的长度，next数组存储的是模式串向右移动到next值的位置，这个值与前缀的最长公共前后缀的长度有关，所以next数组是可以由前缀表生成的。

用前缀表生成一个next数组很容易，将前缀表每一位都向后移动1位（最后一位舍去）并在第一位补一个-1就得到了next数组。

二、为什么有些next数组是0,1开头，而有些next数组是-1,0开头

-1,0开头与0, 1开头的next数组本质是一样的。实际上，以0, 1开头的next数组就是以-1,0开头的next数组每一项加1得到的。出现这种情况的原因在于模式串起始的索引值：在程序中，一个数组的索引的起始值为0；然而在考试和书中给的模式串起始值是多从1开始。所以在考试中遇到的next数组通常是以0, 1开头；而一些程序或教程中的next数组是以-1, 0开头。

注：在考试中通常会给模式串的索引，或者会给next值的前两项，在答题时要按照题目中的要求写next数组。

三、如何计算KMP算法中的next数组（附python实现）

方法一：通过前缀表计算next数组（最易理解）

这种方法计算的是0, 1开头的next数组，如果需要-1, 0开头的next数组，将最后一行对数组每一项都加1的代码删除即可。
具体流程见上前缀表和next数组的关系的第二段

1. 创建前缀表，长度和模式串相同，初值全为0

prefix = [0]*kmp_len

2. 查找最长公共前后缀（傻找就完了）

# 从最长的前后缀开始找，依次找到只有一个字符。
for i in range(1, kmp_len):         # i = 1 to n-1
    # 若模式串为：kkskyyds，i为3（前缀表第4位的值）
    # 则找kksk的最长公共前后缀（通过下面的循环）
    for j in range(i, 0, -1):       # j = i to 1
        # j = 3 --- kks不等于ksk
        # j = 2 --- kk不等于sk
        # j = 1 --- k等于k，最长公共前后缀长度为1，所以prefix[i] = j
        # 假若在j = 1时还找不到最长公共前后缀，则next值不变为0
        str1 = kmp_str[0:j]
        str2 = kmp_str[i-j+1:i+1]
        if str1 == str2:
            prefix[i] = j
            break

3. 计算完前缀表了，现在对前缀表后移1位，再在第一位加一个-1

prefix.insert(0,-1) # 第一项添加-1
prefix.pop(-1)      # 删除最后一项

4. 对数组每一项都加1（若要-1, 0开头的next数组就不需要这行代码）

kmp_next1 = [i+1 for i in prefix]   
# 或者：kmp_next1 = list(map(lambda x:x+1, prefix))

全部代码：

def calc_next(kmp_str, kmp_len):
	prefix = [0]*kmp_len

	for i in range(1, kmp_len):
	    for j in range(i, 0, -1):
	        str1 = kmp_str[0:j]
	        str2 = kmp_str[i-j+1:i+1]
	        if str1 == str2:
	            prefix[i] = j
	            break
	            
	prefix.insert(0,-1)
	prefix.pop(-1)
	kmp_next = [i+1 for i in prefix] 
	# kmp_next = prefix
	return kmp_next

方法二：直接计算next数组（和方法一没有本质区别）

这种方法直接计算next数组（以0, 1开头）。既然方法一中要移位还要添加-1并删除最后一位，可以提前添加好一位，并且不计算最后一位。

1. 创建next数组

# 前两位为[0, 1]，其余位全是1
kmp_next2 = [1]*kmp_len
kmp_next2[0] = 0

2. 找此位置前一个位置的最长公共前后缀（注意找的时候不带当前位置的字符）

for i in range(2, kmp_len):         # i = 2 to n-1
    for j in range(i-1, 0, -1):     # j = i-1 to 0
        # 实际上就是找前一位的最长公共前后缀
        if kmp_str[0:j] == kmp_str[i-j:i]:
            # 这里就是在next的基础上每一项都加1
            kmp_next2[i] = j + kmp_next2[i]
            break

全部代码：

def calc_next(kmp_str, kmp_len):
	kmp_next = [1]*kmp_len
	kmp_next[0] = 0
	
	for i in range(2, kmp_len):
	    for j in range(i-1, 0, -1):
	        if kmp_str[0:j] == kmp_str[i-j:i]:
	            kmp_next[i] = j + kmp_next[i]
	            break
	return kmp_next

方法三：动态求解next数组

借助动态规划的思想，当计算一个字符串的最长公共前后缀时，通过使用已经找好的next表快速计算。
具体流程如下（开头为0, 1的next数组）：

1. 找到要算字符的前一个字符c0的next值对应的字符c1
2. 对比前一个字符c0和对应字符c1
3. 相等，则next值为c0的index值加1；
4. 不相等，则c1的next值对应的字符c2，将c0与c2是否相等。
5. 相等，则next值为c1的index值加1（等价于c0的next值加1）；
6. 不相等，则以此类推找c2的next对应的字符c3，对比c0与c3。注意，当c2的index为1时，结束，c0的next设为1。

例如：设模式串为abaabacd，计算index等于5时的next值

index	1	2	3	4	5	6	7	8
主串	a	b	a	a	b	a	c	d
next数组	0	1	1	2	?

① 找到index = 5 前一个字符，index = 4的字符为a，其next值为2，index = 2对应的字符为b
② 对比 b 和 a 不相等，b的next值为1，，index = 1对应的字符为a
③ 对比 a 和 a 相等，index = 5的next值为b对应的字符a的index值加1，既为1+1=2

总的来说：如果到第一个字符都没有找到相等的字符，则next值设置为1。对比到一个相等的字符，则next值等于此字符的index值+1。

下图是所有next值的对比流程（连线代表两个字符进行对比，字符相等输出右边的next值+1，不相等继续对比，直到找到最左边的字符还不相等next值为1）：

全部代码：

def calc_next(kmp_str, kmp_len):
	kmp_next = [1]*kmp_len
	kmp_next[0] = 0    # next的前两项为0,1
	
	for i in range(2, kmp_len):
	    strCompare0 = kmp_str[i-1]      # 前一个字符
	    n = kmp_next[i-1]               # 前一个字符对应的next值
	    strCompare1 = kmp_str[n-1]      # 对应字符
	    
	    while True:
	        if strCompare0 == strCompare1:
	            kmp_next[i] = n+1
	            break
	        elif n == 1:
	            break
	        else:
	            n = kmp_next[n-1]
	            strCompare1 = kmp_str[n-1]
		return kmp_next