串（Sequence）

在本章节内容中研究的串是开发中熟悉的字符串，大家都知道，字符串是由若干个字符组成的有限序列。

例如有下图所示的字符串，可以看到该字符串有5个字符组成

其中，字符串thank的前缀（prefix），真前缀（proper prefix），后缀（suffix），真后缀（proper suffix），表示如下

可以看出，前缀与真前缀的区别，后缀与真后缀的区别在于前缀/后缀可以是自己，真前缀/真后缀不可以是自己。

串匹配算法

本章节主要研究串的匹配问题，例如

通过一个模式串（Pattern）在文本串（Text）中的位置，例如下面代码

String text = "Hello world";
String pattern = "or";
text.indexOf(pattern);//7
text.indexOf("other");//-1

通过一个模式串，在文本中查找位置，如果找到，则返回对应的索引，如果找不到，返回-1。通过对串匹配算法的讨论，研究哪一种算法更加高效。

以下为常见的几个经典串匹配算法

1. 蛮力（Brute Force）
2. KMP
3. Boyer-Moore
4. Rabin-Karp
5. Sunday

由于后面内容会经常使用到Text的长度与Pattern的长度，因此后面将Text长度简写为tlen，将Pattern长度简写为plen。

蛮力（Brute Force）

以字符为单位，从左到右移动模式串，直到匹配成功为止。

例如文本串如下图所示

模式串如下图所示

从左到右进行匹配，如果模式串中的第一个字符匹配成功，这继续往后进行匹配，如果匹配失败，则模式串从文本串的下一个字符进行匹配，一直重复。直到匹配成功或者匹配完所有的文本串为止。

根据这种方式，上面文本串与模式串的匹配流程如下

这种匹配算法，常见的实现方式有如下两种

方式一：
执行过程如下

定义两个变量pi,ti，其中pi表示正在参与比较的模式串索引，ti表示正在参与比较的文本串索引，如下图

所以

• pi的取值范围为[0,plen)
• ti的取值范围为[0,tlen)

如果当前索引的文本匹配成功，则将两个索引往后移动1个位置，即

• pi++
• ti++

然后继续比较，发现当前索引的文本依然是成功的，所以会将两个索引往后移动1个位置，结果如下

发现在当前索引时，比较依然是成功的，所以会继续将两个索引往后移动1个位置，现在，将注意力放到pi和ti的下一个索引位置，当pi与ti都变为3时，匹配失败了

当匹配失败时，则将pi置为0，ti置为ti - pi + 1；重置了索引以后的结果如下

现在继续进行匹配，在当前索引时(pi = 0 ,ti = 1)时，就匹配失败了，因此再次重置pi与ti的值。

通过这样一直重复，当pi等于plen时，则说明最终匹配到了所有的文本

最终的返回的索引值为ti - pi

所以，根据上面的分析步骤，转换为代码的结果如下

public static int indexOf(String text, String pattern) {
    if (text == null || pattern == null) return -1;
    char[] textChars = text.toCharArray();
    int tlen = textChars.length;
    if (tlen == 0) return -1;
    char[] patternChars = pattern.toCharArray();
    int plen = patternChars.length;
    if (plen == 0) return -1;
    if (tlen < plen) return -1;

    int pi = 0, ti = 0;
    while (pi < plen && ti < tlen) {
        if (textChars[ti] == patternChars[pi]) {
            ti++;
            pi++;
        } else {
            ti -= pi - 1;
            pi = 0;
        }
    }
    if (pi == plen) {
        //说明找到了
        return ti - pi;
    }
    return -1;
}

优化

前面这种实现方法，其实可以在恰当的时候提前退出，这样可以减少比较次数

例如在如下图所示的情况下

此时比较失败，所以pi和ti的值都会重置，终止后进行比较，最终的结果如下

在这种情况下， 模式串匹配的字符已经超过了文本串的索引，最终的结果一定是失败，所以在这种情况下，前面的3次比较结果都是无效的

所以，在这种情况下，可以将退出条件从ti < tlen修改为 ti - pi <= tlen - plen.其中ti - pi表示为每一轮比较中Text首个比较字符的位置，所以可以将while循环条件进行优化

了解了蛮力算法的第一种实现以后，继续研究这种算法的另外一种实现。

方式二：

首先，与前面的实现一样，定义两个变量pi与ti，分别记录当前正在比较的索引

当比较成功时，前面是pi与ti都进行+1操作，现在不使用这种方式，现在的做法是pi进行+1，文本串中进行比较的索引，利用pi + ti来进行表示；如下图所示

pi = 1时比较又是成功的，所以继续往后比较，结果如下

继续进行比较，结果如下

到这一步pi =3时，发现匹配失败，所以，则只需要将pi重置为0，ti执行+1操作即可，继续进行比较，结果如下

