[100分]----->KMP算法问题<-----[100分]

method_01 2010-09-22 08:43:17
kmp算法是很简单的一个算法,数据结构书上第一个有用的代码了,但我不太理解,这个算法通用么?如果字符串本身重复的少,每次的回溯都是到第一个字符,那效率就很低了,而且比直接匹配更慢了,不是么?因为要先过滤一次匹配的字符串,那如果原字串和要匹配的字符串都很长的时候,这个next数组准备也要很多时间了呢。
请帮我解答这个疑惑,谢谢!
...全文
207 16 打赏 收藏 转发到动态 举报
写回复
用AI写文章
16 条回复
切换为时间正序
请发表友善的回复…
发表回复
method_01 2010-09-25
  • 打赏
  • 举报
回复
非常感谢。分不多。兄弟们担待点。
algorithms_memo兄弟的代码灰常好。
method_01 2010-09-24
  • 打赏
  • 举报
回复
十分感谢。出门,一会回来仔细阅读一下。
algorithms_memo 2010-09-24
  • 打赏
  • 举报
回复
KMP预处理阶段(计算函数next)也采用了KMP算法思想,实现复杂度为O(m)。
总时间复杂度为O(n+m),空间复杂度为O(m)。
如下为实现:

void yc_kmp_init(const char *str_patn, size_t sz_patn, size_t *psz_table)
{
size_t i, j;

assert ( str_patn );

psz_table[0] = 0;

for ( i = 1, j = 0; i < sz_patn; ++i )
{
while ( j > 0 && str_patn[j] != str_patn[i] )
{
j = psz_table[j-1];
}

if ( str_patn[j] == str_patn[i] )
{
++j;
}

psz_table[i] = j;
}
}

char * yc_kmp_find(const char *str_text, size_t sz_text, const char *str_patn, const size_t *psz_table, size_t sz_patn )
{
size_t i, j;

assert( str_text && str_patn && psz_table );

for ( i = 0, j = 0; i < sz_text; ++i )
{
while ( j && str_text[i] != str_patn[j])
{
j = psz_table[j - 1];
}

if ( str_text[i] == str_patn[j] )
{
++j;
}

if ( sz_patn == j )
{
return (char*)str_text + i + 1 - sz_patn;
}
}

return NULL;
}

char * yc_strstr_kmp(const char *str_text, const char *str_patn)
{
char *str_rtn = NULL;

size_t sz_patn, sz_text;

assert( str_text && str_patn );

sz_patn = strlen(str_patn);
sz_text = strlen(str_text);

if ( sz_patn && sz_text )
{
size_t *psz_table = (size_t*)malloc(sizeof(size_t)*sz_patn);

if ( psz_table )
{
yc_kmp_init(str_patn, sz_patn, psz_table);
str_rtn = yc_kmp_find(str_text, sz_text, str_patn, psz_table, sz_patn);
free(psz_table);
}
else
{
str_rtn = (char*)strstr(str_text, str_patn);
}
}

return str_rtn;
}
雪岢奇 2010-09-23
  • 打赏
  • 举报
回复
三. 怎么求串的模式值next[n]
定义:
(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)的其他情况。

举例:
01)求T=“abcac”的模式函数的值。
next[0]= -1 根据(1)
next[1]=0 根据 (4) 因(3)有1<=k<j;不能说,j=1,T[j-1]==T[0]
next[2]=0 根据 (4) 因(3)有1<=k<j;(T[0]=a)!=(T[1]=b)
next[3]= -1 根据 (2)
next[4]=1 根据 (3) T[0]=T[3] 且 T[1]=T[4]

下标 0 1 2 3 4
T a b c a c
next -1 0 0 -1 1

若T=“abcab”将是这样:
下标 0 1 2 3 4
T a b c a b
next -1 0 0 -1 0

为什么T[0]==T[3],还会有next[4]=0呢, 因为T[1]==T[4], 根据 (3)” 且T[j] != T[k]”被划入(4)。
02)来个复杂点的,求T=”ababcaabc” 的模式函数的值。
next[0]= -1 根据(1)
next[1]=0 根据(4)
next[2]=-1 根据 (2)
next[3]=0 根据 (3) 虽T[0]=T[2] 但T[1]=T[3] 被划入(4)
next[4]=2 根据 (3) T[0]T[1]=T[2]T[3] 且T[2] !=T[4]
next[5]=-1 根据 (2)
next[6]=1 根据 (3) T[0]=T[5] 且T[1]!=T[6]
next[7]=0 根据 (3) 虽T[0]=T[6] 但T[1]=T[7] 被划入(4)
next[8]=2 根据 (3) T[0]T[1]=T[6]T[7] 且T[2] !=T[8]

下标 0 1 2 3 4 5 6 7 8
T a b a b c a a b c
next -1 0 -1 0 2 -1 1 0 2

