力扣28.实现strStr

实现strStr题目
这道题就是实现一个字符串匹配算法，以前学到过BF和KMP算法，先实现这两个算法。以后有时间学了其他算法再来实现其他的。

BF算法

最先想到的当然是暴力求解。但是第一次写成的代码相比BF虽然时间复杂度是一样的，但是冗长了不少- -！改进一下就是BF算法：

class Solution {
public:
    int strStr(string haystack, string needle) {
        if (needle == "")
            return 0;
        int i = 0, j = 0;
        while (i < haystack.length() && j < needle.length()) {
            if (haystack[i] == needle[j]) {
                i++;    j++;
            }
            // 相当于模式串needle向右滑动一位
            else {
            	// 文本串haystack回溯到下一位
                i = i - j + 1;
                // 模式串needle重新开始匹配
                j = 0;
            }
        }
        if (j == needle.length())
            return i - j;
        else 
            return -1;
    }
};

假设文本串的长度为n，模式串的长度为m。
最好的情况是只匹配一次，时间复杂度是$O(m)$。最坏的情况是匹配n次都失败，时间复杂度是$O(n\ast m)$。一般情况下的平均时间复杂度则为$O(n+m)$。

KMP算法

KMP算法虽然以前学过但是要用的时候还是得复习好久啊，凭记忆写下来太难了，所以我把学习KMP算法的笔记也整理了一下放在这里，以后用到的时候再常看吧。

class Solution {
public:
    vector<int> getNext(string needle) {
        int j = 0, k = -1;  // k == next[j]
        int len = needle.length();
        vector<int> next(len);
        next[0] = -1;
        while (j < len - 1) {
            if (k == -1 || needle[k] == needle[j]) {
                j++;    k++;
                // 对next数组的优化
                // 以避免出现needle[j] == needle[next[j]]的情况
                next[j] = (needle[j] != needle[k]) ? k : next[k];
                // 如果不进行优化，只要next[j] = k即可
            }
            else {
                k = next[k];
            }
        }
        return next;
    }
    int strStr(string haystack, string needle) {
        if (needle == "")
            return 0;
        vector<int> next = getNext(needle);
        int i = 0, j = 0;
        int hLen = haystack.length(), nLen = needle.length();
        while (i < hLen && j < nLen) {
            // j == -1时要将其恢复到0并开始新的匹配
            if (j == -1 || haystack[i] == needle[j]) {
                i++;    j++;
            }
            else
                j = next[j];
        }
        if (j == nLen)
            return i - j;
        else
            return -1;
    }
};

KMP算法杜绝了最差的情况，因为它在匹配时不操作i而只改变j，也可以看作是将模式串needle一次滑动多位。因此其时间复杂度（要加上求解next数组的时间）为$O(n+m)$。