又比较失败，继续执行pi重置为0，ti +1的操作，一直重复上面的步骤，知道pi == plen时，最终匹配成功，结果如下

最终，如果采用这种做法来实现，pi与ti的取值范围分别如下

• pi 的取值范围为[0,plen)
• ti 的取值范围为[0,tlen - plen)

根据这种思路，实现的代码如下

public static int indexOf(String text, String pattern) {
    if (text == null || pattern == null) return -1;
    char[] textChars = text.toCharArray();
    int tlen = textChars.length;
    if (tlen == 0) return -1;
    char[] patternChars = pattern.toCharArray();
    int plen = patternChars.length;
    if (plen == 0) return -1;
    if (tlen < plen) return -1;
    int tiMax = tlen - plen;
    for (int ti = 0; ti <= tiMax ; ti++) {
        int pi = 0;
        for (; pi < plen; pi++) {
            if (textChars[ti + pi] != patternChars[pi]) break;
        }
        if (pi == plen) return ti;
    }
    return -1;
}

蛮力算法-性能分析

下图中长的部分表示文本串，短的部分表示模式串，模式串中，绿色表示匹配成功，红色表示匹配失败，空格表示还未匹配。一旦匹配失败，模式串会向右移动一个单位，所以在匹配的过程中，可能出现的情况如下

现假设n为文本串的长度，m为模式串的长度，所以

1. 最坏的情况下，会比较n - m +1轮

2. 最好的情况为只需要比较一轮就成功，在这种情况下，需要比较m次（m为模式串的长度），所以此时的时间复杂度为O(m)

3. 最坏情况为执行了n - m + 1轮比较（n为文本串的长度），并且每一轮都要比较到模式串的末字符后，才失败(每一轮m - 1次成功，1次失败)

   在这种情况下，时间复杂度为O(m*(n - m +1))，由于一般情况下m远小于n，所以时间复杂度为O(nm)

KMP

前面，通过蛮力算法，可以成功的获取到模式串是否在文本串中的正确结果，其时间复杂度为O(nm)，通过蛮力算法，可以很清晰，简单的理解算法的整个执行过程。研究完蛮力算法以后，现在继续研究一个性能更优的模式匹配算法，KMP.

KMP 是Knuth-Morris-Pratt的简称（取名自3为发明人的名字），与1977年发布

蛮力 vs KMP

• 蛮力算法：是经过一系列比对以后，如果在某位置发现，比对失败，模式串则会从0开始，文本串从下一个位置开始，再次从头开始比较，一直重复，直到匹配成功或者全部匹配完。

  
  

• KMP算法：KMP算法，在经过一系列比对以后，付过发现某个位置比对失败，会直接从文本串的开始位置，直接挪动到某一个位置，然后继续开始比较。

  
  

对比蛮力算法，可以发现KMP算法非常的聪明，蛮力算法匹配失败，一次只会挪动一个位置，但是KMP算法则会一次挪动多个位置，KMP算法可以非常聪明的知道，哪些位置是没有必要比较的，所以，在KMP看来，蛮力算法的中间三次比较是没有必要的。

其实，KMP算法对比蛮力算法，其精妙之处在于：充分利用了此前比较过的内容，可以很聪明的跳过一些不必要的比较位置。

KMP中next表的使用

KMP会预先根据模式串的内容生成一张next表（一般是个数组）；例如下图是模式串ABCDABCE的next表

假设现在有下图所示的模式串与文本串，其中文本串已经比较到了ti = 8的位置，模式串比较到了pi = 7 的位置，现在比较失败了

当比较失败以后，就会到next表中进行查询，根据pi失配的位置7，到next表中进行查询，得到的元素为3，所以现在就会利用现在pi的索引，去next表中取出对应的值，然后再赋值到pi，即pi = next[7]，所以赋值以后，pi的值变为了3

总结：一旦发现pi位置失配，就会将next[pi]中的值赋值给pi，所以赋值完成后，就将pi = 3位置的元素与ti = 8位置的元素记性比较，模式串就会瞬间往右移动一定的位置

向右移动的距离 = pi - next[pi]

为了加深KMP算法对next表的使用原理，结合前面的next表，再利用实例来进行理解

下图中在pi = 3，ti = 5 的位置失配了

步骤如下：

1. 向next表中查表，next[pi] ,即可以得到next[3]的值
2. 查表后，得到next[3]的值为0，所以就会将pi的值更新为0
3. 利用pi == 0的位置与现在的ti进行比较

KMP的核心原理

下图为两个不同的串，其中Text为文本串，Pattern为模式串

• A,B是个子串（两个子串相等）
• c,d,e是单个字符