只要理解了next[3]=0,而不是=1,next[6]=1,而不是= -1,next[8]=2,而不是= 0,其他的好象都容易理解。
03) 来个特殊的,求 T=”abCabCad” 的模式函数的值。
下标 0 1 2 3 4 5 6 7
T a b C a b C a d
next -1 0 0 -1 0 0 -1 4


next[5]= 0 根据 (3) 虽T[0]T[1]=T[3]T[4],但T[2]==T[5]
next[6]= -1 根据 (2) 虽前面有abC=abC,但T[3]==T[6]
next[7]=4 根据 (3) 前面有abCa=abCa,且 T[4]!=T[7]
若T[4]==T[7],即T=” adCadCad”,那么将是这样:next[7]=0, 而不是= 4,因为T[4]==T[7].
下标 0 1 2 3 4 5 6 7
T a d C a d C a d
next -1 0 0 -1 0 0 -1 0


如果你觉得有点懂了,那么
练习:求T=”AAAAAAAAAAB” 的模式函数值,并用后面的求模式函数值函数验证。
意义:
next 函数值究竟是什么含义,前面说过一些,这里总结。
设在字符串S中查找模式串T,若S[m]!=T[n],那么,取T[n]的模式函数值next[n],
1. next[n]= -1 表示S[m]和T[0]间接比较过了,不相等,下一次比较 S[m+1] 和T[0]
2. next[n]=0 表示比较过程中产生了不相等,下一次比较 S[m] 和T[0]。
3. next[n]= k >0 但k<n, 表示,S[m]的前k个字符与T中的开始k个字符已经间接比较相等了,下一次比较S[m]和T[k]相等吗?
4. 其他值,不可能。

本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/Oneil_Sally/archive/2008/12/03/3440784.aspx
雪岢奇 2010-09-23
  • 打赏
  • 举报
回复
二. KMP匹配算法
还是相同的例子,在S=”abcabcabdabba”中查找T=”abcabd”,如果使用KMP匹配算法,当第一次搜索到S[5] 和T[5]不等后,S下标不是回溯到1,T下标也不是回溯到开始,而是根据T中T[5]==’d’的模式函数值(next[5]=2,为什么?后面讲),直接比较S[5] 和T[2]是否相等,因为相等,S和T的下标同时增加;因为又相等,S和T的下标又同时增加。。。最终在S中找到了T。如图:




KMP匹配算法和简单匹配算法效率比较,一个极端的例子是:
在S=“AAAAAA…AAB“(100个A)中查找T=”AAAAAAAAAB”, 简单匹配算法每次都是比较到T的结尾,发现字符不同,然后T的下标回溯到开始,S的下标也要回溯相同长度后增1,继续比较。如果使用KMP匹配算法,就不必回溯.
对于一般文稿中串的匹配,简单匹配算法的时间复杂度可降为O (m+n),因此在多数的实际应用场合下被应用。
KMP算法的核心思想是利用已经得到的部分匹配信息来进行后面的匹配过程。看前面的例子。为什么T[5]==’d’的模式函数值等于2(next[5]=2),其实这个2表示T[5]==’d’的前面有2个字符和开始的两个字符相同,且T[5]==’d’不等于开始的两个字符之后的第三个字符(T[2]=’c’).如图:

也就是说,如果开始的两个字符之后的第三个字符也为’d’,那么,尽管T[5]==’d’的前面有2个字符和开始的两个字符相同,T[5]==’d’的模式函数值也不为2,而是为0。
前面我说:在S=”abcabcabdabba”中查找T=”abcabd”,如果使用KMP匹配算法,当第一次搜索到S[5] 和T[5]不等后,S下标不是回溯到1,T下标也不是回溯到开始,而是根据T中T[5]==’d’的模式函数值,直接比较S[5] 和T[2]是否相等。。。为什么可以这样?
刚才我又说:“(next[5]=2),其实这个2表示T[5]==’d’的前面有2个字符和开始的两个字符相同”。请看图 :因为,S[4] ==T[4],S[3] ==T[3],根据next[5]=2,有T[3]==T[0],T[4] ==T[1],所以S[3]==T[0],S[4] ==T[1](两对相当于间接比较过了),因此,接下来比较S[5] 和T[2]是否相等。。。

