第十一章 串（上）

定义

串匹配

蛮力匹配

def match(t,p):
    # t: 文本串； p: 模式串
    m=len(p)
    n=len(t)
    i=0;j=0
    while i<n and j<m:
        if t[i]==p[j]:
            i+=1; j+=1
        else:
            j=0
            i=i-(j-1)
    return i-j #如果i-j>n-m匹配失败

def match(t,p):
    n,m=len(t),len(p)
    for i in range(n-m+1):
        j=0
        while j<m:
            if t[i+j]==p[j]:
                j+=1
            else:
                break
        if j==m:
            break #匹配成功
    return i

字母表越短，模式串越长，出现最坏情况的可能性越大：

KMP算法

查询表

当文本串和模式串在T[i]和P[j]处匹配失败：
需要找到n[j]，即模式串需要向后滑动多少，这个位置只和模式串有关。

理解next[]表

KMP：使模式串快速的后移，避免许多不必要的比较

KMP的重点就在于当某⼀一个字符与主串串不不匹配时，我们应该知道j指针要移动到哪？

如图：C和D不不匹配了了，我们要把j移动到哪？显然是第1位。为什什么？因为前⾯面有⼀一个A相同：

可以把j指针移动到第2位，因为前⾯面有两个字⺟母是⼀一样的：

构造next[]表

next[j]=k
如果P[k]=P[j]: next[j+1]=next[j]+1

next[j]=k
如果P[k]!=P[j]: k=next[k]

def kmp(t,p):
    next=buildnext(p)
    n,m=len(t),len(p)
    i=0;j=0
    while i<n and j<m:
        if t[i]==p[j] or j<0:
            i+=1; j+=1
        else:
            j=next[j]

    return i-j

def buildnext(p):
    j=0
    m=len(p)
    next=[0]*len(p)
    next[0]=-1
    t=next[0]
    while j<m-1:
        if t<0 or p[j]==p[t]:
            j+=1
            t+=1
            next[j]=t
        else:
            t=next[t]
    return next


next=buildnext("abcdabc")
print (next)
# -1,0,0,0,0,1,2


print (match1("abdcg","dc"))
print (match2("abdcg","dc"))
print (kmp("abdcg","dc"))

KMP复杂度分析