KMP算法

@KMP算法

KMP算法

KMP算法用于字符串查找，将暴力破解方法的O(n²)复杂度降低到O(n)

其主要分为两部分：next数组求法(子串的部分匹配值)，主子串的比较

本次对next数组求法详细分析，主子串的比较略分析

求next数组前，先理解前后缀概念
"部分匹配值"就是"前缀"和"后缀"的最长的共有元素的长度。
以"ABCDABAD"为例，

－　"A"的前缀和后缀都为空集，共有元素的长度为0；

－　"AB"的前缀为[A]，
　　 后缀为[B]，
　　 共有元素的长度为0；

－　"ABC"的前缀为[A, AB]，
　　 后缀为[BC, C]，
　　 共有元素的长度0；

－　"ABCD"的前缀为[A, AB, ABC]，
　　 后缀为[BCD, CD, D]，
　　 共有元素的长度为0；

－　“ABCDA"的前缀为[A, AB, ABC, ABCD]，
　　 后缀为[BCDA, CDA, DA, A]，
　　 共有元素为"A”，长度为1；

－　“ABCDAB"的前缀为[A, AB, ABC, ABCD, ABCDA]，
　　 后缀为[BCDAB, CDAB, DAB, AB, B]，
　　 共有元素为"AB”，长度为2；

－　“ABCDABA"的前缀为[A, AB, ABC, ABCD, ABCDA, ABCDAB]，
　　 后缀为[BCDABA, CDABA, DABA, ABA, BA, A]，
　　 共有元素为"A”，长度为1。
　　－　" "ABCDABAD"的前缀为[A, AB, ABC, ABCD, ABCDA, ABCDAB，ABCDAB]，
　　 后缀为[BCDABAD, CDABAD, DABAD, ABAD, BAD, AD, D]，
　　 共有元素的长度为0。

next数组求法

仍以"ABCDABAD"为例：
next数组的含义为：当子串此字符和主串当前字符不匹配时，字串中下一个和主串当前字符进行比较的字符的位置(及向右一位存放部分匹配值)

子串	A	B	C	D	A	B	A	D
next数组	-1	0	0	0	0	1	2	1

那么如何求next？
思想：
s:子串
j:当前位置
i:当前位置的部分匹配值（"前缀"和"后缀"的最长的共有元素的长度）
有四种情况：
情况一：若i=-1，即未开始，则将i移到首位且当前位置移到1（i++，j++）
情况二：若当前位置j的字符若和匹配i的字符相同，则部分匹配值加1且当前位置和匹配位置都后移（j++, i++, next[j] = i）;
情况三：若i≠0，当前位置j的字符若和匹配i的字符不同，则移到首位（i = 0）；
情况四：若i=0，即匹配i的字符在首位，当前位置j的字符若和匹配i的字符不同，则当前位置后移且部分匹配值为0（j++，i=0, next[j] = 0)

以"ABCDABD"为例分析：
初始 ：s=“ABCDABAD”,i=-1,j=0

1. i = -1 ，情况一，则i++，j++(i=0,j=1)
2. s[j] ≠ s[i] (B ≠ A),i=0 情况四，则 j++,next[j] = 0(i=0, j=2)
3. s[j] ≠ s[i] (C ≠ A),i=0 情况四，则 j++,next[j] = 0(i=0, j=3)
4. s[j] ≠ s[i] (D ≠ A),i=0 情况四，则 j++,next[j] = 0(i=0, j=4)
5. s[j] = s[i] (A = A) 情况二， 则j++,i++,next[j] = i（i=1, j=5）
6. s[j] = s[i] (B = B) 情况二， 则j++,i++,next[j] = i（i=2, j=6）
7. s[j] ≠ s[i] (A ≠ C), i ≠ 0 情况三，则i=0 (i=0, j=6)
8. s[j] = s[i] (A = A) 情况二，则j++,i++,next[j] = i（i=1, j=7）
9. j到字符串最后，结束

