【M-字符串匹配python实现】：朴素算法、KMP算法

字符串回溯匹配(朴素算法)

算法基本思想：
将搜索词整个后移一位，再从头逐个比较。这样做虽然可行，但是效率很差，因为你要把”搜索位置”移到已经比较过的位置，重比一遍。

'''
Creat by HuangDandan
2018-08-19
[email protected]
字符串匹配朴素算法
算法基本思想：
将搜索词整个后移一位，再从头逐个比较。这样做虽然可行，但是效率很差，因为你要把"搜索位置"移到已经比较过的位置，重比一遍
遇字符不等时将模式串p右移一个字符，再次从p0（重置j = 0 后）开始比较
最坏情况是每趟比较都在最后出现不等，最多比较n－m＋1 趟，总比较次数为m*(n－m＋1)，所以算法时间复杂性为O(m*n)

'''
def nmatching(t, p):
    i, j = 0, 0
    n, m = len(t), len(p)
    while i < n and j < m:
        if t[i] == p[j]:
            i, j = i+1, j+1
        else:
            i, j = i-j+1, 0        #i-j+1是关键，遇字符不等时将模式串t右移一个字符
    if j == m:                     #找到一个匹配，返回索引值
        return i-j
    return -1                       #未找到，返回-1

    # else:
    #     return -1 

t = 'aabaabaabab'
p = 'baab'
print(nmatching(t,p))

KMP算法

基本思想：
当字符不匹配时，你其实知道前面的字符是什么。KMP算法的想法是设法利用这个已知信息，不要把字符串t中的”搜索位置”移回已经比较过的位置，继续把搜索位置向后移。匹配中只做不得不做的字符比较，字符串t搜索位置i不回溯。可以针对搜索词，算出一张《部分匹配表》（Partial Match Table）

KMP算法流程：
假设当前字符串t匹配到 i 位置，模式串P匹配到 j 位置.

1. if j = -1，或者当前字符匹配成功（即t[i] == p[j]），则i，j= i+1, j+1，继续匹配下一个字符；

2. if j != -1，且当前字符匹配失败（即t[i] != p[j]），则 i 不变，j = next[j]。此举意味着失配时，模式串P相对于字符串S向右移动了j - next [j] 位。

   • 上面两个if判断在字符串没有搜索结束前，两个条件必定满足一个，两个条件互为否命题。
   • 当匹配失败时，模式串向右移动的位数为：失配字符所在位置 - 失配字符对应的next 值，即移动的实际位数为：j - next[j]，且此值大于等于1。

pnext 数组各值含义

• pnext 数组各值含义：代表当前字符之前的字符串中，有多大长度的相同前缀后缀。例如next [j] = k，代表j 之前的字符串中有最大长度为k 的相同前缀后缀。（p0p1……pk-1 = pj-kpj-k+1……pj-1）。即：模式串向右移动的位数为：已匹配字符数 - 失配字符的上一位字符所对应的最大长度值
• 某个字符失配时，该字符对应的next 值会告诉你下一步匹配中，模式串应该跳到哪个位置（跳到next [j] 的位置）。
• 如果next [j] 等于0或-1，则跳到模式串的开头字符，若next [j] = k 且 k > 0，代表下次匹配跳到j 之前的某个字符，而不是跳到开头，且具体跳过了k 个字符。
• 具体解释：某个字符失配时，j = next [j]，模式串向右移动的位数为：j - next[j]。换言之，当模式串的后缀pj-k pj-k+1, …, pj-1 跟文本串ti-k ti-k+1, …, ti-1匹配成功，但pj 跟ti匹配失败时，因为next[j] = k，相当于在不包含pj的模式串中有最大长度为k 的相同前缀后缀，即p0 p1 …pk-1 = pj-k pj-k+1…pj-1，故令j = next[j]，从而让模式串右移j - next[j] 位，使得模式串的前缀p0 p1, …, pk-1对应着文本串 si-k si-k+1, …, si-1，而后让pk 跟ti 继续匹配。
  

模式串p中长度最大且相等的前缀和后缀
对于P = p0 p1 …pj-1 pj，寻找模式串p中长度最大且相等的前缀和后缀。如果存在p0 p1 …pk-1 = pj- kpj-k+1…pj-2 pj-1，那么在包含pj-1的模式串中有最大长度为k的相同前缀后缀。以”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；k=1

－　”ABCDAB”的前缀为[A, AB, ABC, ABCD, ABCDA]，后缀为[BCDAB, CDAB, DAB, AB, B]，共有元素为”AB”，长度为2；k=k+1=2

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

