kmp演算法java

⑴ 如何准備互聯網公司面試（演算法相關）

書籍： 《演算法導論》 這本是大部頭，很多人都看不完。我本人也並沒有看完，它跟了我這么多年，完全是屬於常看常新的牛書。每一次看，都發現會有新的收獲。比如，以前並不知道求K位數或者中位數有平均為O(n)復雜度的演算法。看到了別的地方的參考資料，才知道，原來《算導》上專門有一小節講這個內容。我基本上是本科比較集中的看了一遍，研一的時候又集中的看了一遍，才算是粗略的看完。但是其實，很多理論性的，以及圖論一部分依然還是沒有看完。個人推薦，先從簡單的開始，挑選比較熟悉的一些偏重與數據結構方面的知識作為起點。這本書的習題非常重要，要是有時間，能夠全部做完，那絕對是能夠神功在手了。其實，集中把，第二部分（排序），第三部分（數據結構），第四部分（高級設計，我基本主要看動態規劃和貪心），第五部分（高級數據結構，B樹和二項堆，並差集），第六部分（圖演算法，最大流部分較難，自己可以看情況掌握）。這些部分可以先從演算法本身開始，偽代碼全部看懂。因為演算法導論講的很詳細，而且有來龍去脈，基本不會有太大難度。數學證明，推薦大家掌握，但是，突擊或者第一次，可以選擇性的看看。我自己是重復看，才把證明看掉的。第一次看的時候，基本都跳過了。不過，證明和習題是精髓！希望如果有時間，一定要補回來。 《編程之美》《挑戰編程》 這本書絕對是將全中國企業，或者說是一部分懶惰的企業面試題庫提升了一個檔次的一本神書。網路面我師兄的時候，我師兄直接把有一道題的最優解答出來了。但是，那個面試官顯然是不知道最優解，一直在引導我師兄答出，這本書裡面的第四個解。呵呵。書很不錯。全部看一遍並不難。說個不好聽的，可以背下來，而且相信我，基本上絕對有用！比如說，n!後面有多少個0。我相信，你們今年面試或者筆試，一定會碰到這道題。《挑戰編程》大家可以自行考慮一下吧，這個完全是針對acm競賽的，不過，看看題也不錯。 《編程珠璣》 業界神書嘛。習題全部做完就是了。其實都是些小東西，但是，基本上一步步考察你的解決問題的能力。個人覺得，最常用的就是bit map做排序或者去重，拓展一下就是bloom filter，我當時都是在這本書裡面看到的。 《演算法技術手冊》 這本書貌似出鏡不多。書很薄，代碼寫的非常好，其實基本上全部都是基礎演算法和數據結構的實現。但是，它牛逼就在於，代碼寫的太好了，基本上，看一遍，絕對能背下來。面試基礎很重要。基本上每個筆試或者面試，都會考一個100行以內的小程序。比如，給定一棵樹，以及其中一個節點x，要求出這棵樹的中序遍歷序列中，x的後續節點，非遞歸實現。這種題非常簡單，但是，真正寫對的，其實並不多。《STL源碼剖析》《C標准庫》 都不厚。挑著看一遍非常舒服。特別是，看看STL每個數據結構迭代器類型啊，紅黑書如何實現啊。C標准庫，最常見的，比如strcpy()和memcpy()有什麼區別啊。特別是，STL，看過之後，對泛型還是能有一定了解的。《C專家編程》《Effective c++》《深度探索C++對象模型》 第一本比較簡單，可以當八卦書看。後兩本其實也沒啥好說的，其實都是些業界公認的牛書。我再重復一遍也沒什麼意義。但是，的確，考察基本上也就都是這么幾本書上面的東西。基本上後兩本主要側重看c++對象方面的一些指示，特別是多態相關的。 《具體數學》《組合數學》 這兩本其實可以看作修身養性的書。我當時是時間比較充裕的時候看完的。純突擊，大家就可以跳過了。但是，看完真的很有用。比如說，你們就可以跟面試官扯約瑟夫環的構造解了（這道題我覺得80%會遇到），直接推推公式，就不用寫模擬代碼了。《組合數學》也是，很多筆試一般會有些小智力題。不過，其實一般的題目，不看這本書也可以搞定。所以，這兩本僅供參考。大家有興趣的時候，可以翻翻。《Linux內核源碼剖析》《Linux環境高級編程》…… 要是有機會，能看看最好。因為很多公司都會考察Linux相關的知識。最少要會點腳本，一些簡單的Linux命令，以及正則表達式什麼的。要是能聊聊內核源碼或者驅動開發什麼的東西，面試官肯定更加喜歡了。 知識： c & c++ 首先要知道c和c++的區別。常考的有const的用法，一些生僻關鍵字比如extern，static的用法。 結構體與類的差別。類裡面的字對齊問題，也就是說一個類到底有多大。以及一個空的類有多大。 虛函數以及多態相關的顯然是重點。比如析構函數什麼時候需要寫成虛函數，構造函數是否可以是虛函數。 int a[10]; a 和 &a的區別。 java java我並不熟。但是基本上肯定會考一些虛擬機相關的，以及GC等知識。然後，一般招聘的java程序員都會問到很多多線程編程的東西，以及hadoop！這個絕對是重點，淘寶絕對就是問這個的。 操作系統 這個看工作崗位的實際要求。基本的進程線程區別==肯定是會問到的。要是要求高一些，就會問很多多線程編程的問題。一些競爭死鎖等基礎知識，一些進程調度的演算法，最近的kernel好像用的是CFS調度演算法。shell編程，如何讀取程序堆棧，寫一些core mp的讀取程序等等的。 數據結構 基本上所有的排序都要會寫。與樹有關的操作都要會些非遞歸版本。圖一般考的不多。Flood-Fill演算法等等。查找中位數。B樹和紅黑書最好要掌握，不用會寫，能扯扯基本就行。KMP，這個很有可能考！而且的確真的不好懂。要是實在不行，背下來吧。哈哈。 網路 這個其實比較基礎了。我個人網路方面的知識並不好。但是各種協議的基礎，幾次握手啊，一些操作系統的api實現到底是單工還是雙工用的是TCP還是UDP。我個人網路純粹靠拼RP。 資料庫 資料庫非常重要。基本的SQL肯定是要會的。最常見有一道題，inner join和out join的區別。MySQL是重點，基本上很多企業都是問這個。然後，網路扯多了會跟你扯MySQL引擎 的一些東西。這些我就不太懂了。要是能准備的話，或者說的確是做這方面的，就可以著重多准備下。 大規模數據處理這一塊絕對是重點！而且本身不是一個系統的學科分支。但是，基本上幾家大公司都會問這方面的。推薦先讀讀google那幾篇論文。Page Rank那一篇，然後Map Rece好像有幾篇吧。Big Table什麼的。推薦一個網址。這篇貌似是轉載的，我以前找到的源地址現在找不到了。處理這一類問題基本上思路都是，哈希，map rece以及bit map等等的。對了，推薦看一下外排序以及相關的敗者樹。這些都是大規模數據處理的一些典型問題。掌握了這些其實也就夠了。這塊有點屠龍之技的感覺，特別是對於學生，基本沒有誰能有機會把這些代碼實現出來。但是，沒辦法，這些公司就是喜歡考。看完那篇博客的，然後再自行查找一些資料，基本就夠了。萬變不離其中，而且，這些東西，沒辦法考那麼難的。 推薦一個博客吧，作者收集了100+道面試題，並且全部給出了代碼。把這個全部看完，基本上很多面試筆試，都是這些原題。 推薦Top Language裡面的今天我們思考系列，好幾年前的了。看大牛的思考過程，非常有幫助。希望自己能多想想再看答案。注意，google group好像有時被牆。 我把發芽網的題庫版塊也掃了一遍。 還有好多一時想不起來了。