现在两个串在进行比较，当Text中比较到字符d时，Pattern比较到字符e时，比较失败了。按照KMP算法的原理，可以让模式串快速的向右移动一段距离，所以当上面的文本串d与模式串e比较失败以后，就会向右移动一段距离，最终移动后的结果如下

将模式串移动以后，就可以直接将模式串中的字符c与与文本串中的字符d进行比较，这样就直接跳过了前面的字符，而且由于子串A和子串B是相等的，所以A,B两个子串在移动后也不会再进行比较

所以，根据KMP算法的原理，当上图的d,e失配是，就会让模式串向右移动一段距离，最后直接从字符d,c进行比较

如果想实现这样的效果，需要具备的条件为：子串A与子串B相等

并且，如果要得知向右移动的距离，KMP就必须在失配字符e左边的子串中找出符合条件的A,B
其中，向右移动的距离为：e左边子串的长度 - A的长度，也等价于：e的索引 - c的索引
结合KMP的设想，也可以得到移动有c的索引；c的索引 == next[e的索引]，所以，向右移动的距离 == e的索引 - next[e的索引]

所以，如果在pi位置失配的话，向右移动的距离即为pi - next[pi]，并且如果next[pi]得到的值越小，向右移动的距离就会越大
其中next[pi]得到的值是pi左边子串的真前缀/真后缀的最大公共子串长度

真前缀/真后缀的最大公共子串

下图表示了不同模式串的真前缀/真后缀，及最大公共子串的长度

即找出模式串中的所有真前缀与真后缀，然后从真前缀/真后缀中找出最大公共子串的长度，然后就可以得到模式串中所有子串的最大公共子串长度，所以如果模式串为ABCDABCE的话，得到的最大公共子串长度结果如下

得到next表

得到最大公共子长度表以后，可以利用该表，得到next表

将最大公共子串长度的值，都向右移动1位，首位置位-1,就可以得到next表，所以利用上面的最大公子串长度表，就可以如下的next表

KMP主算法的实现

KMP主算法的实现，其实是基于前面蛮力算法的基础上，进行改进实现的

结合前面的思路，可以知道，只需要在失配时，将pi重新赋值即可。

但是需要考虑一个问题，就是在pi为0的时候就失配的情况，这种情况的话，只需要将ti进行++操作即可，但是由于在next表中，将next表的首元素值设置为-1，所以需要在首元素失配时，ti++后，又继续从pi为0的位置，继续进行比较，所以当pi == -1时，需要将pi进行++操作，巧妙的为下一次pi匹配做准备

最终，主算法的实现如下

public static int indexOf(String text, String pattern) {
    if (text == null || pattern == null) return -1;
    char[] textChars = text.toCharArray();
    int tlen = textChars.length;
    if (tlen == 0) return -1;
    char[] patternChars = pattern.toCharArray();
    int plen = patternChars.length;
    if (plen == 0) return -1;
    if (tlen < plen) return -1;
    //定义一个next表
    int[] next = next(pattern);
    int pi = 0, ti = 0, lenDelta = tlen - plen;
    while (pi < plen && ti - pi <= lenDelta) {
        //pi小于0，说明是0号位置失配，如果进入if判断的话，就会执行++操作，巧妙的将-1变为了0
        if (pi < 0 || textChars[ti] == patternChars[pi]) {
            ti++;
            pi++;
        } else {
            pi = next[pi];
        }
    }
    if (pi == plen) {
        //说明找到了
        return ti - pi;
    }
    return -1;
}

KMP算法中，为什么选择的是最大公共子串长度

现在假设文本串是AAAAABCDEF，模式串为AAAAB，如果现在在模式串B位置产生失配的话，则需要看失配前的串中，真前缀真后缀的公共子串长度，所以在模式串B位置失配的话，真前缀分别有,A,AA,AAA,AAAA,所以这些真前缀也有自己的真前缀真后缀，所以这些真前缀作为模式串匹配时的真前缀真后缀如下

最终，在失配时，公共子串长度选择的是3，为什么选择的是3，而不是1呢？请继续看下面的解释

现有如下图所示的文本串和模式串在进行匹配

可以发现，当ti为4，pi为4时失配了，现在需要利用pi = 4这个值，到next表中进行查值，最终查到的是3，所以模式串最终会往右移动 4 - 3 = 1个位置，移动后的结果如下

但是前面的表中可以看到，模式串为AAAA时，公共子串长度有3个，分别为1,2,3，假如现在将1赋值给pi的话，得到的结果如下

现在pi的值为1，就是将pi为1位置的值与现在ti为4位置的值进行比较，可以发现pi值越小，前面跳过的索引就会比较大，最终可能会导致再跳过的过程中，错过可能匹配的情况，因此有以下结论

1. 公共子串长度越小，向右移动的距离会越大，越不安全
2. 公共子串长度越大，向右移动的距离会越小，越安全

