BF,BM,KMP，就这？

时间 2020-12-25

标签 php java git github 面试算法数组微信函数动画栏目 PHP 繁體版

原文原文链接

若是文中视频不能够播放，你们能够去查看原文。php

为保证代码严谨性，文中全部代码均在 leetcode 刷题网站 AC ，你们能够放心食用。java

皇上生辰之际，举国同庆，袁记菜馆做为天下第一饭店，因此被选为此次庆典的菜品供应方，此次庆典对于袁记菜馆是一项史无前例的挑战，毕竟是第一次给皇上庆祝生辰，稍有不慎就是掉脑壳的大罪，整个袁记菜馆内都在紧张的布置着。此时忽然有一个店小二慌慌张张跑到袁厨面前汇报，到底发生了什么事，让店小二如此慌张呢？git

袁记菜馆内github

店小二：很差了很差了，掌柜的，出大事了。面试

袁厨：发生什么事了，慢慢说，如此慌张，成何体统。（开店开久了，架子出来了哈）算法

店小二：皇上按照我们菜单点了 666 道菜，可是我们作西湖醋鱼的师傅请假回家结婚了，不知道皇上有没有点这道菜，若是点了这道菜，我们作不出来，那我们店可就完了啊。数组

（袁厨听了以后，吓得一屁股坐地上了，缓了半天说道）微信

袁厨：别说那么多了，快给我找找皇上点的菜里面，有没有这道菜！函数

找了好久，而且核对了不少遍，最后确认皇上没有点这道菜。菜馆内的人都松了一口气动画

经过上面的一个例子，让咱们简单了解了字符串匹配。

字符串匹配：设 S 和 T 是给定的两个串，在主串 S 中找到模式串 T 的过程称为字符串匹配，若是在主串 S 中找到模式串 T ，则称匹配成功，函数返回 T 在 S 中首次出现的位置，不然匹配不成功，返回 -1。

例：

在上图中，咱们试图找到模式 T = baab,在主串 S = abcabaabcabac 中第一次出现的位置，即为红色阴影部分， T 第一次在 S 中出现的位置下标为 4 （字符串的首位下标是 0 ），因此返回 4。若是模式串 T 没有在主串 S 中出现，则返回 -1。

解决上面问题的算法咱们称之为字符串匹配算法，今天咱们来介绍三种字符串匹配算法，你们记得打卡呀，说不许面试的时候就问到啦。

BF算法（Brute Force）

这个算法很容易理解，就是咱们将模式串和主串进行比较，一致时则继续比较下一字符，直到比较完整个模式串。不一致时则将模式串后移一位，从新从模式串的首位开始对比，重复刚才的步骤下面咱们看下这个方法的动图解析，看完确定一下就能搞懂啦。

由于不

经过上面的代码是否是一下就将这个算法搞懂啦，下面咱们用这个算法来解决下面这个经典题目吧。

leetcdoe 28. 实现 strStr()

题目描述

给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。若是不存在，则返回 -1。

示例 1:

输入: haystack = "hello", needle = "ll"
输出: 2

示例 2:

输入: haystack = "aaaaa", needle = "bba"
输出: -1

题目解析

其实这个题目很容易理解，可是咱们须要注意的是一下几点，好比咱们的模式串为 0 时，应该返回什么，咱们的模式串长度大于主串长度时，应该返回什么，也是咱们须要注意的地方。下面咱们来看一下题目代码吧。

题目代码

class Solution {
    public int strStr(String haystack, String needle) {
        int haylen = haystack.length();
        int needlen = needle.length(); 
        //特殊状况
        if (haylen < needlen) {
            return -1;
        }
        if (needlen == 0) {
            return 0;
        }
        //主串
        for (int i = 0; i < haylen - needlen + 1; ++i) {
            int j;
            //模式串
            for (j = 0; j < needlen; j++) {
                //不符合的状况，直接跳出，主串指针后移一位
                if (haystack.charAt(i+j) != needle.charAt(j)) {
                    break;
                }
            }
            //匹配成功
            if (j == needlen) {
                return i;
            } 

        }
        return -1;
    }
}

咱们看一下BF算法的另外一种算法（显示回退），其实原理同样，就是对代码进行了一下修改，只要是看完我们的动图，这个也可以一下就能看懂，你们能够结合下面代码中的注释和动图进行理解。