代码：

 void getNext(string str,int *next)
     {
     //j:当前位置
     //i:当前位置的部分匹配值（"前缀"和"后缀"的最长的共有元素的长度）
         int i = -1,j = 0;
         next[0] = -1;//开始位置已经在最左边了，令其为-1作标志
         while (j < str.length()-1)
         {
             if(i==-1 || str[j] == str[i])//i 为-1即未开始，或者前后缀有共有元素长度为i（顺序不可变）
             {
                 //++j ：右移一位存储部分匹配值，移到下一个字符
                 //++i ：部分匹配值加一，移到下一个字符
                next[++j] =++i;
             }else{//前后缀不同
                 if(i ！= 0)
                 {
                     i = 0;//部分匹配值为0，移到首位，以便当前字符和首位字符的比较                     
                 }else{
                     //++j ：右移一位存储部分匹配值，移到下一个字符
                     next[++j] = i;//i= 0
                 }
             }
         }
     }

next数组进化论：

子串	A	B	C	D	A	B	A	D
next数组	-1	0	0	0	0	1	2	1

变为：

子串	A	B	C	D	A	B	A	D
next数组	-1	0	0	0	0	0	2	1

为什么？
来看第一个例子：
显然，当我们上边的算法得到的next数组应该是[ -1，0，0，1 ]

所以下一步我们应该是把j移动到第1个元素咯：

不难发现，这一步是完全没有意义的。因为后面的B已经不匹配了，那前面的B也一定是不匹配的
参考：https://www.cnblogs.com/yjiyjige/p/3263858.html

代码：

void getNext(string str,int *next)
     {
         int i = -1,j = 0;
         next[0] = -1;//开始位置已经在最左边了，令其为-1作标志
         while (j < str.length()-1)
         {
             if(i==-1 || str[j] == str[i])//i 为-1即未开始，或者前后缀有共有元素长度为i（顺序不可变）
             {
                 //++j ：右移一位存储部分匹配值，移到下一个字符
                 //++i ：部分匹配值加一，移到下一个字符
//^^^^^^^^^^^^^^^^^^^^^^^变化部分^^^^^^^^^^^^^^^^^^^^^^^^
                if(str[++j] == str[++i])//"abab"第二个'b'不匹配，则第一个'b'必不匹配
                 {
                     next[j] = next[i];
                 }else{
                     next[j] = i;
                 }
                  //next[++j] = ++i;
//^^^^^^^^^^^^^^^^^^^^^^^变化部分^^^^^^^^^^^^^^^^^^^^^^^^             
             }else{//前后缀不同
                 if(i ！= 0)
                 {
                     i = 0;//部分匹配值为0，移到首位，以便当前字符和首位字符的比较        
                 }else{
                     //++j ：右移一位存储部分匹配值，移到下一个字符
                     next[++j] = i;//i= 0
                 }
             }
         }
     }

主子串的比较

当准备好next数组，进行主串和子串的比较，思想和找next相似

主串的索引不回溯，从开始到结尾
当主串的当前字符，和子串当前字符相同时，都后移
当主串的当前字符，和子串当前字符不相同时，子串索引移到其对应的next位置再比较

代码：

int KMP(string &source, string &target) { 
        //KMP
        if(target.length() ==0)//子串为空
        {
             return 0;
        }
        else{
             if(source.length() == 0)//主串为空
             return -1;
        }
        //获得next数组
        int * next = new int[target.length()];
        getNext(target,next);
        
        int indexs = 0,indext = 0;
        
        while (indexs < (int)source.length() && indext < (int)target.length())
        {
            if(indext == -1 || source[indexs] == target[indext] )
            {
                indexs++;
                indext++;
            }else{
                indext = next[indext];
            }
        }
        
        if(indext == target.length())
        {
             return indexs - indext;
        }else{           
            return -1;
        }
    }