⑵ KMP演算法詳細代碼

KMP.java

源代碼為：

package algorithm.kmp;

/**
* KMP演算法的Java實現例子與測試、分析
* @author 崔衛兵
* @date 2009-3-25
*/
public class KMP {
/**
* 對子串加以預處理，從而找到匹配失敗時子串回退的位置
* 找到匹配失敗時的最合適的回退位置，而不是回退到子串的第一個字元，即可提高查找的效率
* 因此為了找到這個合適的位置，先對子串預處理，從而得到一個回退位置的數組
* @param B，待查找子串的char數組
* @return
*/
public static int[] preProcess(char [] B) {
int size = B.length;
int[] P = new int[size];
P[0]=0;
int j=0;
//每循環一次，就會找到一個回退位置
for(int i=1;i<size;i++){
//當找到第一個匹配的字元時，即j>0時才會執行這個循環
//或者說p2中的j++會在p1之前執行（限於第一次執行的條件下）
//p1
while(j>0 && B[j]!=B[i]){
j=P[j];
}
//p2，由此可以看出，只有當子串中含有重復字元時，回退的位置才會被優化
if(B[j]==B[i]){
j++;
}
//找到一個回退位置j，把其放入P[i]中
P[i]=j;
}
return P;
}

/**
* KMP實現
* @param parStr
* @param subStr
* @return
*/
public static void kmp(String parStr, String subStr) {
int subSize = subStr.length();
int parSize = parStr.length();
char[] B = subStr.toCharArray();
char[] A = parStr.toCharArray();
int[] P = preProcess(B);
int j=0;
int k =0;
for(int i=0;i<parSize;i++){
//當找到第一個匹配的字元時，即j>0時才會執行這個循環
//或者說p2中的j++會在p1之前執行（限於第一次執行的條件下）
//p1
while(j>0 && B[j]!=A[i]){
//找到合適的回退位置
j=P[j-1];
}
//p2 找到一個匹配的字元
if(B[j]==A[i]){
j++;
}
//輸出匹配結果，並且讓比較繼續下去
if(j==subSize){
j=P[j-1];
k++;
System.out.printf("Find subString '%s' at %d\n",subStr,i-subSize+1);
}
}
System.out.printf("Totally found %d times for '%s'.\n\n",k,subStr);
}

public static void main(String[] args) {
//回退位置數組為P[0, 0, 0, 0, 0, 0]
kmp("abcdeg, abcdeh, abcdef!這個會匹配1次","abcdef");
//回退位置數組為P[0, 0, 1, 2, 3, 4]
kmp("Test ititi ititit! Test ititit!這個會匹配2次","ititit");
//回退位置數組為P[0, 0, 0]
kmp("測試漢字的匹配，崔衛兵。這個會匹配1次","崔衛兵");
//回退位置數組為P[0, 0, 0, 1, 2, 3, 4, 5, 6]
kmp("這個會匹配0次","it1it1it1");
}
}