结合之前的《最大长度表》和上述结论，进行字符串的匹配。如果给定文本串“BBC ABCDAB ABCDABCDABDE”，和模式串“ABCDABD”，现在要拿模式串去跟文本串匹配，如下图所示：

1. 因为模式串中的字符A跟文本串中的字符B、B、C、空格一开始就不匹配，已经匹配的字符串长度=0，最长长度表为0，next [j] 等于0或-1，模式串p的搜索位置一直停在开头字符处，只需要直接将字符串t的搜索位置i不断的后移移一位即可，直到模式串中的字符A跟文本串的第5个字符A匹配成功
2. 继续往后匹配，当模式串最后一个字符D跟文本串匹配时失配，显而易见，模式串需要向右移动。但向右移动多少位呢？因为此时已经匹配的字符数为6个（ABCDAB），然后根据《最大长度表》可得失配字符D的上一位字符B对应的长度值为2，所以根据之前的结论，可知需要向右移动6 - 2 = 4 位。
3. 模式串向右移动4位后，发现C处再度失配，因为此时已经匹配了2个字符（AB），且上一位字符B对应的最大长度值为0，所以向右移动：2 - 0 =2 位。
4. 继续比较，发现D与C 失配，故向右移动的位数为：已匹配的字符数6减去上一位字符B对应的最大长度2，即向右移动6 - 2 = 4 位。
5. 继续比较，发现匹配成功，过程结束。
   
   next 数组相当于“最大长度值” 整体向右移动一位，然后初始值赋为-1。
   根据《最大长度表》，失配时，模式串向右移动的位数 = 已经匹配的字符数 - 失配字符的上一位字符的最大长度值。而根据《next 数组》，失配时，模式串向右移动的位数 = 失配字符的位置 - 失配字符对应的next 值。其中，从0开始计数时，失配字符的位置 = 已经匹配的字符数（失配字符不计数），而失配字符对应的next 值 = 失配字符的上一位字符的最大长度值，两相比较，结果必然完全一致。

关键：计算pnext表：
递推算法流程：
利用已知pnext[0]= -1 直至pnext[i] 求pnext[i+1] 的算法：
1. 假设pnext [j] = k。
2. 若pk = pj，字符串匹配，则p0… pj-k…pj的最大相同前后缀的长度就是k+1，记入pnext[j+1]， j +1后继续递推（循环)，则pnext[j + 1 ] = pnext [j] + 1 = k + 1
3. 若pk ≠ pj，字符串不匹配，则去寻找长度更短一点的相同前缀后缀。如果此时p[ pnext[k] ] == p[j ]，则pnext[ j + 1 ] = pnext[k] + 1，否则继续递归前缀索引k = pnext[k]，而后重复此过程。 相当于在字符p[j+1]之前不存在长度为k+1的前缀”p0 p1, …, pk-1 pk”跟后缀“pj-k pj-k+1, …, pj-1 pj”相等，那么是否可能存在另一个值t+1 < k+1，使得长度更小的前缀 “p0 p1, …, pt-1 pt” 等于长度更小的后缀 “pj-t pj-t+1, …, pj-1 pj” 呢？如果存在，那么这个t+1 便是pnext[ j+1]的值，此相当于利用已经求得的next 数组（pnext [0, …, k, …, j]）进行P串前缀跟P串后缀的匹配。
5. 若k 值为-1（一定来自pnext），得到p0… pi-k…pi 中最大相同前后缀的长度为0，设pnext [i+1] = 0，将i 值加一后继续递推

关于第三步的递归进一步理解：

• 字符串不匹配，则去寻找长度更短一点的相同前缀后缀。若能在前缀“ p0 pk-1 pk ” 中不断的递归前缀索引k = pnext
  [k]，找到一个字符pk’ 也为D，代表pk’ = pj，且满足p0 pk’-1 pk’ = pj-k’ pj-1
  pj，则最大相同的前缀后缀长度为k’ + 1，从而next [j + 1] = k’ + 1 = pnext [k’ ] +
  1。否则前缀中没有D，则代表没有相同的前缀后缀，pnext [j + 1] = 0。
• 不断递推的过程：开始 j=pnext[j]=k ，也就是说后面将k看作 j ,继续递推，k= pnext[k]。

@python程序程序

