kmp演算法實驗報告

㈠ 圖解KMP字元串匹配演算法

kmp演算法跟之前講的bm演算法思想有一定的相似性。之前提到過，bm演算法中有個好後綴的概念，而在kmp中有個好前綴的概念，什麼是好前綴，我們先來看下面這個例子。

觀察上面這個例子，已經匹配的abcde稱為好前綴，a與之後的bcde都不匹配，所以沒有必要再比一次，直接滑動到e之後即可。
  那如果前綴中有互相匹配的字元呢？

觀察上面這個例子，這個時候如果我們直接滑到好前綴之後，則會過度滑動，錯失匹配子串。那我們如何根據好前綴來進行合理滑動？

  其實就是看當前的好前綴的前綴和後綴是否有匹配的，找到最長匹配長度，直接滑動。鑒於不止一次找最長匹配長度，我們完全可以先初始化一個數組，保存在當前好前綴情況下，最長匹配長度是多少，這時候我們的next數組就出來了。

  我們定義一個next數組，表示在當前好前綴下，好前綴的前綴和後綴的最長匹配子串長度，這個最長匹配長度表示這個子串之前已經匹配過匹配了，不需要再次進行匹配，直接從子串的下一個字元開始匹配。

 我們是否每次算next[i]時都需要每一個字元進行匹配，是否可以根據next[i - 1]進行推導以便減少不必要的比較。
  帶著這個思路我們來看看下面的步驟：
  假設next[i - 1] = k - 1;
  如果modelStr[k] = modelStr[i] 則next[i]=k

如果modelStr[k] != modelStr[i]，我們是否可以直接認定next[i] = next[i - 1]？

通過上面這個例子，我們可以很清晰地看到，next[i]!=next[i-1]，那當modelStr[k]!=modelStr[i]時候，我們已知next[0],next[1]…next[i-1]，如何推導出next[i]呢？
  假設modelStr[x…i]是前綴後綴能匹配的最長後綴子串，那麼最長匹配前綴子串為modelStr[0…i-x]

我們在求這個最長匹配串的時候，他的前面的次長匹配串（不包含當前i的），也就是modelStr[x…i-1]在之前應該是已經求解出來了的，因此我們只需要找到這個某一個已經求解的匹配串，假設前綴子串為modelStr[0…i-x-1],後綴子串為modelStr[x…i-1],且modelStr[i-x] == modelStr[i],這個前綴後綴子串即為次前綴子串，加上當前字元即為最長匹配前綴後綴子串。
代碼實現
  首先在kmp演算法中最主要的next數組，這個數組標志著截止到當前下標的最長前綴後綴匹配子串字元個數，kmp演算法裡面，如果某個前綴是好前綴，即與模式串前綴匹配，我們就可以利用一定的技巧不止向前滑動一個字元，具體看前面的講解。我們提前不知道哪些是好前綴，並且匹配過程不止一次，因此我們在最開始調用一個初始化方法，初始化next數組。
  1.如果上一個字元的最長前綴子串的下一個字元==當前字元，上一個字元的最長前綴子串直接加上當前字元即可
  2.如果不等於，需要找到之前存在的最長前綴子串的下一個字元等於當前子串的，然後設置當前字元子串的最長前綴後綴子串

然後開始利用next數組進行匹配，從第一個字元開始匹配進行匹配，找到第一個不匹配的字元，這時候之前的都是匹配的，接下來先判斷是否已經是完全匹配，是直接返回，不是，判斷是否第一個就不匹配，是直接往後面匹配。如果有好前綴，這時候就利用到了next數組，通過next數組知道當前可以從哪個開始匹配，之前的都不用進行匹配。

㈡ 數據結構與演算法——字元串匹配問題(KMP演算法)

KMP演算法也是比較著名的模式匹配演算法。是由 D.E.Knuth,J.H.Morrs 和 VR.Pratt 發表的一個模式匹配演算法。可以大大避免重復遍歷的情況。

如果使用暴風演算法的話，前面五個字母完全相等，直到第六個字母 "f" 和 "x" 不相等。如下圖：

T = 「abcdex」
j 123456
模式串 abcdex
next[j] 011111

T = "abcabx"
j 123456
模式串T abcabx
next[j] 011123

T = "ababaaaba"
j———————123456789
模式串T——— ababaaaba
next[j]————011234223