⑶ java kmp演算法中的 kmp 是什麼意思

kmp演算法
一種改進的字元串匹配演算法，由D.E.Knuth與V.R.Pratt和J.H.Morris同時發現，因此人們稱它為克努特——莫里斯——普拉特操作（簡稱KMP演算法）。
完全掌握KMP演算法思想
學過數據結構的人，都對KMP演算法印象頗深。尤其是新手，更是難以理解其涵義，搞得一頭霧水。今天我們就來面對它，不將它徹底搞懂，誓不罷休。
如今，大夥基本上都用嚴蔚敏老師的書，那我就以此來講解KMP演算法。(小弟正在備戰考研，為了節省時間，很多課本上的話我都在此省略了，以後一定補上。)
嚴老的《數據結構》79頁講了基本的匹配方法，這是基礎。先把這個搞懂了。
80頁在講KMP演算法的開始先舉了個例子，讓我們對KMP的基本思想有了最初的認識。目的在於指出「由此，在整個匹配的過程中，i指針沒有回溯，」。
我們繼續往下看：
現在討論一般情況。
假設 主串：s: 『s(1) s(2) s(3) ……s(n)』 ; 模式串 ：p: 『p(1) p(2) p(3)…..p(m)』
把課本上的這一段看完後，繼續
現在我們假設 主串第i個字元與模式串的第j(j<=m)個字元『失配』後，主串第i個字元與模式串的第k(k<j)個字元繼續比較
此時，s(i)≠p(j), 有
主串： S(1)…… s(i-j+1)…… s(i-1) s(i) ………….
|| (相配) || ≠(失配)
匹配串： P(1) ……. p(j-1) p(j)
由此，我們得到關系式
『p(1) p(2) p(3)…..p(j-1)』 = 』 s(i-j+1)……s(i-1)』
由於s(i)≠p(j)，接下來s(i)將與p(k)繼續比較，則模式串中的前(k-1)個字元的子串必須滿足下列關系式，並且不可能存在 k』>k 滿足下列關系式：(k<j),
『p(1) p(2) p(3)…..p(k-1)』 = 』 s(i-k+1)s(i-k+2)……s(i-1)』
即：
主串： S(1)……s(i-k +1) s(i-k +2) ……s(i-1) s(i) ………….
|| (相配) || || ?(有待比較)
匹配串： P(1) p(2) …… p(k-1) p(k)
現在我們把前面總結的關系綜合一下
有：
S(1)…s(i-j +1)… s(i-k +1) s(i-k +2) …… s(i-1) s(i) ……
|| (相配) || || || ≠(失配)
P(1) ……p(j-k+1) p(j-k+2) ….... p(j-1) p(j)
|| (相配) || || ?(有待比較)
P(1) p(2) ……. p(k-1) p(k)
由上，我們得到關系：
『p(1) p(2) p(3)…..p(k-1)』 = 』 s(j-k+1)s(j-k+2)……s(j-1)』
接下來看「反之，若模式串中存在滿足式(4-4)。。。。。。。」這一段。看完這一段，如果下面的看不懂就不要看了。直接去看那個next函數的源程序。(偽代碼)
K 是和next有關系的，不過在最初看的時候，你不要太追究k到底是多少，至於next值是怎麼求出來的，我教你怎麼學會。
課本83頁不是有個例子嗎？就是 圖4.6
你照著源程序，看著那個例子慢慢的推出它來。看看你做的是不是和課本上正確的next值一樣。
然後找幾道練習題好好練練，一定要做熟練了。現在你的腦子里已經有那個next演算法的初步思想了，再回去看它是怎麼推出來的，如果還看不懂，就繼續做練習，做完練習再看。相信自己！！！
附：
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!=T[j+1]&& j>=0 )
j=next[j] ; //遞推計算
if(T==T[j+1])next=j+1;
else next=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 = 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.
index函數用於模式匹配，t是模式串，s是原串。返回模式串的位置，找不到則返回0