next表的构造思路

假设现在模式串的表示如下

绿色位置的字符，索引为n，黄色位置的字符，索引为i

再假设两个红色方框中的元素相等

这样就会得到 next[i] == n，即当i位置的字符失配时，i位置前面所有字符的最大公共子串的值，又因为两个红框中的值是相等的，所以最大公共子串的长度即为n，所以就有next[i] == n

现有如下假设情况

1. 如果模式串的i位置与n位置是相等的，即Pattern[i] == Pattern[n]

   • 那么nex[i + 1] == n+ 1(因为i + 1位置前面字符串的最大公共子串长度变为了n + 1)

2. 如果模式串的i位置与n位置不相等，即Pattern[i] ！= Pattern[n]
   找到前缀A中的下一位k为字符

   
   
   
   

   由于子串A是相等的，所以可以知道现在next[n]的值即为k

   • 如果现在模式串i位与k位是相等的，即Pattern[i] == Pattern[k]

     • 那么说明下图红框中的部分子串是相等的

       
       

       所以就有next[i + 1] = k + 1

   • 如果现在模式串i为与k为是不相等的，即即Pattern[i] != Pattern[k]

     • 那么现在就要继续在模式串k位置前面的子串中，继续查找子串中真前缀真后缀的最大公共子串，然后将步骤2的n作为k的值，继续进行判断，重复执行即可。

结合构建思路，得到next表的实现如下

private static int[] next(String pattern) {
    char[] chars = pattern.toCharArray();
    int[] next = new int[chars.length];
    next[0] = -1;
    int i = 0;
    int n = -1;
    int iMax = chars.length - 1;
    while (i < iMax) {//i < iMax 是因为后面会做++操作，操作完成后，就变为了i <= iMax
        if (n < 0 || pattern.charAt(i) == pattern.charAt(n)) {
            next[++i] = ++n;
        } else {
            //失配
            n = next[n];
        }
    }
    return next;
}

next表的不足之处

假设现在有文本串AAABAAAAB与模式串AAAAB

如果按照前面next表的实现进行计算你的话，生成的next表如下所示

存在的问题在于，第一次出现失配以后，后面相同字符依然会进行重复判断

所以，可以知道，其实当第一次出现失配情况以后，后面所有有的A与B进行比较时，都会出现失配的情况，所以，中间的几次比较，其实是多余的

所以，如果出现这种情况的话，KMP会显得比较笨拙

next表的优化思路

现通过下图表示模式串文本串

并且现在已知next[i] == n,next[n] == k

如果现在文本串中的d位置与模式串i位置失配的话，结合下图比较

有以下的比较情况

• 如果Pattern[i] != d，就让模式串滑动到next[i]（也就是n）位置与d进行比较
• 如果Pattern[n] != d，就让模式串滑动到next[n]（也就是k）位置与d进行比较
• 如果Pattern[i] == Pattern[n]，那么当i位置失配时，模式串最终必然会滑动到k位置与d 进行比较
  • 在这种情况下，让next[i]直接存储next[i]（也就是k）即可

通过分析，优化后的代码如下

private static int[] next(String pattern) {
    char[] chars = pattern.toCharArray();
    int[] next = new int[chars.length];
    next[0] = -1;
    int i = 0;
    int n = -1;
    int iMax = chars.length - 1;
    while (i < iMax) {//i < iMax 是因为后面会做++操作，操作完成后，就变为了i <= iMax
        if (n < 0 || pattern.charAt(i) == pattern.charAt(n)) {
            ++i;
            ++n;
            if (pattern.charAt(i) == pattern.charAt(n)) {
                next[i] = next[n];
            } else {
                next[i] = n;
            }
        } else {
            //失配
            n = next[n];
        }
    }
    return next;
}

通过优化后，模式串AAAAB生成的next表如下

next值发生变化以后，发生了如下的效果

因为首先在3号位置失配，所以优化后找到的索引为-1，所以会直接向右移动4个位置

KMP性能分析

利用KMP算法进行串匹配时，可能出现的情况如下，其中绿色表示匹配成功，红色表示失配，白色表示没有匹配

通过上图这种一般情况的分析，可以看出，KMP算法一共比较的次数大约为n（n为文本串长度）次

所以KMP算法主逻辑中

• 最好时间复杂度为：O(m)，m为模式串的长度
• 最坏时间复杂度为：O(n)，最多不超过O(2n)（因为有些地方可能会重叠）

其中next表的构造过程，与KMP主逻辑很类似，所以

• next表构建的时间复杂度为：O(n)

整体来讲，KMP刷反的复杂度为：

• 最好时间复杂度为：O(m)
• 最坏时间复杂度为：O(n+m)
• 空间复杂度为：O(m)

demo下载地址

完！