另外有关模式函数值next,将主串S中某个位置i起

2020-01-05 19:23 来源:未知

从头到尾彻底理解KMP(2014年8月22日版)

KMP字符串模式匹配通俗点说就是一种在一个字符串中定位另一个串的高效算法。简单匹配算法的时间复杂度为O(m*n),KMP匹配算法,可以证明它的时间复杂度为O(m+n).。

一.简单匹配算法

先来看一个简单匹配算法的函数:

//简单的字符串匹配算法

#include <iostream>

using namespace std;

int Index_BF(char s[], char T[], int pos)
{
    int i = pos, j = 0;
    while (s[i+j]!=''&&T[j]!='')
    {
        if (s[i+j]==T[j])
        {
            j++;    //继续比较后一字符
        }
        else
        {
            i++;
            j = 0;   //重新开始新一轮的匹配
        }
    }
    if (T[j] == '')
    {
        return i; //匹配成功返回下标
    }
    else
        return -1; //串s中(第pos个字符起)不存在和串T相同的子串
}

int matchString(const string& target,const string& pattern)
{
    int target_size = target.size();
    int pattern_size = pattern.size();
    int target_index = 0;
    int pattern_index = 0;
    if (target_size<=0||pattern_size<=0||target_size<pattern_size)
    {
        return -1;
    }
    while (target_index<target_size&&pattern_index<pattern_size)//  不能有等于号
    {
        if (target[target_index]==pattern[pattern_index])
        {
            target_index++;
            pattern_index++;
        }
        else
        {
            target_index = target_index - pattern_index + 1;  //当前标志-匹配的长度+1
            pattern_index = 0;
        }
    }
    if (pattern_index==pattern_size&&target_index<=target_size)
    {
        return target_index - pattern_size ;
    }
    else
    {
        return -1;
    }
}

int main()
{
    cout << "第一种方法:" << Index_BF("banananobano", "nano", 0) << endl;

    cout << "第二种方法:"<<matchString("banananobano", "nano")<<endl;

    return 0;
}

 

此算法的思想是直截了当的:将主串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]才不等。如图:

永利平台娱乐 1

 

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

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

永利平台娱乐 2

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

永利平台娱乐 3

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

永利平台娱乐 4

二. 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。如图:

永利平台娱乐 5

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’).如图:

永利平台娱乐 6

也就是说,如果开始的两个字符之后的第三个字符也为’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]是否相等。。。

永利平台娱乐 7

有人可能会问: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值、模式函数值、模式值是一个意思。)

三. 怎么求串的模式值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. 其他值,不可能。

四. 求串T的模式值next[n]的函数

void get_nextval(const char *T, int next[])
{
    // 求模式串T的next函数值并存入数组 next。
    int j = 0, k = -1;
    next[0] = -1;
    while (T[j] != '/0')
    {
        if (k == -1 || T[j] == T[k])
        {
            ++j;
            ++k;
            if (T[j] != T[k])
                next[j] = k;
            else
                next[j] = next[k];
        }// if
        else
            k = next[k];
    }// while

}

//下面是KMP模式匹配程序


int KMP(const char *Text, const char* Pattern) //const 表示函数内部不会改变这个参数的值。
{
    if (!Text || !Pattern || Pattern[0] == '' || Text[0] == '')//
        return -1;//空指针或空串,返回-1。
    int len = 0;
    const char *c = Pattern;
    while (*c++ != '')//移动指针比移动下标快。
        ++len;//字符串长度。
    int *next = new int[len + 1];
    get_nextval(Pattern, next);//求Pattern的next函数值
    int index = 0, i = 0, j = 0;
    while (Text[i] != '' && Pattern[j] != '')
    {
        if (Text[i] == Pattern[j])
        {
            ++i;// 继续比较后继字符
            ++j;
        }
        else
        {
            index += j - next[j];
            if (next[j] != -1)
                j = next[j];// 模式串向右移动
            else
            {
                j = 0;
                ++i;
            }
        }
    }//while
    delete[]next;
    if (Pattern[j] == '')
        return index;// 匹配成功,返回匹配首字符下标
    else
        return -1;
}
//测试程序:


int main()
{
    char* text = "abcdefgh123456789465asdac789asd4654qw5e46a1";
    char*pattern = "4654qw";
    int pos = KMP(text, pattern);
    if (pos == -1)
        printf("无法找到匹配字符串!n");
    else
        printf("匹配成功!匹配首字符下标:%dn", pos);
    system("pause");
    return 0;
}

int kmp_find(const string& target,const string& pattern)
{
    const int target_length = target.size();
    const int pattern_length = pattern.size();
    int* overlay_value = new int[pattern_length];
    int index;
    overlay_value[0] = -1;
    for (int i = 1; i < pattern_length; i++)
    {
        index = overlay_value[i - 1];  //存储先前匹配失败的位置
        while (index >= 0 && pattern[i] != pattern[index + 1])  // pattern[i]!=pattern[index+1]
        {
            index = overlay_value[index];  //
        }
        if (pattern[i] == pattern[index + 1])
        {
            overlay_value[i] = index + 1;
        }
        else
        {
            overlay_value[i] = -1;
        }
    }
    //匹配算法
    int pattern_index = 0;
    int target_index = 0;
    while (pattern_index<pattern_length&&target_index<target_length)
    {
        if (target[target_index]==pattern[pattern_index])
        {
            ++target_index;
            ++pattern_index;
        }
        else if (pattern_index==0)
        {
            ++target_index;
        }
        else
        {
            pattern_index = overlay_value[pattern_index - 1] + 1;
        }
    }
    if (pattern_index == pattern_length)
    {
        return target_index - pattern_index;
    }
    else
        return -1;
    delete[] overlay_value;

}

