2022-05-10 Boyer-Moore字符串查找算法，较KMP易于理解，甚至更快

有时候简单就是美

在被DFA KMP完虐后，我看到了BM算法，理念简单，效率一般极高，最优时间性能O(M/N)，最差O(M*N)，一般不会出现。

我们可以非常轻松的构建一个 right[ char ] 表，内容是 pat 匹配子字符串每个字母最后一次出现的位置，其余字母为 -1.

pat	A	B	A	C	other char
right[char]	2	1	2	3	-1

看看如何用这个表：

还是如下对比，我们的对比方法是自右向左的对比。

txt	A	A	A	R	A	A	B	A	B	A	B	A	C
txtPtr	0	1	2	3	4	5	6	7	8	9	10	11	12
pat	A	B	A	C
patPtr	0	1	2	3
right[A]	2	2	2	2
right[B]	1	1	1	1
right[C]	3	3	3	3
right[other]	-1	-1	-1	-1

第一个对比是 R 和 C ，R 在 right 表中是 -1，意思是模式字符串中就没有这个字符，既然没有，那么我在模式字符串长度范围都不可能匹配了，于是应该直接跳过整个 pat.size( ) 的长度，也就是 patPtr - right[ R ] = 3 - ( -1 ) = 4

txt	A	A	A	R	A	A	B	A	B	A	B	A	C
txtPtr	0	1	2	3	4	5	6	7	8	9	10	11	12
pat					A	B	A	C
patPtr					0	1	2	3
right[A]					2	2	2	2
right[B]					1	1	1	1
right[C]					3	3	3	3
right[other]					-1	-1	-1	-1

如果比较的字符在 right 表中，同样的方法计算位移：patPtr - right[ A ] = 3 - 2 = 1

txt	A	A	A	R	A	A	B	A	B	A	B	A	C
txtPtr	0	1	2	3	4	5	6	7	8	9	10	11	12
pat						A	B	A	C
patPtr						0	1	2	3
right[A]						2	2	2	2
right[B]						1	1	1	1
right[C]						3	3	3	3
right[other]						-1	-1	-1	-1

继续移动 2

txt	A	A	A	R	A	A	B	A	B	A	B	A	C
txtPtr	0	1	2	3	4	5	6	7	8	9	10	11	12
pat								A	B	A	C
patPtr								0	1	2	3
right[A]								2	2	2	2
right[B]								1	1	1	1
right[C]								3	3	3	3
right[other]								-1	-1	-1	-1

继续移动 2

txt	A	A	A	R	A	A	B	A	B	A	B	A	C
txtPtr	0	1	2	3	4	5	6	7	8	9	10	11	12
pat										A	B	A	C
patPtr										0	1	2	3
right[A]										2	2	2	2
right[B]										1	1	1	1
right[C]										3	3	3	3
right[other]										-1	-1	-1	-1

如果匹配，则 txtPtr 和 patPtr 同时回退，继续比较，直到遇到不匹配的字符或完全匹配

txt	A	A	A	R	A	A	B	A	B	A	B	A	C
txtPtr	0	1	2	3	4	5	6	7	8	9	10	11	12
pat										A	B	A	C
patPtr										0	1	2	3
right[A]										2	2	2	2
right[B]										1	1	1	1
right[C]										3	3	3	3
right[other]										-1	-1	-1	-1

有个问题，如果移动距离 patPtr - right[ char ] < 0 ，这种情况是会出现的，此时我们设置移动距离为 1 即可。

通过以上示例，我们发现，对于普通的单词字符串，甚至是中文这种大字符表字符，我们都可以如此比较，而且效率相当彪悍。

以下是代码，很容易理解。

struct BoyerMoore
{
    explicit BoyerMoore(std::string patStr) : pat(std::move(patStr))
    {
        int patSize = static_cast<int>(pat.size());
        const int alphSize = 256;
        right = std::vector<int>(alphSize, -1);
        for (int patPtr = 0; patPtr != patSize; ++patPtr)
        {
            right[pat.at(patPtr)] = patPtr;
        }
    }
    auto search(const std::string &txt) const -> int
    {
        int txtSize = static_cast<int>(txt.size());
        int patSize = static_cast<int>(pat.size());
        int skip = 0;
        for (int txtPtr = 0; txtPtr <= txtSize - patSize; txtPtr += skip)
        {
            std::cout << txt.substr(txtPtr) << std::endl;
            std::cout << pat << std::endl;
            skip = 0;
            for (int patPtr = patSize - 1; patPtr >= 0; patPtr--)
            {
                if (pat.at(patPtr) != txt.at(txtPtr + patPtr))
                {
                    skip = patPtr - right[txt.at(txtPtr + patPtr)];
                    if (skip < 1)
                    {
                        skip = 1;
                    }
                    break;
                }
            }
            if (skip == 0)
            {
                return txtPtr;
            }
        }
        return txtSize;
    }

  private:
    std::vector<int> right;
    std::string pat;
};