【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 继续匹配。
    【M-字符串匹配python实现】:朴素算法、KMP算法_第1张图片

模式串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”,现在要拿模式串去跟文本串匹配,如下图所示:
【M-字符串匹配python实现】:朴素算法、KMP算法_第2张图片

  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. 继续比较,发现匹配成功,过程结束。
    【M-字符串匹配python实现】:朴素算法、KMP算法_第3张图片
    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

你可能感兴趣的:(【M-字符串匹配python实现】:朴素算法、KMP算法)