有人可能会问:S[3]和T[0],S[4] 和T[1]是根据next[5]=2间接比较相等,那S[1]和T[0],S[2] 和T[0]之间又是怎么跳过,可以不比较呢?因为S[0]=T[0],S[1]=T[1],S[2]=T[2],而T[0] != T[1], T[1] != T[2],==> S[0] != S[1],S[1] != S[2],所以S[1] != T[0],S[2] != T[0]. 还是从理论上间接比较了。
有人疑问又来了,你分析的是不是特殊轻况啊。
假设S不变,在S中搜索T=“abaabd”呢?答:这种情况,当比较到S[2]和T[2]时,发现不等,就去看next[2]的值,next[2]=-1,意思是S[2]已经和T[0] 间接比较过了,不相等,接下来去比较S[3]和T[0]吧。
假设S不变,在S中搜索T=“abbabd”呢?答:这种情况当比较到S[2]和T[2]时,发现不等,就去看next[2]的值,next[2]=0,意思是S[2]已经和T[2]比较过了,不相等,接下来去比较S[2]和T[0]吧。
假设S=”abaabcabdabba”在S中搜索T=“abaabd”呢?答:这种情况当比较到S[5]和T[5]时,发现不等,就去看next[5]的值,next[5]=2,意思是前面的比较过了,其中,S[5]的前面有两个字符和T的开始两个相等,接下来去比较S[5]和T[2]吧。
总之,有了串的next值,一切搞定。那么,怎么求串的模式函数值next[n]呢?(本文中next值、模式函数值、模式值是一个意思。)

本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/Oneil_Sally/archive/2008/12/03/3440784.aspx
雪岢奇 2010-09-23
  • 打赏
  • 举报
回复
由于本人最近也是在研究算法,就把自己知道跟楼主说说。(参考网友)
KMP字符串模式匹配通俗点说就是一种在一个字符串中定位另一个串的高效算法。简单匹配算法的时间复杂度为O(m*n);KMP匹配算法。可以证明它的时间复杂度为O(m+n).。
一.简单匹配算法
先来看一个简单匹配算法的函数:
int Index_BF ( char S [ ], char T [ ], int pos )
{
/* 若串 S 中从第pos(S 的下标0≤pos<StrLength(S))个字符
起存在和串 T 相同的子串,则称匹配成功,返回第一个
这样的子串在串 S 中的下标,否则返回 -1 */
int i = pos, j = 0;
while ( S[i+j] != '\0'&& T[j] != '\0')
if ( S[i+j] == T[j] )
j ++; // 继续比较后一字符
else
{
i ++; j = 0; // 重新开始新的一轮匹配
}
if ( T[j] == '\0')
return i; // 匹配成功 返回下标
else
return -1; // 串S中(第pos个字符起)不存在和串T相同的子串
} // Index_BF
此算法的思想是直截了当的:将主串S中某个位置i起始的子串和模式串T相比较。即从 j=0 起比较 S[i+j] 与 T[j],若相等,则在主串 S 中存在以 i 为起始位置匹配成功的可能性,继续往后比较( j逐步增1 ),直至与T串中最后一个字符相等为止,否则改从S串的下一个字符起重新开始进行下一轮的"匹配",即将串T向后滑动一位,即 i 增1,而 j 退回至0,重新开始新一轮的匹配。
例如:在串S=”abcabcabdabba”中查找T=” abcabd”(我们可以假设从下标0开始):先是比较S[0]和T[0]是否相等,然后比较S[1] 和T[1]是否相等…我们发现一直比较到S[5] 和T[5]才不等。如图:


当这样一个失配发生时,T下标必须回溯到开始,S下标回溯的长度与T相同,然后S下标增1,然后再次比较。如图:
这次立刻发生了失配,T下标又回溯到开始,S下标增1,然后再次比较。如图:

这次立刻发生了失配,T下标又回溯到开始,S下标增1,然后再次比较。如图:



又一次发生了失配,所以T下标又回溯到开始,S下标增1,然后再次比较。这次T中的所有字符都和S中相应的字符匹配了。函数返回T在S中的起始下标3。如图:



本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/Oneil_Sally/archive/2008/12/03/3440784.aspx

本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/Oneil_Sally/archive/2008/12/03/3440784.aspx
wuyi8808 2010-09-23
  • 打赏
  • 举报
回复
[Quote=引用楼主 method_01 的回复:]
如果字符串本身重复的少,每次的回溯都是到第一个字符,那效率就很低了,而且比直接匹配更慢了,不是么?因为要先过滤一次匹配的字符串,那如果原字串和要匹配的字符串都很长的时候,这个next数组准备也要很多时间了呢。
[/Quote]

KMP算法的优点是不需要在正文中回溯,比较适用于正文很长且存储在读取较慢且不容易回溯的外设(如磁带)的情形。缺点是搜索前事先构造模式需要一定的时间。
method_01 2010-09-23
  • 打赏
  • 举报
回复
能否有人帮忙给个for循环写的实现?
method_01 2010-09-23
  • 打赏
  • 举报
回复
弄了一上午,居然没实现出来。虽然网上有很多的例子,算法的意思也看懂了。但就是没写出来。囧。这么多年的开发经验,看来真是0.
showjim 2010-09-23
  • 打赏
  • 举报