不再贅述演算法原理，下面是兩個函數，已經通過測試，可以直接用。

private int[] get_nextval(String t) {
int len = t.length();
int i = 0;
int j = -1;
int next[] = new int[len];
while (i < len - 1) {
if (j == -1 || (t.charAt(i) == (t.charAt(j)))) {
i++;
j++;
if (t.charAt(i) != (t.charAt(j))) {
next[i] = (j + 1);
} else {
next[i] = next[j];
}
} else {
j = (next[j] - 1);
}
}
return next;
}

private int index_KMP(String s, String t, int[] next) {
int i = 0;
int j = 0;
while (i < s.length() - 1 && j < t.length() - 1) {
if (j == 0 || (s.charAt(i) == t.charAt(j))) {
i++;
j++;
} else
j = (next[j] - 1);
}
if (j > t.length() - 2) {
return (i - t.length() + 1);
} else
return -1;
}

⑷ 怎樣簡單明了的解釋KMP演算法

map 根據輸入的映射函數，將一個集合映射為另一個集合，比如：
輸入集合為 {1,2,3,4,5}，輸入的函數為 f(x) = x^2，那麼輸出的集合就是 {1,4,9,16,25}。

rece 就是根據輸入的歸約函數，將集合（一般指map輸出的集合）歸約，比如上面的輸出集合是 {1,4,9,16,25}，假設我們的歸約函數是 f(x,y) = x + y, 那麼 rece 的過程就是 {5,9,16,25} -> {14,16,25} -> {30,25} -> {55}。

