字符串匹配的三种算法

1.一道字符串匹配题：

实现 strStr() 函数。

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

示例 1:

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

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

当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。

对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与C语言的 strstr() 以及 Java的 indexOf() 定义相符。

链接：https://leetcode-cn.com/problems/implement-strstr/

2.暴力解法：

//暴力法 O(M*N)
class Solution {
public:
    int strStr(string haystack, string needle) {
        if(needle.size() == 0) return 0;
        int i = 0,j = 0,ans = -1;
        while(i < haystack.size() && j < needle.size())
        {
            if(haystack[i] == needle[j])
            {
                i++;
                j++;
            }
            else
            {
                i = i - j + 1;
                j = 0;
            }
        }
        if(j == needle.size()) ans = i - j;
        return ans;
    }
};

3.KMP算法

参考链接：

https://www.cnblogs.com/ZuoAndFutureGirl/p/9028287.html

class Solution {
public:
     
    int strStr(string haystack, string needle) {
        if(needle.size() == 0)
        {
            return 0;
        }
        int len1 = haystack.size();
        int len2 = needle.size();
        vector<int> next(needle.size());
        int i = 0,j = -1;
        next[0] = -1;
        while(i < len2 - 1)
        {
            if(j == -1 || needle[i] == needle[j])
            {
                i++;
                j++;
                if(needle[i] != needle[j])//如果当前没有匹配上的这个字符不等于它下一次要跳的字符
                {
                    next[i] = j;
                }
                else //若两个字符相等，跳到这个字符之前应该跳的地方
                {
                    next[i] = next[j];
                }
            }
            else
            {
                j = next[j];
            }
        }
        
        i = 0,j = 0;
        while(i < len1 && j < len2)//注意string.size() 返回值为size_type 为无符号数 若用负数与其相比 则负数会转化为无符号数
        {
            if(j == -1 || haystack[i] == needle[j])
            {
                i++;
                j++;
            }
            else
            {
                j = next[j];
            }
        }
        if(j == len2) return i - j;
        return -1;
    }
};

4.BM算法

https://www.cnblogs.com/xubenben/p/3359364.html

class Solution {
public:
    void get_bmbs(string &x,vector<int> &p)
    {
        int len = x.size();
        for(int i = 0;i < 256;++i)//ASCII码共256个字符
        {
            p.push_back(len);
        }
        for(int i = 0;i < len - 1;++i)//注意小于len - 1
        {
            p[x[i]] = len - 1 - i;
        }
    }
    
    void get_suffix(string &x,vector<int> &p)
    {
        int len = x.size();
        p[len - 1] = len;
        for(int i = len - 2;i >= 0;--i)
        {
            int q = i;
            while(q >= 0 && x[q] == x[len - 1 - i + q])
            {
                --q;
            }
            p[i] = i - q;
        }
    }
    void get_bmgs(string &x,vector<int> &p)
    {
        int len = x.size();
        
        vector<int> suffix(len);
            
        get_suffix(x,suffix);
        
        for(int i = 0;i < len;++i)
        {
            p.push_back(len);
        }
        int j = 0;
        for(int i = len - 1;i >= 0;--i)
        {
            if(suffix[i] == i + 1)
            {
                for(;j < len - 1 - i;++j)
                {
                    if(p[j] == len)
                    {
                        p[j] = len - 1 - i;
                    }
                }
            }
        }
        
        for(int i = 0;i < len - 1;i++)
        {
            p[len - 1 - suffix[i]] = len - 1 - i;
        }
    }
    int strStr(string haystack, string needle) {
        if(needle.size() == 0) return 0;
        vector<int> bmbs,bmgs;
        get_bmbs(needle,bmbs);
        get_bmgs(needle,bmgs);
        int i = 0;
        int n = haystack.size();
        int m = needle.size();
        while(i <= n - m)
        {
            int j = m - 1;
            while(j >= 0 && needle[j] == haystack[i + j])
            {
                --j;
            }
            if(j < 0) return i;
            i += max(bmbs[haystack[i + j]]-(m - 1 - j),bmgs[j]);//j为当前失配的地方 bmds找的是当前            
        }
        return -1;
    }
};