class Solution {
    public int strStr(String haystack, String needle) {
        //i表明主串指针，j模式串
        int i,j;
        //主串长度和模式串长度
        int halen = haystack.length();
        int nelen = needle.length();
        //循环条件，这里只有 i 增加
        for (i = 0 , j = 0; i < halen && j < nelen; ++i) {
            //相同时，则移动 j 指针
            if (haystack.charAt(i) == needle.charAt(j)) {
                ++j;
            } else {
                //不匹配时，将 j 从新指向模式串的头部，将 i 本次匹配的开始位置的下一字符
                i -= j;
                j = 0;
            }
        }
        //查询成功时返回索引，查询失败时返回 -1；
        int renum = j == nelen ? i - nelen : -1;
        return renum;

    }
}

BM算法(Boyer-Moore)

咱们刚才说过了 BF 算法，可是 BF 算法是有缺陷的，好比咱们下面这种状况

如上图所示，若是咱们利用 BF 算法，遇到不匹配字符时，每次右移一位模式串，再从新从头进行匹配，咱们观察一下，咱们的模式串 abcdex 中每一个字符都不同，可是咱们第一次进行字符串匹配时，abcde 都匹配成功，到 x 时失败，又由于模式串每位都不相同，因此咱们不须要再每次右移一位，再从新比较，咱们能够直接跳过某些步骤。以下图

咱们能够跳过其中某些步骤，直接到下面这个步骤。那咱们是依据什么原则呢？

坏字符规则

咱们以前的 BF 算法是从前日后进行比较，BM 算法是从后往前进行比较，咱们来看一下具体过程，咱们仍是利用上面的例子。

BM 算法是从后往前进行比较，此时咱们发现比较的第一个字符就不匹配，咱们将主串这个字符称之为坏字符，也就是 f ,咱们发现坏字符以后，模式串 T 中查找是否含有该字符（f），咱们发现并不存在 f，此时咱们只需将模式串右移到坏字符的后面一位便可。以下图

那咱们在模式串中找到坏字符该怎么办呢？

此时咱们的坏字符为 f ,咱们在模式串中，查找发现含有坏字符 f,咱们则须要移动模式串 T ,将模式串中的 f 和坏字符对齐。见下图。

而后咱们继续从右往左进行比较，发现 d 为坏字符，则须要将模式串中的 d 和坏字符对齐。

那么咱们在来思考一下这种状况，那就是模式串中含有多个坏字符怎么办呢？

那么咱们为何要让最靠右的对应元素与坏字符匹配呢？若是上面的例子咱们没有按照这条规则看下会产生什么问题。

若是没有按照咱们上述规则，则会漏掉咱们的真正匹配。咱们的主串中是含有 babac 的，可是却没有匹配成功，因此应该遵照最靠右的对应字符与坏字符相对的规则。

咱们上面一共介绍了三种移动状况，分别是下方的模式串中没有发现与坏字符对应的字符，发现一个对应字符，发现两个。这三种状况咱们分别移动不一样的位数，那咱们是根据依据什么来决定移动位数的呢？下面咱们给图中的字符加上下标。见下图

下面咱们来考虑一下这种状况。

此时这种状况确定是不行的，不往右移动，甚至还有可能左移，那么咱们有没有什么办法解决这个问题呢？继续往下看吧。

好后缀规则

好后缀其实也很容易理解，咱们以前说过 BM 算法是从右往左进行比较，下面咱们来看下面这个例子。

这里若是咱们按照坏字符进行移动是不合理的，这时咱们可使用好后缀规则，那么什么是好后缀呢？

BM 算法是从右往左进行比较，发现坏字符的时候此时 cac 已经匹配成功，在红色阴影处发现坏字符。此时已经匹配成功的 cac 则为咱们的好后缀，此时咱们拿它在模式串中查找，若是找到了另外一个和好后缀相匹配的串，那咱们就将另外一个和好后缀相匹配的串，滑到和好后缀对齐的位置。

是否是感受有点拗口，不要紧，咱们看下图，红色表明坏字符，绿色表明好后缀

上面那种状况搞懂了，可是咱们思考一下下面这种状况

上面咱们说到了，若是在模式串的头部没有发现好后缀，发现好后缀的子串也能够。可是为何要强调这个头部呢？

咱们下面来看一下这种状况

可是当咱们在头部发现好后缀的子串时，是什么状况呢？

下面咱们经过动图来看一下某一例子的具体的执行过程

视频

说到这里，坏字符和好后缀规则就算说完了，坏字符很容易理解，咱们对好后缀总结一下

1.若是模式串含有好后缀，不管是中间仍是头部能够按照规则进行移动。若是好后缀在模式串中出现屡次，则以最右侧的好后缀为基准。

2.若是模式串头部含有好后缀子串则能够按照规则进行移动，中间部分含有好后缀子串则不能够。

