学习KMP算法

KMP算法

KMP的经典思想就是:当出现字符串不匹配时，可以记录一部分之前已经匹配的文本内容，利用这些信息避免从头再去做匹配。

相关问题

• 主要应用？

• 在字符串匹配上：在一个串中查找是否出现过另一个串。

• 如何记录已经匹配的文本内容？

• next数组

• next数组里的数字表示的是什么，为什么这么表示？

• next数组就是一个前缀表（prefix table），前缀表是用来回退的，它记录了模式串与主串(文本串)不匹配的时候，模式串应该从哪里开始重新匹配。

• 前缀表是如何记录的呢？

• 首先要知道前缀表的任务是当前位置匹配失败，找到之前已经匹配上的位置，再重新匹配，此也意味着在某个字符失配时，前缀表会告诉你下一步匹配中，模式串应该跳到哪个位置。

• 什么是前缀表？

• 前缀是指不包含最后一个字符的所有以第一个字符开头的连续子串。
• 后缀是指不包含第一个字符的所有以最后一个字符结尾的连续子串。
• 记录下标i之前（包括i）的字符串中，有多大长度的相同前缀后缀。

• 为啥一定要用前缀表？

• 前缀表要求的就是相同前后缀的长度，这也是网上“kmp 最长公共前后缀”的来源。
• 使用前缀表可以告诉我们匹配失败之后跳到哪里重新匹配。

• 如何计算前缀表？

• 模式串与前缀表对应位置的数字表示的就是：下标i之前（包括i）的字符串中，有多大长度的相同前缀后缀。

前缀表不减一构建next数组

var getNext = (str) => {
    // 初始化next数组
    let j = 0, next = [];
    next.push(j);
    for(let i = 1; i < str.length; i++){
        // 前后缀不相同时
        while(j > 0 && str[i] !== str[j]){
            j = next[j - 1];
        }
        // 前后缀相同时
        if(str[i] === str[j]){
            j++;
        }
        // 更新next
        next.push(j);
    }
    return next;
}

实例：实现strStr()

题目链接：[28. 实现 strStr()](​​28. 实现 strStr() - 力扣（LeetCode） (leetcode-cn.com)​​)

解答：

var strStr = function(haystack, needle) {
    if(needle.length === 0) return 0;
    const getNext = (str) => {
        let j = 0, next = [];
        next.push(j);
        for(let i = 1; i < str.length; i++){
            while(j > 0 && str[i] !== str[j]){
                j = next[j - 1];
            }
            if(str[i] === str[j]) j++;
            next.push(j);
        }
        return next;
    }
    const next = getNext(needle);
    let j = 0;
    for(let i = 0; i < haystack.length; i++){
        while(j > 0 && haystack[i] !== needle[j]){
            j = next[j - 1];
        }
        if(haystack[i] === needle[j]){
            j++;
        }
        if(j === needle.length){
            return i - j + 1;
        }
    }
    return -1;
};

进阶：重复的子字符串

题目链接：[459.重复的子字符串](​​459. 重复的子字符串 - 力扣（LeetCode） (leetcode-cn.com)​​)

解答:

var repeatedSubstringPattern = function(s) {
    if(s.length === 0) return false;
    const getNext = (str) => {
        let j = 0, next = [];
        next.push(j);
        for(let i = 1; i < str.length; i++){
            while(j > 0 && str[i] !== str[j]){
                j = next[j - 1];
            }
            if(str[i] === str[j]){
                j++;
            }
            next.push(j);
        }
        return next;
    }
    const next = getNext(s);
    if(next[s.length - 1] !==0 && s.length % (s.length - next[s.length - 1]) === 0){
        return true;
    }
    else{
        return false;
    }
};

注意：

• 如果 next[s.length - 1] !== 0，则说明字符串有最长相同的前后缀（就是字符串里的前缀子串和后缀子串相同的最长长度。
• 如果s.length % (s.length - (next[s.length - 1] + 1)) === 0 ，则说明 (数组长度-最长相等前后缀的长度) 正好可以被数组的长度整除，说明有该字符串有重复的子字符串。