Ⅰ 在主字符串中查找子串的KMP算法和字符串中查找字符用KMP算法的C语言代码
/***KMP算法是对蛮力算法的优化，原理很简单。但存在最坏情况，时间复杂度很可能会崩坏到(m+n)。
* 推荐在高频度数据查找采用优化的Boyer-Moore算法。
*以下为代码
***/
/***首先创建一个ADT，这里给出最简形式，省略部分涉及不到的操作***/
ADT String
{voidStrAssign（SString &T，char*S）//值为S的串T
bool SreEmpty(SString &S) //判断空串
int StrLength(SString &s) //返回长度
void Concat (SString &T,SString&S1,SString &S2)//返回组合的新串
void SubString (SString &Sub,SString &S,int pos, int len)//同串则返回第pos后的串的最初位置，否则为0
}
/***算法部分***/
int KMP(char *T,char *p)
{int n=strlen(T);
int m=strlen(P);
int i,j;
for(i=0;i<n-m;i++)
{j=0;
while(j<m&&T[i+j]==P[j])j++;
if(j==m) return i;
}
return -1}
Ⅱ 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算法写的完整程序，麻烦您了
自己写的测试了几个结果是对的
性能没有好的数据测试
仅供参考，主要靠你自己
/////////////////////////////////c++////////////////////////////////////////////////////
#include<iostream>
#include<string>
#include<cmath>
using namespace std;
int *next;
string mString;
string nString;
void getNext(string n)
{
next=new int[n.length()];
char nHead=n[0];
for(int j=0;j<n.length();j++)
{
next[j]=0;
for(int i=j-1;i>(j)/2;i--)
{
if(n[i]==nHead)
{
int tHead=i;
int tEnd=j-1;
int count=0;
for(int h=tHead;h<=tEnd;h++)
{
if(n[count++]!=n[h])
break;
}
if((count==tEnd-tHead+1)&&n[count]!=n[j])
next[j]=count;
}
}
}
}
int main()
{
cout<<"input main String please!"<<endl;
cin>>mString;
cout<<"input sub String please!"<<endl;
cin>>nString;
getNext(nString);
int pos;//第一个匹配模式的首字母的实际位置
for(int i=0,j=0;i<=mString.length()&&j<=nString.length();)
{
if(j==nString.length())
{
pos=i-j+1;
cout<<"successed and start postion is "<<pos<<endl;
delete[]next;
return 0;
}
if(mString[i]!=nString[j])
{
if(j==0)
i++;
else
j=next[j];
}
else
{
i++;
j++;
}
}
cout<<"failed!"<<endl;
delete[]next;
return 0;
}
Ⅳ 求kmp算法的详细解释。（最好附上能运行的程序）
t;i),那么next[i]就是所有这样的j的最大值
形象地说,就是假如第i 1个字符匹配失败之后,下一个可能匹配位置至少应该往后挪动多少
就"abaabc"而言
next[1]=0
next[2]=0
next[3]=1
next[4]=1
next[5]=2
next[6]=0
计算过程基本上抄自算法导论,假设str长度为n
k=0;//k表示当前匹配了多少位
next[1]=0;
for (i=1;in;i )
{
while (k
Ⅳ java中String的int indexof(String)方法是用什么算法实现的，是KMP吗
不是KMP算法，自己看看源码就知道了。
至于原因:
KMP对特殊的字符串比较好用 就是自身带有很多重复子串的那种
在字符串不长的情况下 KMP比较耗时
Ⅵ kmp算法完整代码（C++）谢谢！
刚学应该仔细看书，首先要学会自己用手一步一步模拟计算的过程，把中间步骤记录下来，作为测试用例。复杂算法居然直接看代码，你认为自己很牛吗？
Ⅶ kmp模式Java编程需要学吗
kmp模式，是指进行字符串比较：
此算法是由D.E.Knuth，J.H.Morris和V.R.Pratt同时发现的，因此该算法被称为克努斯-莫里斯-普拉特操作，简称为KMP算法。
KMP算法，是不需要对目标串S进行回溯的模式匹配算法。读者可以回顾上面的例子，整个过程中完全没有对目标串S进行回溯，而只是对模式串T进行了回溯。通过前面的分析，我们发现这种匹配算法的关键在于当出现失配情况时，应能够决定将模式串T中的哪一个字符与目标串S的失配字符进行比较。所以呢，那三位前辈就通过研究发现，使用模式串T中的哪一个字符进行比较，仅仅依赖于模式串T本身，与目标串S无关。
这里就要引出KMP算法的关键所在next数组，next数组的作用就是当出现失配情况S[i] != T[j]时，next[j]就指示使用T中的以next[j]为下标的字符与S[i]进行比较（注意在KMP算法中，i是永远不会进行回溯的）。还需要说明的是当next[j] = -1时，就表示T中的任何字符都不与S[i]进行比较，下一轮比较从T[0]与S[i+1]开始进行。由此可见KMP算法在进行模式匹配之前需要先求出关于模式串T各个位置上的next函数值。即next[j]，j = 0,1,2,3,...n-1。
如果你是研究底层算法的话，要了解一下，如果你是做应用开发的话，了解一下就可以了，这是数据结构方面的内容。
Ⅷ KMP算法详细代码
private int KMP(String inText, String inMode)
{
if (inText.Length < inMode.Length)
{
return -1;
}
int[] arrNext = new int[inMode.Length + 1];
this.Next(inMode, arrNext);
int i, j; // i是主串游标 j是模式串游标
for (i = j = 0; i < inText.Length && j < inMode.Length; )
{
if (j == -1 || // 模式串游标已经回退到第一个位置
inText[i] == inMode[j]) // 当前字符匹配成功
{ // 满足以上两种情况时两个游标都要向前进一步
++i;
++j;
}
else // 匹配不成功,模式串游标回退到当前字符的arrNext值
{
j = arrNext[j];
}
}
if (j >= inMode.Length)
{
return i - inMode.Length;
}
else
{
return -1;
}
}
private void Next(String inMode, int[] arrNext)
{
arrNext[0] = -1;
for (int i = 0, j = -1; i < inMode.Length; )
{ // i是主串游标 j是模式串的游标
if (j == -1 || // 如果模式串游标已经回退到第一个字符
inMode[i] == inMode[j]) // 如果匹配成功
{ // 两个游标都向前走一步
++i;
++j;
arrNext[i] = j; // 存放当前的arrNext值为此时模式串的游标值
}
else // 匹配不成功j就回退到上一个arrNext值
{
j = arrNext[j];
}
}
}
Ⅸ KMP算法 看看代码哪里错了
搞定了请采纳最佳答案
#include<stdio.h>
#include<string.h>
voidgetnext(charT[],int*next)
{
inti,j;
i=0;
j=-1;
next[0]=-1;
while(i<strlen(T))
{
if(j==-1||T[i]==T[j])
{
next[i+1]=j+1;
i++;
j++;
}
else
j=next[j];
}
}
intKMP(charS[],charT[])
{
inti=0,j=0,next[100];
getnext(T,next);
while(i<strlen(S)&&j<strlen(T))
{
if(j==0||S[i]==T[j])
{
i++;
j++;
}
else
{
j=next[j];
}
}
if(j>=strlen(T))
returni-strlen(T);
else
return-1;
}
voidmain()
{
charS[100],T[100];
printf("请输入主字符串S ");
gets(S);
printf("请输入子字符串T ");
gets(T);
printf("位置%d",KMP(S,T));
}
Ⅹ 急！kmp算法代码
LZ的get_next函数和Index_KMP函数的代码是复制粘贴的吧，那对应的是字符数组下标以1开始的代码，此外也有少量错误，修改后的正确代码如下。另外，LZ的代码中找不到next数组的定义，并且元素类型应该int才对头，这点需要在适当位置补充。
voidget_next(HString&T,int*next)
{
inti=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];
else
////////////////////////////////////////////
next[i]==j;
}
else
j=next[j];
}
}
intIndex_KMP(HString&S,HString&T,intpos)
{
inti=pos,j=0;
get_next(T,next);
while(i<S.length&&j<T.length)
{
if(j==-1||S.ch[i]==T.ch[j])
{
++i;
++j;
}
else
j=next[j];
}
if(j>=T.length)
returni-T.length;//返回的匹配位置从下标0起算
else
return-1;//返回-1表示没有找到
}