『壹』 急！！急！！急！！數據結構（C語言版）程序設計題： 使用KMP演算法實現一個模式匹配。
#include <cstring>
#include <iostream>
using namespace std;
//修正後的求next數組各值的函數代碼
void get_nextval(char const* ptrn, int plen, int* nextval)
{
int i = 0; //i是從0開始的
nextval[i] = -1;
int j = -1;
while( i < plen-1 )
{
if( j == -1 || ptrn[i] == ptrn[j] ) //循環的if部分
{
++i;
++j;
if( ptrn[i] != ptrn[j] ) //++i，++j之後，再次判斷ptrn[i]與ptrn[j]的關系
nextval[i] = j;
else
nextval[i] = nextval[j];
}
else //循環的else部分
j = nextval[j];
}
}
void print_progress(char const* src, int src_index, char const* pstr, int pstr_index)
{
cout<<src_index<<"\t"<<src<<endl;
cout<<pstr_index<<"\t";
for( int i = 0; i < src_index-pstr_index; ++i )
cout<<" ";
cout<<pstr<<endl;
cout<<endl;
}
//int kmp_seach(char const*, int, char const*, int, int const*, int pos) KMP模式匹配函數
//輸入：src, slen主串
//輸入：patn, plen模式串
//輸入：nextval KMP演算法中的next函數值數組
int kmp_search(char const* src, int slen, char const* patn, int plen, int const* nextval, int pos)
{
int i = pos;
int j = 0;
while ( i < slen && j < plen )
{
if( j == -1 || src[i] == patn[j] )
{
++i;
++j;
}
else
{
j = nextval[j];
//當匹配失敗的時候直接用p[j_next]與s[i]比較，
//下面闡述怎麼求這個值，即匹配失效後下一次匹配的位置
}
}
if( j >= plen )
return i-plen;
else
return -1;
}
int main()
{
std::string src = "";
std::string prn = "abac";
int* nextval = new int[prn.size()];
//int* next = new int[prn.size()];
get_nextval(prn.data(), prn.size(), nextval);
//get_next(prn.data(), prn.size(), next);
for( int i = 0; i < prn.size(); ++i )
cout<<nextval[i]<<"\t";
cout<<endl;
cout<<"result sub str: "<<src.substr( kmp_search(src.data(), src.size(), prn.data(), prn.size(), nextval, 0) )<<endl;
system("pause");
delete[] nextval;
return 0;
}
望樓主採納！
『貳』 kmp 演算法原理
樸素演算法
先看看最「樸素」的演算法： ///find a template in a string. #include<string.h> #include<stdio.h> int Index(char *S, char *T, int pos) { int k=pos, j=0; while(k <strlen(S) && j<strlen(T))//未超出字元串的長度 { if (S[k] == T[j]) { ++k; ++j;} //如果相同，則繼續向後比較 else {k = k-j+1; j =0;} //如果不同，就回溯，重新查找 } if (j == strlen(T)) return k-strlen（T）; else return 0; }
編輯本段KMP演算法
一種由Knuth(D.E.Knuth)、Morris(J.H.Morris)和Pratt(V.R.Pratt)三人設計的線性時間字元串匹配演算法。這個演算法不用計算變遷函數δ，匹配時間為Θ(n)，只用到輔助函數π[1，m]，它是在Θ(m)時間內，根據模式預先計算出來的。數組π使得我們可以按需要，「現場」有效的計算(在平攤意義上來說)變遷函數δ。粗略地說，對任意狀態q=0，1，…，m和任意字元a∈Σ，π[q]的值包含了與a無關但在計算δ(q，a)時需要的信息。由於數組π只有m個元素，而δ有Θ(m∣Σ∣)個值，所以通過預先計算π而不是δ，使得時間減少了一個Σ因子。[1] KMP演算法是通過分析子串，預先計算每個位置發生不匹配的時候，所需GOTO的下一個比較位置，整理出來一個next數組，然後在上面的演算法中使用。
編輯本段KMP演算法的講解
當我們分析一個子串時，例如：abcabcddes. 需要分析一下，每個字元x前面最多有多少個連續的字元和字元串從初始位置開始的字元匹配。然後+1就行了（別忘了，我們的字元串都是從索引1開始的）當然，不要相同位置自己匹配，默認第一個字元的匹配數是0。
編輯本段定義
設字元串為 x1x2x3...xn ,其中x1，x2，x3，... xi，... xn均是字元，設ai為字元xi對應的整數。則a=m，當且僅當滿足如下條件：字元串x1x2...xm equals 字元串x(i-m+1)...xi-1 xi 並且x1x2...xm x(m+1) unequals x(i-m) x(i-m+1)...xi-1 xi。
編輯本段舉例
abcabcddes 0111234111 |----------------------默認是0 --| | |-----------------不能自己在相同位置進行字元匹配，所以這里認為沒有匹配字元串，所以0+1 =1，繼續從1開始匹配 ------| | |-----------前面的字元和開始位置的字元相同，所以是2,3,4 -----------| | | |-------不匹配只能取1。 希望能明白的是，如果開始字元是 Ch1的話，那麼我們就是要在串中第2個Ch1後面的位置開始自己和自己匹配，計算最大的吻合度。 程序寫出來就是： void GetNext(char* T, int *next) { int k=1,j=0; next[1]=0; while( k〈 T[0] ){ if (j ==0 || T[k] == T[j]) { ++k; ++j; next[k] = j; } else j= next[j]; } } 但是這個不是最優的，因為他沒有考慮aaaaaaaaaaaaaaaaaaab的情況，這樣前面會出現大量的1，這樣的演算法復雜度已經和最初的樸素演算法沒有區別了。所以稍微改動一下： void GetNextEx(char *T, char *next) { int k=1,j=0; next[1] = 0; while(k < T[0]) { if (j == 0 || T[k] == T[j]) { ++k; ++j; if (T[k] == T[j]) next[k] = next[j]; else next[k] = j; } else j = next[j]; } } 現在我們已經可以得到這個next字元串的值了，接下來就是KMP演算法的本體了： 相當簡單： int KMP(char* S, char* T, int pos) { int k=pos, j=1; while (k){ if (S[k] == T[j]){ ++k; ++j; } else j = next[j]; } if (j>T[0]) return k-T[0]; else return 0; } 和樸素演算法相比，只是修改一句話而已，但是演算法復雜度從O(m*n) 變成了：O(m)
編輯本段KMP演算法的偽代碼
KMP-MATCHER(T，P) 1n ← length[T] 2m ←length[P] 3π ← COMPUTE-PREFIX-FUNCTION(P) 4q ← 0△Number of characters matched. 5for i ← 1 to n△Scan the text from left to right. 6do while q>0 and P[q+1]≠T[i] 7do q ← π[q]△Next character does not match. 8if P[q+1]=T[i] 9then q ← q+1△Next character matches. 10if q=m△Is all of P matched? 11then print 「Pattern occurs with shift」 i-m 12q ← π[q]△Look for the next match. COMPUTE-PERFIX-FUNCTION(P) 1m ← length[P] 2π[1] ← 0 3k ← 0 4for q ← 2 to m 5do while k>0 and P[k+1]≠P[q] 6do k ← π[k] 7if P[k+1]=P[q] 8then k ← k+1 9π[q] ← k 10return π[1]
編輯本段KMP演算法的c++實現
//c++實現的KMP演算法，所有涉及字元串，其初始下標從0開始(上述演算法均是從1開始) //example: char s[100],t[100];cin>>s>>t;KMP(s,t); //獲取待查詢模式的next數組 int* get_next(char* T, int* next){ int i = 0, j = -1; int length = strlen(T); int *temp = next; *next = -1; while(i< length){ if(j==-1 || *(T+i)==*(T+j)){ i++; j++; //優化後的get_next方法，可以防止出現形如"aaaaab"這種模式的計算退化 if(*(T+i)!=*(T+j)) *(next+i)=j; else *(next+i)=*(next+j); } else j=*(next+j); } return temp; } //KMP演算法 int KMP(char *S, char *T){ int S_Length = strlen(S); int T_Length = strlen(T); //若模式長度大於字元串，則直接返回查詢失敗 if( S_Length < T_Length) return 0; int i = 0, j = 0; int* next = new int[T_Length]; get_next(T, next); while(i < S_Length && j < T_Length){ if(j == -1 || *(S+i) == *(T+j)){ i++; j++; } else j=*(next+j); } if(j>=T_Length) return i-T_Length; return 0; } 在此提供一個更簡明的適用於字元串的kmp實現： #include<iostream> #include<string.h> int next[100]; void getnext(char b[]) { int i=1,j=0; //i是每個位子，j是回退的位子 next[1]=0; while(i<=strlen(b)) { if(j==0||b[i-1]==b[j-1]) { i++; j++; next[i]=j; } else j=next[j]; //用上一個的 回退關系 } } int kmp(char a[],char b[]) { int i=1,j=1; //i是主串中的位子 ，j匹配串的位子 while(i<=strlen(a)&&j<=strlen(b)) { if(j==0||a[i-1]==b[j-1]) { i++; j++; } else j=next[j]; } if(j>strlen(b)) return i-strlen(b); else return 0; } int main() { char a[40],b[40]; printf("要匹配的主串：\n"); scanf("%s",a); printf("要匹配的子串：\n"); scanf("%s",b); getnext(b); printf("輸出next值：\n"); for(int i=1;i<=strlen(b);i++) printf("%d ",next[i]); printf("\n"); printf("%d",kmp(a,b)); system("pause"); main(); return 0; }
編輯本段串的最大匹配演算法
摘要：
給定兩個串S和T，長分別m和n，本文給出了一個找出二串間最大匹配的演算法。該演算法可用於比較兩個串S和T的相似程度，它與串的模式匹配有別。
關鍵詞：
模式匹配 串的最大匹配 演算法 Algorithm on Maximal Matching of Strings Lin YuCai Xiang YongHong Zhang ChunXia Zhang JianJun （Computer Science Department of Yunnan Normal University Kunming 650092） ABSTRACT Given Two Strings S of length m and T of length n，the paper presents an algorithm which finds the maximal matching of them. The algorithm can be used to compare the similarility of the two strings S and T, it is different with the strings' pattren matching. KEY WORDS Pattern Matching Maximal Matching of Strings Algorithm
編輯本段問題的提出
字元串的模式匹配主要用於文本處理，例如文本編輯。文本數據的存儲（文本壓縮）和數據檢索系統。所謂字元串的模式匹配[2]，就是給定兩個字元串S和T，長度分別為m和n，找出T中出現的一個或多個或所有的S，在這方面已經取得了不少進展[3][4][5][6][7][8][9][10][11]。本文從文本處理的另一個角度出發，找出兩個串的最大匹配，比較其相似程度[1]。它主要應用於文本比較，特別是在計算機輔助教學中。顯然前者要找S的完全匹配，而後者並無此要求。例如，若S=ABCD，T=EFABCDX，那麼模式匹配的結果就是找出了T中的一個ABCD，而我們演算法的結果就是S能與T的ABCD完全匹配，但是T中還有3個字元是比S多出來的，也就是說在S中有100%的字元與T中的匹配，而在T中有57%的字元與S中的匹配。若S= ABCDFE，T=AFXBECDY。則在模式匹配中S與T無匹配項，但在我們的演算法中就能發現T中存在A，B，C，D，但D後不存在E，F。而且S中也存在A，B，C，D，且具有順序性。這樣就能公正地評價S，T的區別。得知其相似程度。 文章的組織如下：首先介紹基本定義和問題的描述；第三節是演算法設計；最後是本文總結。
編輯本段問題的描述
設∑為任意有限集，其元稱為字元，w：∑→N為∑到N的函數，稱為∑的權函數（註：本文僅討論權值恆為1的情況）。∑*為∑上的有限字元串集合，那麼對任意S，T∈∑*，設S=a1a2…am，T=b1b2…bn，m>0，n>0。記<m>={1,2, …,m},<n>={1,2, …,n}，則稱{(i,j)∣i∈<m>，j∈<n>，ai=bj}為S與T的匹配關系集，記作M（S，T），稱M為S與T的一個（容許）匹配，若對任意（i,j）, ( i',j' )∈，① i< i'，當且僅當j< j'，② i= i'當且僅當j= j'。S與T的匹配中滿足 最大者，稱為S與T的最大匹配。若C(i,j)為N上的m×n矩陣，且滿足： 則稱矩陣C為串S與T的匹配關系陣。 於是求串S與T的最大匹配，等價於求C中的一個最大獨立點集M，它滿足，若ci,j，ci',j'∈M，則i< i' 當且僅當j< j'，i=i'當且僅當j=j'。我們稱這樣的最大獨立點集為C的最大C-獨立點集。 例：設∑為所有字母的集合，對任意x∈∑，w（x）≡1，設S與T分別為：S=「BOOKNEWS」，T=「NEWBOOKS」。則我們可以得到S與T兩個匹配： 這里=5； 這里 =4。 顯然為串S與T的最大匹配。 S與T的匹配關系陣C可表示如下： 其中帶圈的部分為一最大C-獨立點集。
編輯本段演算法設計
我們僅就權值為一的情況進行討論。 設S和T為任意給定串，C為的S與T匹配關系陣，那麼由2的討論知，求S與T的最大匹配問題，等價於求C的最大C-獨立點集問題。因而，為了解決我們的問題，只要給出求C的最大C-獨立點集的演算法就可以了。 顯然，為了求出C的最大C-獨立點集，我們可以採用這樣的方法：搜索C的所有C-獨立點集，並找出它的最大者。這種方法是可行的，但並不是非常有效的。這會使問題變得很繁，復雜度很大。因此，我們先對問題進行分析。 在下面的討論中，我們把C的任一C-獨立點集={ai1,j1，…，ais,js}，記作=ai1,j1…ais,js，i1 <…< is。於是可看作陣C中以1為節點的一條路，滿足：對路中的任意兩節點，均有某一節點位於另一節點的右下方。稱這種路為右下行路。 於是求C-獨立點集等價於求陣C的右下行路。這種求右下行路的搜索可以逐行往下進行。 命題1. 若 =αai,jβ和ψ=α'ai,jσ為C的兩個C-獨立點集，且α為α'的加細，則存在C-獨立點集'=αai,jδ，滿足≥。 命題2. 若 =αai,jβ和ψ=α'ai+k,jσ為C的兩個C-獨立點集，且≥，則存在C-獨立點集'=αai,jδ，滿足≥。 命題3. 若 =αai,jβ和ψ=α'ai,j+kσ為C的兩個C-獨立點集，且≥，則存在C-獨立點集'=αai,jδ，滿足≥。 由命題1知，在搜索右下行路的過程中，如果已獲得了某一C-獨立點集的某一初始截段αai,j和另一C-獨立點集ψ的某一初始截段α'ai,j，且有≤，則我們可以停止對ψ的進一步搜索。 由命題2知，在搜索右下行路的過程中，在某一列j存在某兩個C-獨立點集的某初始截段=ai1,j1…ais,j和ψ=al1,m1…alt,j，如果≥，但lt>is，則我們可以停止對ψ的進一步搜索。 由命題3知，在搜索右下行路的過程中，在某一行i存在某兩個C-獨立點集的某初始截段=ai1,j1…ai,js和ψ=ai1,m1…ai,mt，如果≥，但mt>js，則我們可以停止對ψ的進一步搜索。 由此可見，並不要求搜索所有C的最大C-獨立點集，而可以採用比這簡單得多的方法進行計算。那麼按照我們上面的三個命題，來看如下實例： 首先我們得到=B（在上的節點用①表示），我們向右下方找路，可以發現，在第4列有兩個1，根據命題2，我們選擇上面的一個1，也就是說選擇第1行的那個1，而不要第2行的那個1。同時我們也發現在第1行也有兩個1，由命題3知，我們選擇左邊的那個1，即第4列的那個1。此時=BO。但是當我們的演算法運行到第4行時，=BOOK，由於K在第3行第6列，而本行的1在第1列，在路最後一個節點K的左邊，那麼我們必須新建一條路ψ，因為我們並不能確定是否以後就有≥，當演算法運行到第6行時，=BOOK，ψ=NEW，=4，=3，我們將S鏈到路上，此時我們得到最長右下行路=BOOKS，=5。這樣我們就可以計算出這兩個字元串的匹配程度。 在我們的演算法設計過程中，用到了兩個技巧。技巧之一，矩陣C不用存儲，是動態建立的，節省了空間。技巧之二，本演算法並不要求所有的S與T中所有的元素都相互進行比較，也並不存儲所有的右下行路，節省了時間和空間。由矩陣中1的出現情況可見，本演算法所需的空間和時間都遠小於O（mn）
編輯本段結束語
本文給出了一個與模式匹配不同的，具有若干應用的，串的最大匹配演算法，該演算法已經在機器上實現，達到了預期的效果。本文僅討論權值恆為1的情況，對於權值任意的情形不難由此得到推廣。
編輯本段C語言代碼(C Code)
#include<stdio.h> #include<string.h> void getnext(int next[],char s[],int l) { int i=1,j=0; next[1]=0; while(i<l) { if(j==0 || s[i]==s[j]) { i++;j++; next[i]=j; } else j=next[j]; } } int KMP(char s1[],char s2[],int l1,int l2,int next[]) { int i,j; i=j=1; while(i<=l1 && j<=l2) { if(j==0||s1[i]==s2[j]) { i++;j++; } else j=next[j]; } if(j>l2) return(i-l2); return 0; } int main() { int next[10001],ans; char s1[10001],s2[10001],l1,l2; scanf("%s",s1+1); scanf("%s",s2+1); l1=strlen(s1+1); l2=strlen(s2+1); getnext(next,s2,l2); ans=KMP(s1,s2,l1,l2,next); if(ans!=0) printf("%d\n",ans); else printf("No!\n"); system("pause"); return 0; }
編輯本段KMP演算法的pascal實現
var next:array [1 ..1000001] of longint; s,t:ansistring; procere get_next(t:ansistring); var j,k:integer; begin j:=1; k:=0; while j<length(t) do begin if (k=0) or (t[j]=t[k]) then begin inc(j); inc(k); next[j]:=k; end else k:=next[k]; end; end; function index(s:ansistring;t:ansistring):longint; var i,j:longint; begin get_next(t); index:=0; i:=1; j:=1; while (i<=length(s))and(j<=length(t)) do begin if (j=0)or(s[i]=t[j]) then begin inc(i); inc(j); end else j:=next[j]; if j>length(t) then index:=i-length(t); end; end; begin readln(s); readln(t); writeln(index(s,t)) end.
編輯本段KMP播放器
K-multimedia player的縮寫
來自韓國的影音全能播放器，與Mplayer一樣從linux平台移植而來的Kmplayer(簡稱KMP)幾乎可以播放您系統上所有的影音文件。通過各種插件擴展KMP可以支持層出不窮的新格式。強大的插件功能,直接從Winamp繼承的插件功能，能夠直接使用winamp的音頻 ，輸入，視覺效果插件，而通過獨有的擴展能力，只要你喜歡，可以選擇使用不同解碼器對各種格式進行解碼。 KMPlayer The Professional Media Player! 它支持 Winamp 2/5 的輸入、常規、DSP、視覺效果、媒體庫插件。無須注冊表支持直接調用 Directshow 濾鏡！FFdshow 的視覺特效系統~超強的 GUI 界面~安裝電視卡後可以直接代替原軟體直接收看電視~支持播放 DVD/VCD 以及絕大多數電腦的媒體文件（AVI 支持 Xvid/DivX/3vid/H264 OGG/OGM/MKV 容器/AC3/DTS 解碼~Monkey Audio 解碼~）強烈推薦！此播放器除了會將自己的配置信息寫入注冊表外絕對綠色~ KMplayer內置目前常見的所有解碼器，包括real,QT等。 另外KMplayer安裝版也是目前很少見的檢查流氓軟體的安裝方式，如果一旦有惡意的漢化小組漢化並捆綁了流氓軟體。該安裝程序自動會識別，並作出提示，建議用戶不要安裝，雖然不是特別准確，但KMplayer的無廣告及第三方插件的特點使其深受好評。 目前韓國官方已經在Kmplayer里自帶了中文字型檔，只要用戶是中文系統，軟體就會自動識別，十分方便。 KMP版本: KMPlayer3.0.0.1439
『叄』 KMP演算法的原理及其應用
KMP演算法是通過分析子串，預先計算每個位置發生不匹配的時候，所需GOTO的下一個比較位置，整理出來一個next數組，然後再上面的演算法中使用。
講解一下：
當我們分析一個子串時，例如：abcabcddes. 需要分析一下，每個字元x前面最多有多少個連續的字元和字元串從初始位置開始的字元匹配。然後+1就行了（別忘了，我們的字元串都是從索引1開始的）當然，不要相同位置自己匹配，默認第一個字元的匹配數是0。
定義如下：設字元串為 x1x2x3...xn ,其中x1，x2，x3，... xi，... xn均是字元，設ai為字元xi對應的整數。則a=m，當且僅當滿足如下條件：字元串x1x2...xm equals 字元串x(i-m+1)...xi-1 xi 並且x1x2...xm x(m+1) unequals x(i-m) x(i-m+1)...xi-1 xi。
舉例如下：
abcabcddes
0111234111
|----------------------默認是0
--| | |-----------------不能自己相同字元匹配，所以這里者能認為是沒有所以是0+1 =1
------| | |-----------前面的字元和開始位置的字元相同，所以是2,3,4
-----------| | | |-------不匹配只能取1。
希望能明白的是，如果開始字元是 Ch1的話，那麼我們就是要在串中第2個Ch1後面的位置開始自己和自己匹配，計算最大的吻合度。
程序寫出來就是：
void GetNext(char* T, int *next)
{
int k=1,j=0;
next[1]=0;
while( k〈 T[0] ){
if (j ==0 || T[k] == T[j])
{
++k;
++j;
next[k] = j;
}
else j= next[j];
}
}
但是這個不是最優的，因為他沒有考慮aaaaaaaaaaaaaaaaaaab的情況，這樣前面會出現大量的1，這樣的演算法復雜度已經和最初的樸素演算法沒有區別了。所以稍微改動一下：
void GetNextEx(char *T, char *next)
{
int i=k,j=0; next[1] = 0;
while(k < T[0])
{
if (j == 0 || T[k] == T[j])
{
++k; ++j;
if (T[k] == T[j])
next[k] = next[j];
else
next[k] = j;
}
else j = next[j];
}
}
現在我們已經可以得到這個next字元串的值了，接下來就是KMP演算法的本體了：
相當簡單：
int KMP(char* S, char* T, int pos)
{
int k=pos, j=1;
while (k){
if (S[k] == T[j]){ ++k; ++j; }
else j = next[j]
}
if (j>T[0]) return k-T[0];
else return 0;
}
和樸素演算法相比，只是修改一句話而已，但是演算法復雜度從O(m*n) 變成了：O(m)
『肆』 解析一哈c語言中的kmp演算法，bf演算法,kr演算法之間的聯系與區別，盡量淺顯易懂，謝謝！
三種演算法聯系：都是字元串匹配演算法。
區別：
「KMP演算法」：在匹配過程稱，若發生不匹配的情況，如果next[j]>=0，則目標串的指針i不變，將模式串的指針j移動到next[j]的位置繼續進行匹配；若next[j]=-1，則將i右移1位，並將j置0，繼續進行比較。
「BF演算法」是普通的模式匹配演算法，BF演算法的思想就是將目標串S的第一個字元與模式串P的第一個字元進行匹配，若相等，則繼續比較S的第二個字元和P的第二個字元；若不相等，則比較S的第二個字元和P的第一個字元，依次比較下去，直到得出最後的匹配結果。
「KR演算法」在每次比較時，用HASH演算法計算文本串和模式串的HASH映射，通過比較映射值的大小來比較字元串是否匹配。但是考慮到HASH沖突，所以在映射值相同的時候，還需要近一步比較字元串是否相同。但是在每次比較時，需要計算HASH值，所以選擇合適的HASH演算法很重要。
略知一二！
『伍』 請會編程的同學幫忙用c語言寫一個無回溯模式匹配，kmp演算法。。
KMP演算法查找串S中含串P的個數count #include <iostream> #include <stdlib.h> #include <vector> using namespace std; inline void NEXT(const string& T,vector<int>& next) { //按模式串生成vector,next(T.size()) next[0]=-1; for(int i=1;i<T.size();i++ ){ int j=next[i-1]; while(T[i]!=T[j+1]&& j>=0 ) j=next[j] ; //遞推計算 if(T[i]==T[j+1])next[i]=j+1; else next[i]=0; // } } inline string::size_type COUNT_KMP(const string& S, const string& T) { //利用模式串T的next函數求T在主串S中的個數count的KMP演算法 //其中T非空， vector<int> next(T.size()); NEXT(T,next); string::size_type index,count=0; for(index=0;index<S.size();++index){ int pos=0; string::size_type iter=index; while(pos<T.size() && iter<S.size()){ if(S[iter]==T[pos]){ ++iter;++pos; } else{ if(pos==0)++iter; else pos=next[pos-1]+1; } }//while end if(pos==T.size()&&(iter-index)==T.size())++count; } //for end return count; } int main(int argc, char *argv[]) { string S=""; string T="ab"; string::size_type count=COUNT_KMP(S,T); cout<<count<<endl; system("PAUSE"); return 0; } 補上個Pascal的KMP演算法源碼 PROGRAM Impl_KMP; USES CRT; CONST MAX_STRLEN = 255; VAR next : array [ 1 .. MAX_STRLEN ] of integer; str_s, str_t : string; int_i : integer; Procere get_nexst( t : string ); Var j, k : integer; Begin j := 1; k := 0; while j < Length(t) do begin if ( k = 0 ) or ( t[j] = t[k] ) then begin j := j + 1; k := k + 1; next[j] := k; end else k := next[k]; end; End; Function index( s : string; t : string ) : integer; Var i, j : integer; Begin get_next(t); index := 0; i := 1; j := 1; while ( i <= Length(s) ) and ( j <= Length(t) ) do begin if ( j = 0 ) or ( s[i]= t[j] ) then begin i := i + 1; j := j + 1; end else j := next[j]; if j > Length(t) then index := i - Length(t); end; End; BEGIN ClrScr;{清屏，可不要} Write(『s = 』); Readln(str_s); Write(『t = 』); Readln(str_t); int_i := index( str_s, str_t ); if int_i <> 0 then begin Writeln( 'Found' , str_t,' in ', str_s, 'at ', int_i,' .' ); end else Writeln( 'Cannot find ', str_t,' in' , str_s, '. '); END.
『陸』 C語言的KMP 匹配演算法，VS老是報錯，不知道是不是編譯器的問題，請高手賜教啊！！！
//#include<iostream> //這一行是C++標准庫，C語言編程時不需要
#include<stdio.h>
#include<string.h> //C語言字元串處理頭文件是 string.h 而不是 string
//using namespace std; //這一行是C++標准命名空間的聲明，C語言編程時不需要
#define MAXSTRLEN 255
typedef unsigned char SString[MAXSTRLEN+1];
//計算最大滑動距離
void getnext(SString t,int next[])
{
int i,j;
////////////////////////////////////////////////////////////////////////////經典的KMP演算法
i=0, j=-1; // 此處最好是分為兩條語句，而不是寫在一起，這也是編程風格問題
next[0] = -1;
while(i<t[0])
{
if(j==-1 || (j>=0 && t[i]==t[j]))
{
i++;
j++;
next[i]=j;
}
else
j=next[j];
}
}
//*
//模式匹配，返回最小匹配的位置
int kmp(SString s, SString t,int next[])
{
int i = 0, j = 0;
while(i<s[0]&&j<t[0])
{
if(j==-1||s[i]==t[j])
{
++i,++j;
}
else j = next[j];
}
if(j>=t[0])
return i-t[0];
else return -1;
}
/////*/
int main()
{
int next[MAXSTRLEN];
SString s,t;
memset(s,0,sizeof(s));//對較大的數組進行初始化，有利於程序的多組數據測試，本例中只執行一
memset(t,0,sizeof(t)); //次程序，可暫時不需要，但是初始化以後更好，這個也屬於編程風格問題
printf("please input a main string\n");
scanf("%s",s); // 樓主在此處應該小心，輸入格式控制是 %s 而不是 s%
printf("please input a sub string\n");
scanf("%s",t); // 同上
getnext(t,next);
kmp(s,t,next);
return 0;
}
/****
//最後 此程序沒有輸出，不能看出來所需要的結果，因此不實用；不過前提要保證演算法正確，我
//沒有時間去驗證你的這個KMP演算法是否正確，你自己再多去調試一下。
//另外就是，樓主最好注意編程風格問題，好的編程風格增強代碼的可讀性，也方便調試；這個最
//好是從一開始就堅持下去，久而久之你就會發現其中的好處了。
*****/
『柒』 演算法基礎 - 樸素模式匹配演算法、KMP模式匹配演算法
假設我們要從 主字元串goodgoogle 中匹配 子字元串google
樸素模式匹配演算法就是 通過從主字元的頭部開始 一次循環匹配的字元串的挨個字元 如果不通過 則主字元串頭部位置遍歷位置+1 在依次遍歷子字元串的字元
匹配過程
主字元串從第一位開始 取出g 子字元串取出第一位 g 匹配 進入子循環
取出o 取出o 匹配
取出o 取出o 匹配
取出d 取出g 不匹配 主字元串遍歷位置+1
主字元串從第二位開始 取出o 子字元串取出第一位 g 不匹配 主字元串遍歷位置+1
主字元串從第三位開始 取出o 子字元串取出第一位 g 不匹配 主字元串遍歷位置+1
主字元串從第四位開始 取出d 子字元串取出第一位 g 不匹配 主字元串遍歷位置+1
主字元串從第五位開始 取出g 子字元串取出第一位 g 匹配 進入子循環
取出o 取出o 匹配
取出o 取出o 匹配
取出g 取出g 匹配
取出l 取出l 匹配
取出e 取出e 匹配 子循環結束 匹配成功
假設主字元串 長度為 n 子字元串長度為m n>= m
最好的情況需要匹配m次 時間復雜度為 0(m)
例如 000000000001 匹配 00001 每次進入子循環之後 都要遍歷到最後一次子循環才得出不匹配
需要匹配次數 (n-m+1) * m
最壞的情況需要匹配m次 時間復雜度為 0((n-m+1) * m)
KMP 演算法的主要核心就是 子字元串在子循環內得出不匹配時 主字元串當前的判斷位不需要回溯–也就是不可以變小 ，且子循環的判斷位需要回溯 回溯位與子字元串本身是否具有重復結構有關 。 以此來規避無效的判斷
時間復雜度為 O(n+m)
如果主串 S = "abcdefgab" 我們要匹配的子串 T = "abcdex" 如果用前面的樸素演算法 ， 前5個字母完全相同
直到第6個字母 f 和 x 不同
步驟1
S: a b c d e f g a b
T: a b c d e x
接下來如果用樸素演算法的話 那麼應該是如下比較
步驟2
S: a b c d e f g a b
T: # a b c d e x
b 和 a 不匹配
步驟3
S: a b c d e f g a b
T: # # a b c d e x
a和c 不匹配
步驟4
S: a b c d e f g a b
T: # # # # a b c d e x
d和a 不匹配
步驟5
S: a b c d e f g a b
T: # # # # a b c d e x
a和e 不匹配
步驟6
S: a b c d e f g a b
T: # # # # # a b c d e x
即主串S中的第2 ，3 ， 4， 5， 6 位都與子串T的首字元不相等
對於子串T來說 如果首字元a與後面的bcdex中任意一個字元都不相等
那麼對於上面的第一步來說 前五位都相等 那麼 可以得到 子串首字元a 與主串的第2，3，4，5 位都不相等
即步驟2 ， 3 ，4 ，5 都是多餘的 可以直接進入步驟6
如果子串的首字元串與後面的字元有相等的情況
假設S = "abcababca" T= "abcabx"
樸素演算法
步驟1
S: a b c a b a b c a
T: a b c a b x
a 與 x 不匹配
步驟2
S: a b c a b a b c a
T: # a b c a b x
b 與 a 不匹配
步驟3
S: a b c a b a b c a
T: # # a b c a b x
c 與 a 不匹配
步驟4
S: a b c a b a b c a
T: # # # a b c a b x
a 與 a 匹配
步驟5
S: a b c a b a b c a
T: # # # # a b c a b x
b 與 b 匹配
步驟6
S: a b c a b a b c a
T: # # # # a b c a b x
a 與 c 不匹配
因為步驟1 中已經得出 前五位已經完全匹配 並且子串首字元ab 存在相同的情況 所以 步驟2，3 是多餘的
直接進入步驟4 因為步驟1中已經得出 主串與子串前五位相同 同時 子串1 2 位與 子串的4 5 位相同 所以可得出
子串1 2 位 與當前主串匹配位置開始的前兩位也就是主串的4 5 位匹配 所以步驟4 , 5 是多餘的 可以直接進入步驟6
通過上面的兩個例子我們可以發現 主串的比較位是不會回溯的 ， 而子串的比較位與子串本身結構中是否有重復相關
子串不重復 舉例
S: a b c d e f g a
T: a b c d e x
子串第6位不匹配 且本身沒有重復 那麼下一次循環 就變成了 子串的第一位與主串的第二位比較
即子串的匹配位從6 變成了1
S: a b c d e f g a
T: # a b c d e x
子串重復 舉例
S: a b c a b a b c a
T: a b c a b x
a 與 x 不匹配
子串在第六位發生不匹配是 前五位abcab 具有重復結構 ab 所以子串匹配位發生變化 即子串的匹配位從6 變成了 3
S: a b c a b a b c a
T: # # # a b c a b x
a 與 c 不匹配
我們可以得出 子串匹配位的值 與主串無關 只取決於當前字元串之前的串前後綴的相似度
也就是說 我們在查找字元前 ，要先對子串做一個分析 獲取各個位置不匹配時 下一步子串的匹配位
前綴 ： 從頭開始數 不包含最後一位
後綴 : 不是倒著數 是以和前綴相同的字元串為結尾的部分
例如 字元串 a 沒有前後綴
字元串 ab 沒有前後綴
字元串 aba 沒有前後綴
字元串 abab 前後綴 ab
字元串 ababa 前後綴 可以是 a 可以是 aba 我們取長度最長的 即 aba
第一位時 next值固定為0
其他情況 取其公共最長前後綴的長度+1 沒有則為1
因為一共子串有8位 所以在子循環內一共需要獲取 8次前後綴
這里我們定義一個next數組 長度為8 裡面的元素分別對應子串各個子循環內的 前後綴長度
第1位不匹配時 獲取字元串為a 沒有前字元串 沒有前後綴 那麼next[1] = 0
第2位不匹配時 獲取字元串為ab 有前字元串a 沒有前後綴 那麼next[2] = 1
第3位不匹配時 獲取字元串為aba 有前字元串ab 沒有前後綴 那麼next[3] = 1
第4位不匹配時 獲取字元串為abab 有前字元串aba 前後綴 a 那麼next[4] = 2
第5位不匹配時 獲取字元串為ababa 有前字元串abab 前後綴 ab 那麼next[5] = 3
第6位不匹配時 獲取字元串為ababaa 有前字元串ababa 前後綴 aba 那麼next[6] = 4
第7位不匹配時 獲取字元串為ababaab 有前字元串ababaa 前後綴 a 那麼next[7] = 2
第8位不匹配時 獲取字元串為ababaabc 有前字元串ababaab 前後綴 ab 那麼next[8] = 3
next數組為[ 0, 1 , 1 ,2 , 3, 4 ,2, 3 ]
後來有人發現 KMP還是有缺陷的 比如 當子串 T = "aaaaax"
在5位發生不匹配 此時 next[5] = 4 接著就是 子串中的第四位a與 主串當前位置字元比較
因為子串第五位等於子串第四位相同 所以可以得出該步驟也不匹配 此時 next[4] = 3
依然不匹配 直到next[1] = 0
我們可以發現由於T串中的 2 3 4 5 位置都與首位a 相等 中間的過程都是多餘的
那麼可以用首位的next[1] 的值 去替代與它相等的字元後續的next[x]的值
『捌』 KMP演算法的C語言程序
#include "iostream"
#include "stdlib.h"
#include "stdio.h"
#include "malloc.h"
#define MAXSTRLEN 100
#define OK 1
#define NULL 0
using namespace std;
typedef char SString[MAXSTRLEN+1];
SString T,S;
int next[MAXSTRLEN],c[MAXSTRLEN];
int i,j;
void get_next(SString &T,int next[MAXSTRLEN]){
i=1;next[1]=0;j=0;
while(i<T[0]){
if(j==0||T[i]==T[j]){++i;++j;next[i]=j;}
else j=next[j];
}
}
int KMP(SString &S,SString &T){
i=1;j=1;
while(i<=S[0]&&j<=T[0]){
if(j==0||S[i]==T[j]){++i;++j;}
else j=next[j];
}
if(j>T[0])return i-T[0];
else return 0;
}
void main(){
int k,p=1;
int i=1,j=1;
printf("輸入主串：");
gets(&M[1]);
printf("輸入模式串：");
gets(&N[1]);
while(M[i]!=NULL)
{
i++;
M[0]=i-1;
}
puts(&M[1]);
while(N[j]!=NULL)
{
j++;
N[0]=j-1;
}
puts(&N[1]);
if(M[0]>N[0])
{
printf("error!");
exit(0);
}
get_next(T,next);
for(i=1;i<=T[0];i++)printf("%d",next[i]);
printf("\n");
k=KMP(S,T);
printf("模式串從主串第%d個開始匹配！",k);
}
『玖』 串模式匹配演算法（C語言）100分懸賞
第一個樸素演算法:
1.普通的串模式匹配演算法:
int index(char s[],char t[],int pos)
/*查找並返回模式串T在S中從POS開始的位置下標,若T不是S的子串.則返回-1.*/
{
int i,j,slen,tlen;
i=pos;j=0; //i,j分別指示主串和模式串的位置.
slen=strlen(s);tlen=strlen(t); //計算主串和模式串的長度.
while(i<slen && j<tlen)
{
if(s[i]==t[j]) {i++;j++;}
else {i=i-j+1;j=0;}
}
if(j>=tlen) return i-tlen;
return -1;
}
第二個KMP演算法.該演算法支持從主串的任意位置開始搜索.
2.KMP演算法:
//求模式串的next函數.
void get_next(char *p,int next[])
{
int i,j,slen;
slen=strlen(p);i=0;
next[0]=-1;j=-1;
while(i<slen)
{
if(j==-1||p[i]==p[j]) {++i;++j;next[i]=j;}
else j=next[j];
}
}
//KMP模式匹配演算法
int index_kmp(char *s,char *p,int pos,int next[])
/* 利用模式串P的NEXT函數,求P在主串S中從第POS個字元開始的位置*/
/*若匹配成功.則返回模式串在主串中的位置下標.否則返回-1 */
{
int i,j,slen,plen;
i=pos-1;j=-1;
slen=strlen(s);plen=strlen(p);
while(i<slen && j<plen)
{
if(j==-1||s[i]==p[j]) {++i;++j;}
else j=next[j];