T = "aaaaaaaab"
j———————123456789
模式串T——— aaaaaaaab
next[j]————012345678

next數組其實就是求解字元串要回溯的位置
假設，主串S= 「abcababca」;模式串T=「abcdex」，由以上分析得出next數組為011111，next數組意味著當主串與模式串不匹配時，都需要從第一個的位置重新比較。

KMP演算法也是有缺陷的，比如主串S=「aaaabcde」,模式串T= 「aaaaax」。next的數組就是012345；

當開始匹配時，當i= 5，j = 5時，我們發現字元"b"與字元「a」不相等，如上圖，j = next[5] = 4;

由於T串的第二、三、四、五位置的字元都與首位「a」相等，那麼可以用首位next[1]的值去取代與它相等的後續字元的next[j],那麼next數組為{0,0,0,0,0,5};

在求解nextVal數組的5種情況

㈢ kmp演算法的優化

KMP演算法是可以被進一步優化的。
我們以一個例子來說明。譬如我們給的P字元串是「abcdaabcab」，經過KMP演算法，應當得到「特徵向量」如下表所示： 下標i 0 1 2 3 4 5 6 7 8 9 p(i) a b c d a a b c a b next[i] -1 0 0 0 0 1 1 2 3 1 但是，如果此時發現p(i) == p(k），那麼應當將相應的next[i]的值更改為next[k]的值。經過優化後可以得到下面的表格： 下標i 0 1 2 3 4 5 6 7 8 9 p(i) a b c d a a b c a b next[i] -1 0 0 0 0 1 1 2 3 1 優化的next[i] -1 0 0 0 -1 1 0 0 3 0 （1）next[0]= -1 意義：任何串的第一個字元的模式值規定為-1。
（2）next[j]= -1 意義：模式串T中下標為j的字元，如果與首字元
相同，且j的前面的1—k個字元與開頭的1—k
個字元不等（或者相等但T[k]==T[j]）（1≤k<j）。
如：T=」abCabCad」 則 next[6]=-1，因T[3]=T[6]
（3）next[j]=k 意義：模式串T中下標為j的字元，如果j的前面k個
字元與開頭的k個字元相等，且T[j] != T[k] （1≤k<j）。
即T[0]T[1]T[2]。。。T[k-1]==
T[j-k]T[j-k+1]T[j-k+2]…T[j-1]
且T[j] != T[k].（1≤k<j）;
(4) next[j]=0 意義：除（1）（2）（3）的其他情況。
補充一個next[]生成代碼： voidgetNext(constchar*pattern,intnext[]){next[0]=-1;intk=-1,j=0;while(pattern[j]!=''){while(k!=-1&&pattern[k]!=pattern[j])k=next[k];++j;++k;if(pattern[k]==pattern[j])next[j]=next[k];elsenext[j]=k;}} PROGRAMImpl_KMP;USESCRT;CONSTMAX_STRLEN=255;VARnext:array[1..MAX_STRLEN]ofinteger;str_s,str_t:string;int_i:integer;Procereget_next(t:string);Varj,k:integer;Beginj:=1;k:=0;whilej<Length(t)dobeginif(k=0)or(t[j]=t[k])thenbeginj:=j+1;k:=k+1;next[j]:=k;endelsek:=next[k];end;End;Functionindex(s:string;t:string):integer;Vari,j:integer;Beginget_next(t);index:=0;i:=1;j:=1;while(i<=Length(s))and(j<=Length(t))dobeginif(j=0)or(s[i]=t[j])thenbegini:=i+1;j:=j+1;endelsej:=next[j];ifj>Length(t)thenindex:=i-Length(t);end;End;BEGINClrScr;{清屏，可不要}Write('s=');Readln(str_s);Write('t=');Readln(str_t);int_i:=index(str_s,str_t);ifint_i<>0thenbeginWriteln('Found''',str_t,'''in''',str_s,'''at',int_i,'.');endelseWriteln('Cannotfind''',str_t,'''in',str_s,'''.');END.index函數用於模式匹配，t是模式串，s是原串。返回模式串的位置，找不到則返回0

㈣ 計算機考研：數據結構常用演算法解析(4)

第四章
KMP演算法和樸素的匹配演算法的關鍵區別就是解決了主串指針i的回溯，原理如下：
設主串S[]和模式串T[],如比較到模式串的第j個字元。 當主串指針i和模式串指針j比較時 ，說明他們前面的所有字元都已經對應相等了。而
Next[j]=k的定義是T1T2…Tk-1==Tj-k+1Tj-k+2….Tj-1且k是最大了，沒有更長的了。
所以Si和Tj比較失敗時Si和Tk去比較。不可能有 這種匹配的成功，因為S2S3…..Si-1= =T2T3……Tj-1,而T2T3….Tj-1是不等於T1T2….Tj-2。除非next[j]=j-1;因為next定義的是最長的。所以任何挪動小於next[j]的串的匹配都是不能成功的。直到Tnext[j]和S[i]相比是才是最早有可能成功的。
Int KMP_Index(Sstring S,Sstring T,int pos)
{
i=pos;j=1;
while(i<=S[0]&&j<=T[0])
{
If(j=0||S[i]=T[j])//j=0表示模式串已經退到起點了說明在這個位置徹底不可能了，
{ ++i; ++j; } //i必須下移,j回到1開始
Else j=next[j];
}
If(j>T[0]) return i-T[0];
Else return 0;
}
求next[j]的方法和原理
設尺肆羨k=next[j];那麼T1T2…Tk-1= =Tj-k+1……Tj-2Tj-1;
若Tj= =Tk,那麼T1T2…Tk-1Tk= =Tj-k+1……Tj-2Tj-1Tj;
所以 next[j+1]=k+1=next[j]+1;且T1T2…Tk-1= =Tj-k+1……Tj-2Tj-1已經是
最長雹弊的序列，所以k+1也是next[j+1]最長的
若Tj不等於Tk,那麼就需要重找了。即…..Tj-1Tj ?,
T1T2….
所以next[j+1]首先=k=next[j]; 即…..Tj-1Tj ?,
T1T2…Tk-1.
若不相等，則next[j+1]=next[k]; 即…..Tj-1Tj ?,
T1T2….Tnext[k]-1
直到找到這樣的序列， 即…..Tj-1Tj ?,
T1T2 ...To
那麼，next[j+1]=next[next[j]]=next[next[next[j]]]…..=o+1;
Void get_next(Sstring T,int next[])
{
i=1; next[1]=0; j=0;//i表示當前求的next
While(i
{
if(j=0 | | T[i]=T[j])
{
++i;
++j;
next[i]=j;
}
Else j=next[j];
}
}
因為 next[ ] 在匹配過程中，若T[ j ]=T[ next[j] ];那麼當 S[i]不等於T[j],
S[ i]肯定也不等於T[k= next[j] ];
所以 S[i]應直接與T[next[k]]比較，而我們通陵拍過將next[j]修正
為nextval[j]=next[next[j]];這樣能使比較更少。
Void get_nextval(Sstring T,int nextval[])
{
i=1; nextval[1]=0; j=0;
while(i
{
if(j=0 || T[i]= T[j])
{
++i;
++j;
if(T[i]!=T[j])
nextval[i]=j;
else
nextval[i]=next[j];
}
else
j=nextval[j];
}
空格串是指__由空格字元(ASCII值32)所組成的字元串，其長度等於 空格個數____。
在模試匹配KMP演算法中所用失敗函數f的定義中，為何要求p1p2……pf(j)為p1p2……pj兩頭匹配的真子串?且為最大真子串?
失敗函數(即next)的值只取決於模式串自身，若第j個字元與主串第i個字元失配時，主串不回溯， 模式串用第k(即next[j])個字元與第i個相比，有『p1…pk-1』=『pj-k+1…pj-1』，為了不因模式串右移與主串第i個字元比較而丟失可能的匹配，對於上式中存在的多個k值，應取其中最大的一個。這樣，因j-k最小，即模式串向右滑動的位數最小，避免因右移造成的可能匹配的丟失。
第4章節有關數據結構演算法，上文中為大家作了分析，希望考生對於這些演算法能夠熟記於心，方便考試的應用和日後的實際操作，預祝大家都能夠取得好成績，加油!

更多詳情請點擊：計算機考研：數據結構常用演算法解析匯總

考研有疑問、不知道如何總結考研考點內容、不清楚考研報名當地政策，點擊底部咨詢官網，免費領取復習資料：https://www.87dh.com/xl/

㈤ 數據結構-串的模式匹配

串的模式匹配就是子串定位操作。給定兩明虧個串s="s0 s1 ... s(n-1)"和t="t0 t1 ... t(m-1)"（其中n和m分別是串s和t的長度），在主串s中尋找子串t的過程稱為模式匹配，t稱為模式。如果在s中找到等於t的子串，則稱匹配成功，返回t在s中的首次出現的下標位置；否則匹配失敗，返回-1。

本文介紹三個串模式匹配演算法，分別是簡單回溯演算法（Brute-Force，BF演算法）、KMP演算法、KMP演算法的改進。

從主串s的第0個字元開始，與模式串t的第0個字元開始逐字元比較，不相同時回溯到模式串t的第0個和主串s的第1個字元，重新開始比較。以此類推，直到t的所有字元完成匹配，則匹配成功，否則匹配失敗。

BF演算法速度慢的原因是存在大量不必要的回溯，即在某一趟與t的匹配過程失敗後，需要返回s串開始字元的下一字元重新開始比較，這對於某些模式串t來說是不必要的。例如，若s=12123123132，t=12313，在t與12 12312 3132中加粗子序列進行比較時，在 2 處發生失配，BF演算法接下來將t與121 23123 132、1212 31231 32、12123 12313 2比較。由於t中的231、312與其開始的123並不相同，顯然t與121 23123 132、1212 31231 32的比較是不必要的。

KMP演算法就是利用模式串中與模式串開頭部分子串的重復性來減少重復回溯，實現新一輪比較的直接跳轉。 具體來說，KMP演算法利用一個數組記錄模式串中每一個字元前面有幾個字元與模式串從頭重復，在與s串比較失配時，直接跳轉到重復子串的下一個字元繼續比較，而不用跳轉至模式串t的第0個字元。

演算法步驟： ①計算跳轉數組next。②利用KMP演算法進行模式匹配。

next數組通過遞推計算，即如果當前字元 t[j] 的前一個字元 t[j-1] 與其 next[j-1] 指向的字元 t[next[j-1]] 相同，意味著 t[j] 前的 next[j-1]+1 個字元與從 t[0] 到 t[next[j-1]] 的子串相同，因此 next[j]=next[j-1]+1 ；如果不相同，則遞推至 t[next[j-1]] 的next值指向的字元，與 t[j-1] 比較，直到確認 t[j] 前與 t 串從頭重復的數羨字元數，或者無重復字元標記為薯槐拍 0 。

注意此處的函數返回參數類型為int*，用於 返回一位數組 ，且返回的這個一位數組必須在函數中用static定義。

KMP演算法進行模式匹配時，只需在回溯時將 j 指針賦值為 next[j] 。需要注意的是，若 next[j] 為 -1 ，則意味著 t[j] 前面沒有與 t 從頭重復的字元，且 t[j] 與 s[i] 失配，則 i 和 j 均加 1 。

考慮更特殊的模式串，還能進一步減少不必要的回溯次數。例如，s=111211112，t=11112，按照上述next的計算方式，next={-1,0,1,2,3}。當 i=3, j=3 時失配，此時 s[i]=2, t[j]=1 ，由於 next[j]=2 ，於是 j 跳轉為 2 ，t=11 1 12與s=111 2 11112比較。由於 t[next[j]]=t[j] 也為 1 ，必然與 s[i]=2 不相同，顯然這次回溯也不必要。

總結來說， 當失配的字元與待跳轉的字元相同時，跳轉一步並無意義，可再跳一步 ，即將當前字元置為跳轉後字元的next值。

㈥ 演算法-KMP

大一下參加學校ACM預備隊集訓的時候首次接觸KMP演算法，當時看了很多介紹文章，仍然不是很理解其實質，只是簡單地套模板AC題目，待大二數據結構與演算法課堂上再聽老師介紹一次，才恍然大悟其實KMP也就是那麼回事嘛。但當初為啥看那麼多文章都沒弄明白呢？正巧最近和朋友聊天時他告訴我他對KMP不是很理解，於是打算自己寫一篇文章，鞏固自己對KMP的認識，也希望能夠幫助更多朋友理解KMP。
在開始之前，需要知曉的概念：

前綴：以原串串頭為自身串頭的子串，如 的前綴有：
後綴：以原串串尾為自身串尾的子串，如 的後綴有：

注意：字元串前後綴都不包括該串本身

給你一個文本串T(Text String)

再給你一個模式串P(Pattern String)

問該模式串是否在文本串中，怎麼找？

一開始只好分別從文本串與模式串的串頭開始逐字母比較

二者相同，再比較T串與P串的下一位

如此反復

如果一直這么順利，兩串對應位置的字元總相同，待P串中最後一個字元也匹配完畢，說明該模式串在文本串中存在，耶( •̀ ω •́ )y超開心，查找結束。但，大多數匹配過程不會如此順利，在該例中，當匹配進行至

很明顯，失配了。現在怎麼辦？按樸素思想，將P串相對T串整體右移一位，重新開始匹配，即

但這種演算法效率無疑是十分低下的。設T串長度N，P串長度M，則樸素演算法時間復雜度為O(MN)

已知的重要信息並沒有被使用——已匹配的字元串前綴

在上例中，當P串最後一個字元匹配失敗時，其已有包含七個字元的 前綴子串S 匹配成功

完全可以利用前綴子串S做點什麼。觀察到在S串

中，有相同前後綴，即下圖藍色部分

而S串各字元又與T串中對應字元相同，即有

當失配發生後，直接將P串右移四位使S串藍色後綴部分對齊T串中藍色前綴部分

從圖中紅框部分繼續嘗試匹配，發現再次失配。這次，已匹配成功的前綴串S為

而在該串中沒有相同的前後綴，只能將P串串頭移至失配處進行比較

再次失配。此時前綴串S為空串，只好如樸素演算法般將P串整體右移一位，重新開始比較

匹配成功。於是又按照之前的步驟往下匹配，直至再次失配或匹配成功

後續步驟同上，不再贅述

上述示例已展現，KMP演算法的精髓在於對已匹配成功的前綴串S的利用

在樸素演算法中，匹配失敗了，T串待匹配字元會回溯

T串原本已匹配至T[7] = 'X'，但是因為失配，需回溯到T[1] = 'b'重新開始匹配

而在KMP演算法中，若P[M]與T[K]匹配失敗，K不會回溯。既然匹配過程是從T[0]開始逐漸向右進行的，至T[K]失配發生時，T[0]至T[K-1]早已匹配過，何必再回溯過去重復匹配呢？於是乎，就如問題引入部分展示般

每當失配發生，我們總是去關注P串中已匹配成功的前綴串S

因為該前綴串是匹配成功的，說明在T串中必定存在與該前綴串相同的子串，記為S'

若S串中存在相同前後綴

則S'串必然也存在此相同前後綴

所以只需將P串右移四位，使得S串的該相同前綴對齊S'串的該相同後綴

再嘗試比較T[7]與P[3]

至於T[7]與P[3]是否能夠匹配另說（當然，本例中一看就知道沒匹配上），但通過對前綴串S的利用，成功省去了P串右移一位、兩位和三位後的無效匹配

繼續深入思考，給定一個具體的P串，其第N位的前綴串S內容是固定的，則S是否存在相同前後綴、相同前後綴的長度與內容也是確定的。換言之，對於一個具體的P串，當其與給定T串匹配至P[N]失配，P串應右移幾位再次與T串進行匹配也是確定的。我們完全可以使用一個數組記錄當P[N]失配後，應當使用N之前的哪一位再來與T串進行匹配，以此提高匹配效率，記該數組為Next數組

定義Next[i] = j表示當P串中第i位失配後，跳轉至P串第j位再次嘗試匹配

還是以之前的P串為例，它的Next數組求出來應為

取下標5為例，其前綴串為

最長相同前後綴為

若P[5]失配，應跳轉至P[1]再次嘗試匹配（最長相同前綴對應P[0]，則取其後一位P[1]，若存在多位，則取最後一位的下一位），P[5]的前一個字元P[4]對應字元'a'，而P[1]前一個字元P[0]同對應字元'a'，保證了P[1]之前字元與T串中對應字元保持匹配。所以Next[5] = 1，其餘下標對應Next數組值同如此求。

特別地，規定Next[0] = -1。而對於除下標0外的任意下標N，Next[N]的含義是 前N-1個已匹配成功的字元構成的前綴串S中，最長相同前後綴長度。 所以若在下標為N處匹配失敗了，則應前往Next[N]所對應的下標處匹配。

具體地，以下圖所示為例，P[6]與T[6]失配

而Next[6] = 2，所以使用P[2]再次嘗試與T[6]進行匹配

當求出P串Next數組後，便可快速進行與T串的匹配

現在問題只剩下如何求Next數組，注意到Next數組既然只與P串本身相關，與文本串T無關，故令P串與自身匹配即可求得

考慮字元串

其Next數組應為

令其與給定文本串相匹配

當匹配進行至

失配，於是跳轉至P[Next[3]] = P[1]處再次嘗試匹配

再度失配，也必然失配

問題在於不該出現P[N] =P[Next[N]]

若P[N] =P[Next[N]]，則P[N]失配後使用P[Next[N]]再次嘗試匹配，由於P[N] =P[Next[N]]，P[N]匹配失敗，P[Next[N]]必然也失敗

因此，若出現P[N] =P[Next[N]]情況，則令Next[N]=Next[Next[N]]

本例中該字元串新Next數組為

當匹配進行至

失配，於是跳轉至P[Next[3]] = P[0]處再次嘗試匹配

省去了之前跳轉至P[1]處的無效匹配

設T串長度M，P串長度N，由於KMP演算法不會回溯，分析易知時間復雜度為O(m+n)

對於P[N]，若其前綴串S含相同前後綴F，且F長度為n（n>1），Next[N]可以取1至n中任意值，為最大化匹配效率考慮，總是取最大相同前後綴以提高效率，節省時間

㈦ KMP模式匹配演算法是什麼

KMP模式匹配演算法是一種改進演算法，是由D.E.Knuth、J.H.Morris和v.R.Pratt提出來的，因此人們稱它為「克努特－莫里斯－普拉特操作」，簡稱KMP演算法。此演算法可以在O（n＋m）的時間數量級上完成串的模式匹配操作。其改進在於：每當一趟匹配過程出現字元不相等時，主串指針i不用回溯，而是利用已經得到的「部分匹配」結果，將模式串的指針j向右「滑動」盡可能遠的一段距離後，繼續進行比較。

1.KMP模式匹配演算法分析回顧圖4－5所示的匹配過程示例，在第三趟匹配中，當i＝7、j＝5字元比較不等時，又從i＝4、j＝1重新開始比較。然而，經仔細觀察發現，i＝4和j＝1、i＝5和j＝1以及i＝6和j＝1這三次比較都是不必進行的。因為從第三趟部分匹配的結果就可得出，主串中的第4、5和6個字元必然是b、c和a（即模式串第2、第2和第4個字元）。因為模式中的第一個字元是a，因此它無須再和這三個字元進行比較，而僅需將模式向右滑動2個字元的位置進行i＝7、j＝2時的字元比較即可。同理，在第一趟匹配中出現字元不等時，僅需將模式串向右移動兩個字元的位置繼續進行i＝2、j＝1時的字元比較。由此，在整個匹配過程中，i指針沒有回溯，如圖1所示。

圖1改進演算法的模式匹配過程示意

㈧ kmp演算法詳解

KMP模式匹配演算法
KMP演算法是一種改進的字元串匹配演算法,其關鍵是利用匹配失敗後的信息,盡量減少模式串與主串的匹配次數以達到快速匹配的目的明[4]。
求得模式的特徵向量之後，基於特徵分析的快速模式匹配演算法(KMP模式匹配演算法)與樸素匹配演算法類似，只是在每次匹配過程中發生某次失配時，不再單純地把模式後移一位，而是根據當前字元的特徵數來決定模式右移的位數[3]。
include "string. h"

#include<assert. h>

int KMPStrMatching(String T, String P, int. N, int startIndex)

{int lastIndex=T.strlen() -P.strlen();

if((1 astIndex- startIndex)<0)//若 startIndex過大,則無法匹配成功

return (-1);//指向P內部字元的游標

int i;//指向T內部字元的游標

int j=0;//指向P內部字元的游標

for(i= startIndex; i <T.strlen(); i++)

{while(P[j]!=T[i]&& j>0)

j=N[j-1];

if(P[j]==T[i])

j++;

if(j ==P.strlen())

return(1-j+1);//匹配成功,返回該T子串的開始位置

}

return (-1);

}