3.若是在模式串尾部就出现不匹配的状况，即不存在好后缀时，则根据坏字符进行移动，这里有的文章没有提到，是个须要特别注意的地方，我是在这个论文里找到答案的，感兴趣的同窗能够看下。

Boyer R S，Moore J S. A fast string searching algorithm［J］. Communications of the ACM，1977，10： 762-772.

以前咱们刚开始说坏字符的时候，是否是有可能会出现负值的状况，即往左移动的状况，因此咱们为了解决这个问题，咱们能够分别计算好后缀和坏字符日后滑动的位数（好后缀不为 0 的状况），而后取两个数中最大的，做为模式串日后滑动的位数。

这破图画起来是真费劲啊。下面咱们来看一下算法代码，代码有点长，我都标上了注释也在网站上 AC 了，若是各位感兴趣能够看一下，不感兴趣理解坏字符和好后缀规则便可。能够直接跳到 KMP 部分

class Solution {
    public int strStr(String haystack, String needle) {
        char[] hay = haystack.toCharArray();
        char[] need = needle.toCharArray();
        int haylen = haystack.length();
        int needlen = need.length;
        return bm(hay,haylen,need,needlen);
    }
    //用来求坏字符状况下移动位数
    private static void badChar(char[] b, int m, int[] bc) {
        //初始化
        for (int i = 0; i < 256; ++i) {
            bc[i] = -1;
        }
        //m 表明模式串的长度，若是有两个 a,则后面那个会覆盖前面那个
        for (int i = 0; i < m; ++i) {
            int ascii = (int)b[i];
            bc[ascii] = i;//下标
        }
    }
    //用来求好后缀条件下的移动位数
    private static void goodSuffix (char[] b, int m, int[] suffix,boolean[] prefix) {
        //初始化
        for (int i = 0; i < m; ++i) {
            suffix[i] = -1;
            prefix[i] = false;
        }
        for (int i = 0; i < m - 1; ++i) {
            int j = i;
            int k = 0;
            while (j >= 0 && b[j] == b[m-1-k]) {
                --j;
                ++k;
                suffix[k] = j + 1;
            }
            if (j == -1) prefix[k] = true;
        }
    }
    public static int bm (char[] a, int n, char[] b, int m) {

        int[] bc = new int[256];//建立一个数组用来保存最右边字符的下标
        badChar(b,m,bc);
        //用来保存各类长度好后缀的最右位置的数组
        int[] suffix_index = new int[m];
        //判断是不是头部，若是是头部则true
        boolean[] ispre = new boolean[m];
        goodSuffix(b,m,suffix_index,ispre);
        int i = 0;//第一个匹配字符
        //注意结束条件
        while (i <= n-m) {
            int j;
            //从后往前匹配，匹配失败，找到坏字符
            for (j = m - 1; j >= 0; --j) {
                if (a[i+j] != b[j]) break;
            }
            //模式串遍历完毕，匹配成功
            if (j < 0) {
                return i;
            }
            //下面为匹配失败时，如何处理
            //求出坏字符规则下移动的位数，就是咱们坏字符下标减最右边的下标
            int x = j - bc[(int)a[i+j]];
            int y = 0;
            //好后缀状况，求出好后缀状况下的移动位数,若是不含有好后缀的话，则按照坏字符来
            if (y < m-1 && m - 1 - j > 0) {
                y = move(j, m, suffix_index,ispre);
            }
            //移动
            i = i + Math.max(x,y);

        }
        return -1;
    }
    // j表明坏字符的下标
    private static int move (int j, int m, int[] suffix_index, boolean[] ispre) {
        //好后缀长度
        int k = m - 1 - j;
        //若是含有长度为 k 的好后缀，返回移动位数，
        if (suffix_index[k] != -1) return j - suffix_index[k] + 1;
        //找头部为好后缀子串的最大长度，从长度最大的子串开始
        for (int r = j + 2; r <= m-1; ++r) {
            //若是是头部
            if (ispre[m-r] == true) {
                return r;
            }
        }
        //若是没有发现好后缀匹配的串，或者头部为好后缀子串，则移动到 m 位，也就是匹配串的长度
        return m;
    }
}

咱们来理解一下咱们代码中用到的两个数组，由于两个规则的移动位数，只与模式串有关，与主串无关，因此咱们能够提早求出每种状况的移动状况，保存到数组中。

KMP算法（Knuth-Morris-Pratt）

咱们刚才讲了 BM 算法，虽然不是特别容易理解，可是若是你用心看的话确定能够看懂的，咱们再来看一个新的算法，这个算法是考研时必考的算法。实际上 BM 和 KMP 算法的本质是同样的，你理解了 BM 再来理解 KMP 那就是分分钟的事啦。