我們使用 Java8 來描述這個過程：
int result = IntStream.range(1, 6) // 獲得集合 {1,2,3,4,5} .map(x -> x * x) // 映射為 {1,4,9,16,25} .rece((x, y) -> x + y) // 歸約 .getAsInt(); // 獲得結果System.out.println(result);結果：

⑸ java中String的int indexof(String)方法是用什麼演算法實現的，是KMP嗎

不是KMP演算法，自己看看源碼就知道了。
至於原因:
KMP對特殊的字元串比較好用 就是自身帶有很多重復子串的那種
在字元串不長的情況下 KMP比較耗時

⑹ java字元串最大長度

1.String內部是以char數組的形式存儲，數組的長度是int類型，那麼String允許的最大長度就是Integer.MAX_VALUE了,2147483647;
又由於java中的字元是以16位存儲的，因此大概需要4GB的內存才能存儲最大長度的字元串。所以，發送xml批量的需要在oracle資料庫中用clob類型，而在java 端可以用String；

2. ResultSet rs = st.executeQuery("select CLOBATTR from TESTCLOB where ID=1");
if (rs.next())
{
java.sql.Clob clob = rs.getClob("CLOBATTR");
inStream = clob.getCharacterStream();
char[] c = new char[(int) clob.length()];
inStream.read(c);
//data是讀出並需要返回的數據，類型是String
data = new String(c);
inStream.close();
}
inStream.close();
con.commit();

⑺ C語言數據結構中的kmp演算法，是不是其中的getnext（）和getnextvalu（）兩個函數的功能是相同的，只是後者

效率沒有變化

⑻ （高分）大俠們，請教編程學習的問題！！ 可以追加分數

編程分為： 面向過程編程 面向對象編程

ACM比賽一類的需要的主要是面向過程編程，一般ACM競賽的題目都可以解決

舉個例子

現在我有1000個數，我要找到第100大的數字，那麼我們可以用選擇排序，然後找到排在第100個的數， 演算法的效率 是O(N^2)

如果我有10000000個數，我要找第100大的數呢，選擇排序的速度就太慢了，於是我們要換一種方法去找第100大的數。 這里我們用到的方法就是演算法！！

面向過程編程就要收針對一個問題進行解決，設計省空間省時間的演算法！！

面向對象編程，與面向過程編程在思路上有很大的區別，主要考慮了程序的移植性，復用性，繼承等等，主要在應用中會用到，比如軟體開發等等

c是面向過程編程的語言，c++包含了c的特性，但是主要是屬於面向對象編程，java是面向對象編程的語言

如果你這么問，我們可以做一個假設，那就是你對演算法以及數據結構都沒有一個很清晰的了解，或者是說沒有一個更深入的理解。

我的意見是：從 演算法與數據結構 入手，這類的書籍很多很泛濫，內容差不多。 等你對演算法與數據結構有了深入的了解了以後再去看看 高級演算法與數據結構 這些是編程思想的基礎！！

計算機語言是可以觸類旁通的，所以使用任何語言都沒有太大關系。

總結：
1. 了解清楚什麼是面向過程編程，面向對象編程，有自己的理解最好；
2. 從演算法與數據結構入手，
了解各種數據結構：樹，二叉樹，多叉樹，紅黑樹等等
哈希表，數組模擬鏈表等等
演算法：貪心演算法、動態規劃演算法、最小生成樹演算法、KMP演算法、網路流演算法等等最基本的演算法
3. 練習，訓練編程思想最重要的就是練習！！ ACM題庫就是一個很好的練習場所，浙大的題庫，北大的題目，同濟的題庫，還有美國的題庫USACO 俄羅斯的也有很多很多題庫，我們高中的時候就是做這些題庫的@！！