'''
Creat by HuangDandan
2018-08-21
[email protected]

字符串匹配KMP算法
思想：

关键：
1-整个KMP的重点就在于当某一个字符与主串不匹配时，我们应该知道j指针要移动到哪？
当匹配失败时，j要移动的下一个位置k。存在着这样的性质：最前面的k个字符和j之前的最后k个字符是一样的。 p[0~k-1] == p[j-k,j-1]
2-怎么求这个（这些）k呢？
根据模式串p 做出pnext 表，即根据j递推计算最长相等前后缀的长度
因为在P的每一个位置都可能发生不匹配，也就是说我们要计算每一个位置j对应的k，
所以用一个列表next来保存,当T[i] != P[j]时，j指针的下一个位置pnext[j]
求pnext 的问题变成对每个i 求p 的（前缀）子串p0…pi-1 的最长相等前后缀的长度。
KMP 提出了一种巧妙的递推算法:
 1. 假设pnext [j] = k。
 2. 若pk = pj，字符串匹配，则p0… pj-k…pj的最大相同前后缀的长度就是k+1，记入pnext[j+1]， j +1后继续递推（循环)，则pnext[j + 1 ] = pnext [j] + 1 = k + 1
 3. 若pk ≠ pj，字符串不匹配，则去寻找长度更短一点的相同前缀后缀。如果此时p[ pnext[k] ] == p[j ]，则pnext[ j + 1 ] =  pnext[k] + 1，否则继续递归前缀索引k = pnext[k]，而后重复此过程。 相当于在字符p[j+1]之前不存在长度为k+1的前缀"p0 p1, …,     pk-1 pk"跟后缀“pj-k pj-k+1, …, pj-1 pj"相等，那么是否可能存在另一个值t+1 <  k+1，使得**长度更小的前缀** “p0 p1, …, pt-1 pt” 等于长度更小的后缀 “pj-t pj-t+1, …, pj-1 pj” 呢？如果存在，那么这个t+1 便是pnext[ j+1]的值，此相当于利用已经求得的next 数组（pnext    [0, ...,    k, ..., j]）进行P串前缀跟P串后缀的匹配。
 5. 若k 值为-1（一定来自pnext），得到p0… pi-k…pi 中最大相同前后缀的长度为0，设pnext [i+1] = 0，将i 值加一后继续递推

时间复杂度：
算法复杂性的关键是循环。注意循环中i 的值递增，但加一的总次数不多于n = len(t)。而且i 递增时j值也递增。另一方面j = pnext[j] 总使j 值减小，但条件保证其值不小于–1，因此j = pnext[j] 的执行次数不会多于j 值递增的次数。循环次数是O(n)，算法复杂性也是O(n)


'''


def matchingKMP(t,p,pnext):     #需要传入一个部分匹配表pnext
    i, j = 0, 0
    n, m = len(t), len(p)
    while i < n and j < m:
        if j == -1 or t[i] == p[j]: #如果j = -1，或者当前字符匹配成功（即S[i] == P[j]），都令i+1，j+1
            i, j = i+1, j+1
        else:                       #如果j != -1，且当前字符匹配失败（即S[i] != P[j]），则令 i 不变，j = next[j] # next[j]即为j所对应的next值
            j = pnext[j]
        if j == m:                  # 找到匹配，返回索引值
            return i - j

    return -1                       # 无法匹配，返回-1

def genPNext0(p):
    j, k, m = 0, -1, len(p)
    pnext = [-1]*m
    while j < m-1:                  #生成pnext
        while k >= 0 and p[j] != p[k]:
            k = pnext[k]            
        j, k = j+1, k+1
        pnext[j] = k                #考虑前面

    return pnext

#生成pnext表，作用：当模式串中的某个字符跟文本串中的某个字符匹配失配时，模式串下一步应该跳到哪个位置
def genPNext(p):                    
    j, k, m = 0, -1, len(p)
    pnext = [-1]*m
    while j < m-1:                  #生成pnext
        while k >= 0 and p[j] != p[k]:
            k = pnext[k]            #设k = pnext[k]
        j, k = j+1, k+1
        if p[j] == p[k]:            #递推过程
            pnext[j] = pnext[k]
        else:
            pnext[j] = k            #next [j] = k 且 k > 0，表示下次匹配跳到j 之前的某个字符，而不是跳到开头，且具体跳过了k 个字符
    return pnext


if __name__ == "__main__":
    t = 'bbc abcdab abcdabdabde'
    p = 'abcdabdab'
    print('------------------------------------')

    print(matchingKMP(t,p,genPNext(p)))

参考博客：
https://www.cnblogs.com/zhangtianq/p/5839909.html
https://www.cnblogs.com/yjiyjige/p/3263858.html