咱们先来看一个实例

视频

为了让读者更容易理解，咱们将指针移动改为了模式串移动，二者相对与主串的移动是一致的，从新比较时都是从指针位置继续比较。

经过上面的实例是否是很快就能理解 KMP 算法的思想了，可是 KMP 的难点不是在这里，不过多思考，认真看理解起来也是很轻松的。

在上面的例子中咱们提到了一个名词，最长公共先后缀，这个是什么意思呢？下面咱们经过一个较简单的例子进行描述。

此时咱们在红色阴影处匹配失败，绿色为匹配成功部分，则咱们观察匹配成功的部分。

咱们来看一下匹配成功部分的全部前缀

咱们的最长公共先后缀以下图，则咱们须要这样移动

好啦，看完上面的图，KMP的核心原理已经基本搞定了，可是咱们如今的问题是，咱们应该怎么才能知道他的最长公共先后缀的长度是多少呢？怎么知道移动多少位呢？

刚才咱们在 BM 中说到，咱们移动位数跟主串无关，只跟模式串有关，跟咱们的 bc,suffix,prefix 数组的值有关，咱们经过这些数组就能够知道咱们每次移动多少位啦，其实 KMP 也有一个数组，这个数组叫作 next 数组，那么这个 next 数组存的是什么呢？

next 数组存的我们最长公共先后缀中，前缀的结尾字符下标。是否是感受有点别扭，咱们经过一个例子进行说明。

咱们知道 next 数组以后，咱们的 KMP 算法实现起来就很容易啦，另外咱们看一下 next 数组究竟是干什么用的。

剩下的就不用说啦，彻底一致啦，我们将上面这个例子，翻译成和我们开头对应的动画你们看一下。

动画必上岸

下面咱们看一下代码，标有详细注释，你们认真看呀。

注：不少教科书的 next 数组表示方式不一致，理解便可

class Solution {
    public int strStr(String haystack, String needle) {
        //两种特殊状况
        if (needle.length() == 0) {
            return 0;
        }
        if (haystack.length() == 0) {
            return -1;
        }
        // char 数组
        char[] hasyarr = haystack.toCharArray();
        char[] nearr = needle.toCharArray();
        //长度
        int halen = hasyarr.length;
        int nelen = nearr.length;
        //返回下标
        return kmp(hasyarr,halen,nearr,nelen);

    }
    public int kmp (char[] hasyarr, int halen, char[] nearr, int nelen) {
        //获取next 数组
        int[] next = next(nearr,nelen);
        int j = 0;
        for (int i = 0; i < halen; ++i) {
            //发现不匹配的字符，而后根据 next 数组移动指针，移动到最大公共先后缀的，
            //前缀的后一位,和我们移动模式串的含义相同
            while (j > 0 && hasyarr[i] != nearr[j]) {
                j = next[j - 1] + 1;
                //超出长度时，能够直接返回不存在
                if (nelen - j + i > halen) {
                    return -1;
                }
            }
            //若是相同就将指针同时后移一下，比较下个字符
            if (hasyarr[i] == nearr[j]) {
                ++j;
            }
            //遍历完整个模式串，返回模式串的起点下标
            if (j == nelen) {
                return i - nelen + 1;
            }
        }
        return -1;
    }
    //这一块比较难懂，不想看的同窗能够忽略，了解大体含义便可，或者本身调试一下，看看运行状况
    //我会每一步都写上注释
    public  int[] next (char[] needle,int len) {
        //定义 next 数组
        int[] next = new int[len];
        // 初始化
        next[0] = -1;
        int k = -1;
        for (int i = 1; i < len; ++i) {
            //咱们此时知道了 [0,i-1]的最长先后缀，可是k+1的指向的值和i不相同时，咱们则须要回溯
            //由于 next[k]就时用来记录子串的最长公共先后缀的尾坐标（即长度）
            //就要找 k+1前一个元素在next数组里的值,即next[k+1]
            while (k != -1 && needle[k + 1] != needle[i]) {
                k = next[k];
            }
            // 相同状况，就是 k的下一位，和 i 相同时，此时咱们已经知道 [0,i-1]的最长先后缀
            //而后 k - 1 又和 i 相同，最长先后缀加1，便可
            if (needle[k+1] == needle[i]) {
                ++k;
            }
            next[i] = k;

        }
        return next;
    }
}

这篇文章真的写了好久好久，以为还不错的话，就麻烦您点个赞吧，你们也能够去个人公众号看个人全部文章，每一个都有动图解析，公众号：袁厨的算法小屋