int main()
{
    string source = "annbcdanacadsannannabnna";
    string pattern = "annacanna";
    cout << "第一种方法:" << Index_BF("banananobano", "nano", 0) << endl;

    cout << "第二种方法:" << matchString(source, pattern) << endl;

    cout << "kmp:" << kmp_find(source,pattern) << endl;;
    string pattern1 = "abaabcaba";
    compute_overlay(pattern1);

    return 0;
}

 

参考:http://blog.csdn.net/caoyan_12727/article/details/52556327

http://blog.csdn.net/sjf0115/article/details/8579484
KMP字符串模式匹配通俗点说就是一种在一个字符串中定位另一个串的高效算法。简单匹配算法的时间复杂度为O(m*n);KMP匹配算法。可以证明它的时间复杂度为O(m+n).。
</br>
在S=”abcabcabdabba”中查找T=”abcabd”,如果使用KMP匹配算法,当第一次搜索到S[5] 和T[5]不等后,S下标不是回溯到1,T下标也不是回溯到开始,而是根据T中T[5]==’d’的模式函数值(next[5]=2,为什么?后面讲),直接比较S[5] 和T[2]是否相等。
</br>
所以这个模式函数是怎么得到的?
定义:

个人觉得这篇文章是网上的介绍有关KMP算法更让人容易理解的文章了,确实说得很“详细”,耐心地把它看完肯定会有所收获的~~,另外有关模式函数值next[i]确实有很多版本啊,在另外一些面向对象的算法描述书中也有失效函数 f(j)的说法,其实是一个意思,即next[j]=f(j-1)+1,不过还是next[j]这种表示法好理解啊:

  • (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)。

                                          KMP字符串模式匹配详解

KMP字符串模式匹配通俗点说就是一种在一个字符串中定位另一个串的高效算法。简单匹配算法的时间复杂度为O(m*n);KMP匹配算法。可以证明它的时间复杂度为O(m+n).。

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)的其他情况。


链接:https://www.nowcoder.com/questionTerminal/57bdf294407c4477969fc7b4d56c7be7来源:牛客网首先看看next数组值的求解方法例如: 
模式串 a b a a b c a c 
next值 0 1 1 2 2 3 1 2               
next数组的求解方法是:
第一位的next值为0,第二位的next值为1,后面求解每一位的next值时,根据前一位进行比较。首先将前一位与其next值对应的内容进行比较,如果相等,则该位的next值就是前一位的next值加上1;如果不等,向前继续寻找next值对应的内容来与前一位进行比较,直到找到某个位上内容的next值对应的内容与前一位相等为止,则这个位对应的值加上1即为需求的next值;如果找到第一位都没有找到与前一位相等的内容,那么需求的位上的next值即为1。       
看起来很令人费解,利用上面的例子具体运算一遍。       
1.前两位必定为0和1。       
2.计算第三位的时候,看第二位b的next值,为1,则把b和1对应的a进行比较,不同,则第三位a的next的值为1,因为一直比到最前一位,都没有发生比较相同的现象。       
3.计算第四位的时候,看第三位a的next值,为1,则把a和1对应的a进行比较,相同,则第四位a的next的值为第三位a的next值加上1。为2。因为是在第三位实现了其next值对应的值与第三位的值相同。       
4.计算第五位的时候,看第四位a的next值,为2,则把a和2对应的b进行比较,不同,则再将b对应的next值1对应的a与第四位的a进行比较,相同,则第五位的next值为第二位b的next值加上1,为2。因为是在第二位实现了其next值对应的值与第四位的值相同。       
5.计算第六位的时候,看第五位b的next值,为2,则把b和2对应的b进行比较,相同,则第六位c的next值为第五位b的next值加上1,为3,因为是在第五位实现了其next值对应的值与第五位相同。       
6.计算第七位的时候,看第六位c的next值,为3,则把c和3对应的a进行比较,不同,则再把第3位a的next值1对应的a与第六位c比较,仍然不同,则第七位的next值为1。       
7.计算第八位的时候,看第七位a的next值,为1,则把a和1对应的a进行比较,相同,则第八位c的next值为第七位a的next值加上1,为2,因为是在第七位和实现了其next值对应的值与第七位相同。

复杂度:O(n+m)

一.简单匹配算法

先来看一个简单匹配算法的函数:

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] != ''&& T[j] != '')

if ( S[i+j] == T[j] )

j ++; // 继续比较后一字符

else

{

i ++; j = 0; // 重新开始新的一轮匹配

}

if ( T[j] == '')

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]才不等。如图:

TAG标签:
版权声明:本文由永利平台娱乐发布于新闻动态,转载请注明出处:另外有关模式函数值next,将主串S中某个位置i起