使用Boyer-Moore算法
或者使用KMP算法
建议使用后者
KMP算法（java）
public class KMP {
/**
* @param args
*/
//计算模式串的next值
public static void getNext(String strModel, int dNext[]){
int i = 0,j = 1;
dNext[1] = 0;
while(j strModel.length()){
while(i 0 strModel.charAt(i) != strModel.charAt(j))//递推
i = dNext[i];
i◆◆;
j◆◆;
if(j == strModel.length())
break;
if(strModel.charAt(j) == strModel.charAt(i))//得出next值
dNext[j] = dNext[i] ◆ 1;
else
dNext[j] = i;
}
//利用next值查询子串
public static int getSubString(String strMain, String strModel, int dStart){
int dPos = -1;
int i = dStart;
int j = 1;
getNext(strModel, dNext);
while(istrMain.length()){
if(strMain.charAt(i) == strModel.charAt(j)){//当前字符匹配
if(j == (strModel.length()-1)){//查找成功
dPos = i - j ◆ 1;
else{//当前字符不匹配
if(dNext[j] == 0){
j = 1;
else{
j = dNext[j];
return dPos;
public static void main(String[] args) {
// TODO Auto-generated method stub
String strModel = " jlsdjflskjdm";
for(int i = 1; istrModel.length(); i◆◆)
System.out.print(dNext[i] ◆ " ");
String strMain = " aaaaaaaaaaabbbcdabbksfjlsdjflskjd";
System.out.println();
System.out.println(getSubString(strMain, strModel, 1));
基本思想：
这种算法是D.E.Knuth 与V.R.Pratt和J.H.Morris同时发现的,所以呢人们称为KMP算法.此算法可以在O(n◆m)的时间数量级上完成串的模式匹配操作.
其基本思想是：每当匹配过程中出现字符串比较不等时,不需回溯i指针,而是利用已经得到的"部分匹配"结果将模式向右"滑动"尽可能远的一段距离后,继续进行比较.
#include stdio.h
#include string.h
int index_KMP(char *s,char *t,int pos);
void get_next(char *t,int *);
char s[10]="abcacbcba";
int pos=0;
int main()
{
int n;
get_next(t,next);
n=index_KMP(s,t,pos);
printf("%d",n);
return 0;
int index_KMP(char *s,char *t,int pos)
int i=pos,j=1;
while (i=(int)strlen(s)j=(int)strlen(t))
if (j==0||s[i]==t[j-1])
else j=next[j];
if (j(int)strlen(t))
return i-strlen(t)◆1;
void get_next(char *t,int *next)
int i=1,j=0;
next[0]=next[1]=0;
while (i(int)strlen(t))
if (j==0||t[i]==t[j])
next[i]=j;
kmp算法
一种改进的字符串匹配算法,由D.E.Knuth与V.R.Pratt和J.H.Morris同时发现,所以呢人们称它为克努特——莫里斯——普拉特操作（简称KMP算法）.
完全掌握KMP算法思想
学过数据结构的人,都对KMP算法印象颇深.尤其是新手,更是难以理解其涵义,搞得一头雾水.本文就由土嘎嘎小编面对它,不将它彻底搞懂,誓不罢休.
如今,大伙基本上都用严蔚敏老师的书,那我就以此来讲解KMP算法.(小弟正在备战考研,为了节省时间,很多课本上的话我都在此省略了,以后一定补上.)
我们继续往下看：
现在讨论一般情况.
把课本上的这一段看完后,继续
现在我们假设 主串第i个字符与模式串的第j(j=m)个字符'失配'后,主串第i个字符与模式串的第k(kj)个字符继续比较
此时,s(i)≠p(j), 有
主串： S(1)...... s(i-j◆1)...... s(i-1) s(i) .............
|| (相配) || ≠(失配)
匹配串： P(1) ....... p(j-1) p(j)
由此,我们得到关系式
由于s(i)≠p(j),此时此刻呢s(i)将与p(k)继续比较,则模式串中的前(k-1)个字符的子串必须满足下列关系式,并且不可能存在 k'k 满足下列关系式：(kj),
即：
|| (相配) || || ?(有待比较)
现在我们把前面总结的关系综合一下
有：
|| (相配) || || || ≠(失配)
由上,我们得到关系：
K 是和next有关系的,不过在最初看的时候,你不要太追究k到底是多少,至于next值是怎么求出来的,我教你怎么学会.
你照着源程序,看着那个例子慢慢的推出它来.看看你做的是不是和课本上正确的next值一样.
然后找几道练习题好好练练,一定要做熟练了.现在你的脑子里已经有那个next算法的初步思想了,再回去看它是怎么推出来的,如果还看不懂,就继续做练习,做完练习再看.相信自己！！！
附：
KMP算法查找串S中含串P的个数count
#include iostream
#include stdlib.h
#include vector
using namespace std;
inline void NEXT(const string T,vectorint next)
//按模式串生成vector,next(T.size())
next[0]=-1;
for(int i=1;iT.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非空,
vectorint next(T.size());
NEXT(T,next);
string::size_type index,count=0;
for(index=0;indexS.size();◆◆index){
string::size_type iter=index;
while(posT.size() iterS.size()){
if(S[iter]==T[pos]){
◆◆iter;◆◆pos;
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="abaabcacabaabcacabaabcacabaabcacabaabcac";
string T="ab";
string::size_type count=COUNT_KMP(S,T);
coutcountendl;
system("PAUSE");
补上个Pascal的KMP算法源码
PROGRAM Impl_KMP;
USES
CRT;
CONST
VAR
next : array [ 1 .. MAX_STRLEN ] of integer;
str_s, str_t : string;
int_i : integer;
Procedure 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
j := j ◆ 1; k := k ◆ 1;
next[j] := k;
end
else k := next[k];
end;
End;
Function index( s : string; t : string ) : integer;
i, j : integer;
get_next(t);
index := 0;
i := 1; j := 1;
while ( i = Length(s) ) and ( j = Length(t) ) do
if ( j = 0 ) or ( s = t[j] ) then
i := i ◆ 1; j := j ◆ 1;
else j := next[j];
if j Length(t) then index := i - Length(t);
BEGIN
ClrScr;
Write(s = );
Readln(str_s);
Write(t = );
Readln(str_t);
int_i := index( str_s, str_t );
if int_i 0 then
Writeln( Found , str_t, in , str_s, at , int_i, . );
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)))) {
if (t.charAt(i) != (t.charAt(j))) {
next[i] = (j ◆ 1);
} else {
next[i] = next[j];
j = (next[j] - 1);
return next;
private int index_KMP(String s, String t, int[] next) {
int j = 0;
while (i s.length() - 1 j t.length() - 1) {
if (j == 0 || (s.charAt(i) == t.charAt(j))) {
} else
return (i - t.length() ◆ 1);
return -1;
LZ的get_next函数和Index_KMP函数的代码是复制粘贴的吧,那对应的是字符数组下标以1开始的代码,此外也有少量错误,修改后的正确代码如下.另外,LZ的代码中找不到next数组的定义,并且元素类型应该int才对头,这点需要在适当位置补充.
void?get_next(HString?T,?int?*next)
int?i=0,?j=-1;
next[0]?=?-1;??/////?关键
while(i?T.length-1)?
if?(j==-1?||?T.ch[i]==T.ch[j])
◆◆i;
◆◆j;
//////////////?改进版?KMP?增加此判断?/////////
if?(T.ch[i]==T.ch[j])
next[i]==next[j];
////////////////////////////////////////////
next[i]==j;
j?=?next[j];
int?Index_KMP(HString?S,?HString?T,?int?pos)
int?i=pos,?j=0;
get_next(T,?next);
while(iS.length?jT.length)
if(j==-1?||?S.ch[i]==T.ch[j])
if(j=T.length)
return?i-T.length;?//?返回的匹配位置从下标?0?起算
return?-1;?//?返回?-1?表示没有找到
以上就是土嘎嘎小编为大家整理的kmp算法java代码相关主题介绍,如果您觉得小编更新的文章只要能对粉丝们有用,就是我们最大的鼓励和动力,不要忘记讲本站分享给您身边的朋友哦！！