先講這么多，祝好運哦～

⑼ Java編程實現字元串的模式匹配

傳統的字元串模式匹配演算法（也就是BF演算法）就是對於主串和模式串雙雙自左向右，一個一個字元比較，如果不匹配，主串和模式串的位置指針都要回溯。這樣的演算法時間復雜度為O（n＊m），其中n和m分別為串s和串t的長度。

KMP 演算法是由Knuth，Morris和Pratt等人共同提出的，所以成為Knuth－Morris－Pratt演算法，簡稱KMP演算法。KMP演算法是字元串模式匹配中的經典演算法。和BF演算法相比，KMP演算法的不同點是匹配過程中，主串的位置指針不會回溯，這樣的結果使得演算法時間復雜度只為O（n＋m）。

⑽ 串的應用kmp演算法。求一個字元串在另一個字元串中第一次出現的位置。

KMP.java

源代碼為：

package algorithm.kmp;

/**
* KMP演算法的Java實現例子與測試、分析
* @author 崔衛兵
* @date 2009-3-25
*/
public class KMP {
/**
* 對子串加以預處理，從而找到匹配失敗時子串回退的位置
* 找到匹配失敗時的最合適的回退位置，而不是回退到子串的第一個字元，即可提高查找的效率
* 因此為了找到這個合適的位置，先對子串預處理，從而得到一個回退位置的數組
* @param B，待查找子串的char數組
* @return
*/
public static int[] preProcess(char [] B) {
int size = B.length;
int[] P = new int[size];
P[0]=0;
int j=0;
//每循環一次，就會找到一個回退位置
for(int i=1;i<size;i++){
//當找到第一個匹配的字元時，即j>0時才會執行這個循環
//或者說p2中的j++會在p1之前執行（限於第一次執行的條件下）
//p1
while(j>0 && B[j]!=B[i]){
j=P[j];
}
//p2，由此可以看出，只有當子串中含有重復字元時，回退的位置才會被優化
if(B[j]==B[i]){
j++;
}
//找到一個回退位置j，把其放入P[i]中
P[i]=j;
}
return P;
}

/**
* KMP實現
* @param parStr
* @param subStr
* @return
*/
public static void kmp(String parStr, String subStr) {
int subSize = subStr.length();
int parSize = parStr.length();
char[] B = subStr.toCharArray();
char[] A = parStr.toCharArray();
int[] P = preProcess(B);
int j=0;
int k =0;
for(int i=0;i<parSize;i++){
//當找到第一個匹配的字元時，即j>0時才會執行這個循環
//或者說p2中的j++會在p1之前執行（限於第一次執行的條件下）
//p1
while(j>0 && B[j]!=A[i]){
//找到合適的回退位置
j=P[j-1];
}
//p2 找到一個匹配的字元
if(B[j]==A[i]){
j++;
}
//輸出匹配結果，並且讓比較繼續下去
if(j==subSize){
j=P[j-1];
k++;
System.out.printf("Find subString '%s' at %d\n",subStr,i-subSize+1);
}
}
System.out.printf("Totally found %d times for '%s'.\n\n",k,subStr);
}

public static void main(String[] args) {
//回退位置數組為P[0, 0, 0, 0, 0, 0]
kmp("abcdeg, abcdeh, abcdef!這個會匹配1次","abcdef");
//回退位置數組為P[0, 0, 1, 2, 3, 4]
kmp("Test ititi ititit! Test ititit!這個會匹配2次","ititit");
//回退位置數組為P[0, 0, 0]
kmp("測試漢字的匹配，崔衛兵。這個會匹配1次","崔衛兵");
//回退位置數組為P[0, 0, 0, 1, 2, 3, 4, 5, 6]
kmp("這個會匹配0次","it1it1it1");
}
}