KMP 示例

1、问题

检查字符串中是否包含子字符串

    main_string = 'abcxabcdabcdabcy'
    sub_string = 'abcdabcy'

2、关键字实现

方法一、find

    # 关键字 find ，找到返回索引，没找到返回 -1
    print("内置方法，find，索引为：",main_string.find(sub_string))

方法二、index

    # 关键字 index ，找到返回索引，没找到返回 Error,ValueError: substring not found
    try:
        print("内置方法，index，索引为：",main_string.index(sub_string))
    except Exception as e:
        print("内置方法，index未找到，返回异常：",str(e))

3、简单实现方法

特点，简单，低效
核心，按主串字符索引，逐个完整匹配

方法一、暴力递归

def violent_search(main_string,sub_string,index=0):
    '''
      暴力查找，递归
      主字符串、子字符串、当前检索索引，默认为0
    '''
    main_l = len(main_string)
    sub_l = len(sub_string)

    if main_l < sub_l + index:
        return -1
    elif main_string[index:sub_l+index] == sub_string:
        return index
    else:
        index += 1
        return violent_search(main_string,sub_string,index)

print("暴力查找，递归，索引为：",violent_search(main_string,sub_string))

方法二、循环迭代

def violent_search_next(main_string,sub_string):
    '''
      暴力查找，for循环
      主字符串、子字符串
    '''
    main_l = len(main_string)
    sub_l = len(sub_string)

    for i in range(main_l-sub_l+1):
        if main_string[i:sub_l+i] == sub_string:
            return i
    return -1

print("暴力查找，循环，索引为：",violent_search_next(main_string,sub_string))

4、KMP 实现

发现者，D.E.Knuth，J.H.Morris，V.R.Pratt
时间复杂度，O（m+n）
核心，利用匹配失败后的信息，尽量减少模式串与主串的匹配次数以达到快速匹配的目的

步骤一、构建部分匹配表

def kpm_gen_while(substring):
    """
    构造临时数组pnext，用于计算 “部分匹配表”
    """
    index = 0
    m = len(substring)
    pnext = [0]*m
    i = 1
    while i < m:
        if (substring[i] == substring[index]):
            pnext[i] = index + 1
            index += 1
            i += 1
        elif (index!=0):
            index = pnext[index-1]
        else:
            pnext[i] = 0
            i += 1
    return pnext

def kpm_gen_for(substring):
    m = len(substring)
    pnext = [0]*m
    # 首字符前缀和后缀都为空集，共有元素的长度为0，循环从 1 开始
    for i in range(1,m):
        temp = substring[0:i+1]
        # print("判断字符串，",temp)
        for j in range(1,len(temp)):
            # print("前缀，",temp[0:j],"后缀，",temp[-j:])
            if temp[0:j] == temp[-j:]:
                pnext[i] = j
    return pnext

print(kpm_gen_while(sub_string))
print(kpm_gen_for(sub_string))

两种构建方式，区别不大，都是根据子串，计算前缀、后缀，记录基于前缀，后缀中重复最长的字段长度。

例如 "ABCDABD"

"A"的前缀和后缀都为空集，共有元素的长度为0；

"AB"的前缀为[A]，后缀为[B]，共有元素的长度为0；

"ABC"的前缀为[A, AB]，后缀为[BC, C]，共有元素的长度0；

"ABCD"的前缀为[A, AB, ABC]，后缀为[BCD, CD, D]，共有元素的长度为0；

"ABCDA"的前缀为[A, AB, ABC, ABCD]，后缀为[BCDA, CDA, DA, A]，共有元素为"A"，长度为1；

"ABCDAB"的前缀为[A, AB, ABC, ABCD, ABCDA]，后缀为[BCDAB, CDAB, DAB, AB, B]，共有元素为"AB"，长度为2；

"ABCDABD"的前缀为[A, AB, ABC, ABCD, ABCDA, ABCDAB]，后缀为[BCDABD, CDABD, DABD, ABD, BD, D]，共有元素的长度为0。

部分匹配表 即为 0 0 0 0 1 2 0

步骤二、实现比对方法

def kmp_match_for_else(main_string, sub_string): 
    m = len(main_string)
    s = len(sub_string)
    cur = 0     #起始指针cur 
    table = kpm_gen_for(sub_string)
    while cur <= m - s:
        for i in range(s):
            print("当前指针 ",cur,"子字符串中索引 ",i,"主值 ",main_string[i+cur],"辅值 ",sub_string[i])
            if main_string[i+cur] != sub_string[i]:
                cur += max(i - table[i-1], 1)
                break
        else:
            return cur
    return -1

def kmp_match(main_string, sub_string): 
    m = len(main_string)
    s = len(sub_string)
    cur = 0     #起始指针cur 
    table = kpm_gen_for(sub_string)
    while cur <= m - s:
        for i in range(s):
            # print("当前指针 ",cur,"子字符串中索引 ",i,"主值 ",main_string[i+cur],"辅值 ",sub_string[i])
            if main_string[i+cur] != sub_string[i]:
                #根据匹配表,移动多位 ,移动位数 = 已匹配的字符数 - 对应的部分匹配值(最后一次相等的值即，i - 1)
                cur += max(i - table[i-1], 1)
                break
            elif i == s-1:
                # 如果子字符串最后一位也匹配上，返回当前索引
                return cur

    return -1

print("KMP查找，索引为：",kmp_match(main_string,sub_string))

两种写法区别在于第一种使用了 Python 中 for ... else 语法，考虑其他语言可能不支持，第二种使用了常规elif

4、参考资料

KMP算法_百度百科
阮一峰 字符串匹配的KMP算法