在看子串匹配問題的時候，書上的關於KMP的演算法的介紹總是理解不了。看了一遍程式碼總是很快的忘掉，後來決定好好分解一下KMP演算法，算是給自己加深印象。

------------------------- 分割線-----------------------------------------------

在將KMP字串匹配問題的時候，我們先來回顧一下字串匹配的暴力解法：

假設字串str為: "abcgbabcdh",  字串substr為: "abcd"

 從第一個字元開始比較，顯然兩個字串的第一個字元相等（'a'=='a'）,然後比較第二個字元也相等（'b'=='b'）,繼續下去，我們發現第4個字元不相等了（'g'!='d'）,這時候我們讓'g'和字串的開頭'a'比較，若兩者相同，則同時後移一位比較下一個字母，不同則將str中比較的字元後移一位，然後和字串中開始的'a'比較。以此類推....我們可以在str中找到substr字串，並返回字串的位置。

這種暴力搜尋方法很顯然時間複雜度是O(m*n) n,m分別表示str字串和substr字串的長度。m*n的複雜度顯然是比較大的，當m或者n很大的時候，時間開銷會很大。KMP演算法則可以將時間複雜度下降到O(m+n),和O(m*n)相比明顯下降。

KMP演算法和暴力搜尋方法之間的差別在於KMP演算法在出現字串不相等的情況時，不需要返回到字串的開頭重新比較。

如何保證字串不相等的情況出現時，字串不從最開始開始比較呢，這時候臨時陣列就登場了。

書本上總是介紹說是，判斷此時字串中是否有相同字首和字尾，懵逼臉......

看完臨時陣列是如何構造的你應該差不多就知道前後綴問題了。

** 臨時陣列 ** ： 我們假設子串為 'abcabg', 開始時j指向第一個字元，i指向第二個字元(j=0, i=1)。並且令pnext[0] = 0,如下圖所示：

1)  由於substr[j] != substr[i] 並且j=0, 令pnext[i] = 0 , i往後移一位。(步驟1後，j=0， i=2)

2)  由於substr[j] != substr[i] 並且j=0, 令pnext[i] = 0 , i往後移一位。(步驟2後，j=0， i=3)

3)  此時substr[j] == substr[i], 令pnext[i] = j + 1, 並且 i , j 都後移一位。(步驟3後，j=1，i=4) 

這時候我們來看一下臨時陣列的狀態：

4)  substr[j] == substr[i] 還是成立, 令pnext[i] = j+1,  並且i, j都後移一位。(j=2,  i=5)

5)  此時 substr[j] != substr[i]，由於j=2(不為0)，令j = pnext[j-1]  (由於pnext[j-1] = pnext[1] = 0 ==> j=0, 保持 i=5)

6)  substr[j] != substr[i], 並且j=0, 令pnext[i] = 0, 並使i後移一位。(j=0， i=6)

7)  substr[j] == substr[i],  同理pnext[i] = j+1 ,並且i, j都向後移動一位。(j=1， i=7)

8)  substr[j] != substr[i], j != 0, j = pnext[j-1] = pnext[0] = 0。 (j=0, i=7)

9)  substr[j] != substr[i], 且j=0, 令pnext[i] = 0。(此時i到達最後一個位置，並且pnext陣列全部賦值完畢。pnext陣列構造結束)

臨時陣列構造完畢之後，就可以使用 KMP演算法 了。

還是假設 字串str = 'abgabcabgacyf', 子串 substr = 'abcabgac'.

令i指向str的第一個字元，j指向substr第一個字元。KMP演算法的詳細執行步驟如下：

<1> str[i] == substr[j], i = i+1,  j = j+1. (步驟1之後: i=1, j=1)

<2> str[i] == substr[j], i = i+1, j = j+1. (i=2, j=2)

<3> str[i] != substr[j], 此時j != 0, 所以臨時陣列pnext就派上用場了。令 j = pnext[j-1].  （i=2,  j = pnext[2-1] = 0）

如果存在前後綴的話(即pnext[j-1]!=0)，由於此步驟之前的substr與str相同(要不然 j 也不會往後移動了)，這裡舉一個例子幫助理解：

如圖，當i和j位於圖中時刻，字元j與p不相等。(p之前的abcdab肯定和上面相等，要不然j不會移動到字元p上)，按照暴力搜尋的方法是不是要讓j和子串的第一個字元a比較呢。KMP演算法就不需要，我們可以看到子串中p之前的字元存在最大相等前後綴為'ab', 那在下一次比較的時候‘ab’是不是就不用比較了呢。從而直接比較j和c呢？？(如下圖)這就是KMP演算法的精髓所在。

<4> 這時候str[i] != substr[j], 但是和步驟<3>不一樣的是，此時j=0（由於pnext[-1]不存在，j不能等於pnext[j-1]了）。所以子串開頭只能和str中下一個字元比較，即i = i+1。（i=3, j=0）

<5> str[i] == substr[j] ==> i = i+1, j = j+1. (i=4, j=1)

<6> 以此類推。這一過程存在兩種方法中止，即i或者j不能再加1(加1就會發生越界的時候)。假設str的長度為n，substr的長度為m。當j==m時，說明找到了子串，否則沒有找到。

def KMP_algorithm(string, substring):
    '''
    KMP字串匹配的主函式
    若存在字串返回字串在字串中開始的位置下標，或者返回-1
    '''
    pnext = gen_pnext(substring)
    n = len(string)
    m = len(substring)
    i, j = 0, 0
    while (i<n) or (j<m):
        if (string[i]==substring[j]):
            i += 1
            j += 1
        elif (j!=0):
            j = pnext[j-1]
        else:
            i += 1
    if (j == m):
        return i-j
    else:
        return -1
            
    
def gen_pnext(substring):
    """
    構造臨時陣列pnext
    """
    index, m = 0, 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

if __name__ == "__main__":
    string = 'abcxabcdabcdabcy'
    substring = 'abcdabcy'
    out = KMP_algorithm(string, substring)
    print(out)

程式碼結果返回子串開始時的座標位置。

看到這裡如果還是沒有懂得話，那就說明我表述的還不夠好，推薦看看視訊。

快速傳送門：戳我

------------------------- 我是有底線的，結束了 ----------------------------