数据结构（三）字符串的模式匹配算法

提示：本文仅做简单介绍，部分图来自网络，侵删

---

导入

leetcode 28 找出字符串中第一个匹配项的下标

问题描述：给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回 -1 。

示例 1：
输入：haystack = “sadbutsad”, needle = “sad”
输出：0
解释：“sad” 在下标 0 和 6 处匹配。
第一个匹配项的下标是 0 ，所以返回 0 。

示例 2：
输入：haystack = “leetcode”, needle = “leeto”
输出：-1
解释：“leeto” 没有在 “leetcode” 中出现，所以返回 -1 。

提示：

• 1 <= haystack.length, needle.length <= 104
• haystack 和 needle 仅由小写英文字符组成

方法一：Broute Force暴力算法

class Solution {
public:
    int strStr(string haystack, string needle) {

        int m = haystack.size();
        int n = needle.size();
        for(int i = 0; i <= m - n; i ++){
            int k = 0;  // needle 字符串计数 
            int j = i;
            while(k < n && haystack[j] == needle[k]) {
                j ++;
                k ++;
            }
            if(k == n) {
                return i;
            }
        }
        return -1;
    }
};

方法二：KMP算法

详见 串的模式匹配

class Solution {
public:
    int strStr(string haystack, string needle) {

        // KMP by myself! 
        int s_len = haystack.length();
        int p_len = needle.length();
        if(p_len == 0) {
            return 0;
        }
        vector<int> next(p_len, 0);
        for(int j = 0, i = 1; i < p_len; i ++){
            // j代表前缀最后一个字符（j也代表最长相等前后缀），i代表后缀最后一个字符
            while(j > 0 && needle[j] != needle[i]) {
                // 当前的前后缀字符不相等，前缀回退
                j = next[j - 1];
            }
            if(needle[j] == needle[i]) {
                // 当前的前后缀字符相等，前缀加一（最长相同前后缀加一）
                j ++;
            }
            // 更新 next 数组
            next[i] = j;
        }

        // 模式匹配
        for(int i = 0, j = 0; i < s_len; i ++) {
            while(j > 0 && haystack[i] != needle[j]) {
                j = next[j - 1];
            }
            if(haystack[i] == needle[j]) {
                j ++;
            }
            if(j == p_len) {
                return i - p_len + 1;
            }
        }
        return -1;
    }
};

方法三：api大法好

class Solution {
public:
    int strStr(string haystack, string needle) {
        return haystack.find(needle);
    }
};

一、串类型的定义

字符串string：由零个或多个字符组成的有序数列。串中字符数量称为串的长度，零个字符称为空串，任意连续的字符组成的子序列在串中称为子串，相应的包含子串的字符串称为主串，字符串属于线性表，字符在串中的序号称为该字符的位置，当两个串的所有字符值都相等则称这两个串相等。

s = 'a1a2a3a4a5……an' (n >= 0)

二、串的表示和实现

typedef struct {
	char *ch;
	int length;
}string;

串的基本操作
略略略

三、串的模式匹配

1. 字符串的前缀：从主串下标0开始的子串称为主串的前缀；
2. 字符串的后缀：从主串下标大于0的位置到结尾的子串称为主串的后缀；
3. 目标串：也就是主串，简单说就是那条比较长的串；
4. 模式串：也就是那条短的，用来匹配的串；
5. kmp算法的目的：在O(m+n)的时间复杂度的内进行串匹配，也就是在目标串中找到模式串，并返回目标串中模式串的第一个字符下标；

next数组的含义：
next[i] = k表示p[0…i]这个串中，前缀与后缀相同的情况下，前缀的最长长度为k，例如：p[8] = {a, c, d, e, f, a, c, d, e}，这里next[6] = 2 (p[6] = c, a c = a c), next[8] = 4 (p[8] = e, a c d e = a c d e)

---

求next数组，法一（删）：
若p[x] = p[now]，显然等式 next[x] = n[x-1] + 1成立；
若 p[x] != p[now]，当next[x - 1] = 0的时候看一下p[0]与p[x]，若相等next[x] = 1，否则为0；当next[x - 1] != 0的时候，等式next[x] = n[x-1] + 1成立。

 void get_next(int next[]){
     next[0] = 0;//第一个肯定是0
     int x = 1;//我们从p[1]开始递归
     int now = 0;//next[x-1] = now
     while(x < m){
         if(p[x] == p[now]){
             next[x] = now + 1;//若相等，则直接加一
             now ++;//now也加一计算下一个
             x++;//计算下一个
         }else if(now != 0){//不相等的情况，递归计算次一级的长度
             now = next[now - 1];
         }else{//now = 0 表示上一次循环计算次一级长度的时候不存在，表示找以p[x-1]结尾的串的前缀与后缀相等的情况已经找完了
             //找完了都满足不了p[x] == p[now + 1]这时直接x++进入下一个字符，next[x] = 0
             //可以将上面的例子中a串中的字符c改为字符d帮助理解，也可以从x = 1 , now = 0处开始理解
             x++;
         }
     }            
 }

---

求next数组，法二：

next[0] = 0;
// j 指向前缀末尾位置（j 亦代表最长相等前后缀），i 指向后缀末尾位置 
for(int i = 1, j = 0; i < p.length(); i++){
	// 1）前后缀不相同
    while(j && p[i] != p[j]) {
    	// 当前字符不相等，前缀回退到上一个，循环回退直至当前的前缀和后缀字符相等
    	// 注意，前缀 j 不能越界
    	j = next[j - 1];
    }
    // 2 ）前后缀相同
    // 前缀后移（最长相等前后缀加一）
    if(p[i] == p[j]) {
		j++;
	}
   // 3）更新next数组值
    next[i] = j;
}

KMP思想：在一次整体匹配失败后我们必定可以得到一些匹配成功的串，我们发现在后面的匹配尝试中，这些匹配成功的串只要出现后缀不等于前缀的情况，那这些尝试就必定是失败的，于是我们可以直接跳过这些尝试，直接进行后缀等于前缀的尝试，至于这个尝试是不是失败我们根据经验是不知道的，我们接着递归这个过程，直到匹配完全。

快找个视频看看，在这是整不明白的，哈哈哈