回复
KMP确实是线性时间的O(m+n),因为next数组的生成也是线性时间的(和匹配过程类似),一般都不会比回溯的O(m*n)的效率低。它是一种通用的稳定算法。
因为KMP算法的基本法则是肯定的,也就是每一次匹配都必须比较,所以在实际应用中并不算高效(比如语言匹配)。如果基于hash的否定算法,可以匹配多次以后比较一次,减少比较次数。平均性能要提高几倍,当然极端情况可能比KMP慢(主要取决于hash方法)。另外,从尾部向前匹配的贪婪算法在实际应用中也比KMP高效,匹配过程最好的情况是O(n/m),最坏也就O(n),模式生成类似于KMP也是O(m),不过模式生成比KMP需要额外指针空间,不过不是一种通用算法,只适用于字节匹配或双字节匹配。在很多匹配确定串的时候,还有一种关键点匹配法,复杂度是低于O(n)的,但是适用范围有限。
如果在未知条件下需要一个稳定的时间复杂度,可以选择KMP或后缀数组。
绿色夹克衫 2010-09-23
  • 打赏
  • 举报
回复
构造模式串也是线性时间,因此总的复杂度是O(m+n)的,不会是n^2,如果说比朴素的方法慢,也是常数范围,如果碰上特殊的串,会快很多。
air_snake 2010-09-22
  • 打赏
  • 举报
回复
KMP可以同时搜寻多个字符串,automata实现,这种情况下也还是很好的。
使用failure function的复杂度是O(n),n是匹配string的长度
总的复杂度是O(m+n),是连个字符串的长度。夫复何求。
WizardOz 2010-09-22
  • 打赏
  • 举报
回复
楼主的说法基本正确,生成数组的过程本生复杂度比较高。对于普通的字符串,直接匹配的算法也很好了。
WizardOz 2010-09-22
  • 打赏
  • 举报
回复
KMP在匹配阶段只会快不会慢啊。如果要慢的话,可能在子串很长的情况下会比较慢,因为生成自动机的算法是O(n^2)复杂度的。
air_snake 2010-09-22
  • 打赏
  • 举报
回复
如果字符串本身重复的少,每次的回溯都是到第一个字符,那效率就很低了,而且比直接匹配更慢了,不是么?

这个好像不对吧。不会比直接比较的次数更多了吧。
air_snake 2010-09-22
  • 打赏
  • 举报
回复
分析的都是worst case。你说的没错。但一般情况下是在很长的一篇文章中,搜短的吧。
1.算法是程序的灵魂,优秀的程序在对海量数据处理时,依然保持高速计算,就需要高效的数据结构和算法支撑。2.网上数据结构和算法的课程不少,但存在两个问题:1)授课方式单一,大多是照着代码念一遍,数据结构和算法本身就比较难理解,对基础好的学员来说,还好一点,对基础不好的学生来说,基本上就是听天书了2)说是讲数据结构和算法,但大多是挂羊头卖狗肉,算法讲的很少。 本课程针对上述问题,有针对性的进行了升级 3)授课方式采用图解+算法游戏的方式,让课程生动有趣好理解 4)系统全面的讲解了数据结构和算法, 除常用数据结构和算法外,还包括程序员常用10大算法:二查找算法(非递归)、治算法、动态规划算法、KMP算法、贪心算法、普里姆算法、克鲁斯卡尔算法、迪杰斯特拉算法、弗洛伊德算法、马踏棋盘算法。可以解决面试遇到的最短路径、最小生成树、最小连通图、动态规划等问题及衍生出的面试题,让你秒杀其他面试小伙伴3.如果你不想永远都是代码工人,就需要花时间来研究下数据结构和算法。教程内容:本教程是使用Java来讲解数据结构和算法,考虑到数据结构和算法较难,授课采用图解加算法游戏的方式。内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、选择排序、插入排序、快速排序、归并排序、希尔排序、基数排序(桶排序)、堆排序、排序速度析、二查找、插值查找、斐波那契查找、散列、哈希表、二叉树、二叉树与数组转换、二叉排序树(BST)、AVL树、线索二叉树、赫夫曼树、赫夫曼编码、多路查找树(B树B+树和B*树)、图、图的DFS算法和BFS、程序员常用10大算法、二查找算法(非递归)、治算法、动态规划算法、KMP算法、贪心算法、普里姆算法、克鲁斯卡尔算法、迪杰斯特拉算法、弗洛伊德算法马踏棋盘算法。学习目标:通过学习,学员能掌握主流数据结构和算法的实现机制,开阔编程思路,提高优化程序的能力。

33,006

社区成员

发帖
与我相关
我的任务
社区描述
数据结构与算法相关内容讨论专区
社区管理员
  • 数据结构与算法社区
加入社区
  • 近7日
  • 近30日
  • 至今
社区公告
暂无公告

试试用AI创作助手写篇文章吧