KMP算法解决字符串匹配问题

最新推荐文章于 2022-12-13 11:31:56 发布

葵gui

最新推荐文章于 2022-12-13 11:31:56 发布

阅读量230

点赞数 2

文章标签：算法 leetcode

本文链接：https://blog.csdn.net/weixin_55541277/article/details/127178099

版权

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

主要为了记录对KMP算法的理解

题目

给你两个字符串 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 仅由小写英文字符组成

方法

暴力破解

偷懒 (直接使用String封装方法)

class Solution {
    public int strStr(String haystack, String needle) {
       return haystack.indexOf(needle);
    }
}

KMP算法

KMP 算法就是针对寻找字串的算法

在字符串 A 中寻找字符串 B

将字符串 A 称为主串， B 称为子串(也称为 pattern)

学习之前了解两个概念

以 b c d a b c为例

前缀: 包含首位字符但不包含末位字符的字串，如b 、bc、bcda、bcdabc
后缀: 包含末位字符但不包含首位字符的字串，如 c、bc、abc、bcdabc

主要思想就是利用一个数组 (叫做next) 保存字串在当前下标位置的最长的 后缀和前缀完全重合 的前缀位置，当按字符比较主串和字串时，遇到不同的字符即可在next数组中查找与当前位置的匹配的前缀的位置，进而只需要遍历一次主串，避免回头

为什么遇到字符不同时在next数组找对应的前缀位置就能避免在主串中回头呢？

因为next 记录了与以当前位置字符匹配的最长前缀的下一个位置

所以前面的字符主串和子串一定相等，只需要比较后面的符即可

`next` 数组从 0 开始使用

获得next数组需要在字串中寻找最大长度的相同前后缀

假设子串 0 1 2 3 4

A B A B A

-1 0 0 1 2

为方便代码实现，将 0 位赋予 -1 ，下标为i+1的位置记录i位置之前最长（前缀和后缀字符且长度相等）的前缀末尾位置

所以 next 数组中记录子串当前位置不同时，去哪个下标继续比较（需要回退的位置）

假如当前位为i

i==1: 只有字符 A ，无相同字符且长度相等的前后缀，所以为0

i==2：字符串 AB 无符合条件前后缀，为0

i==3：字符串 ABA ，最长前缀A，最长后缀A，为 1 ,

当下标为3无法匹配主串时，即前缀为A，当前下标为3和主串不同

而next记录最大前缀和后缀相同的下一个位置，即下标1，此处前后缀都是 A

可以让主串直接和1号下标进行比较，从而避免主串回溯 (回头重复比较)

i==4：字符串ABAB，最长前缀AB，最长后缀AB，为 2

不同是与下标2进行比较，前后缀都为AB，下一个位置正好为2

代码

获得 next 数组

public int[] getNextByZero(String pattern){
    // 字符串长度
    int n = pattern.length();
    // 转换数组
    char[] ns = pattern.toCharArray();
    // 构建next数组
    int[] next = new int[n];
    next[0] = -1;
    // j 代表了此位置之前的最长的重合前后缀位置下标,
    for (int i=0,j=-1; i<n-1;){
        // j==-1 代表子串中遇到不同的前后缀，从头开始计数
        if (j==-1||ns[i]==ns[j]){
            // 前缀位置加1即为比较的位置，++i下一位,加一后再使用
            next[++i] = ++j;
        } else {
            // 利用之前的next数组进行计数
            j = next[j];
        }
    }
    return next;
}

理解的最好方法就是带入数据多跟几遍

与主串进行比较

public int strStr(String haystack, String needle) {
    // 主串长度
    int m = haystack.length();
    // 字串长度
    int n = needle.length();
    if (n==0)
        return 0;
    if (n>m)
        return -1;
	// 主串
    char[] ms = haystack.toCharArray();
    // 子串
    char[] ns = needle.toCharArray();

    int[] next = getNextByZero(needle);
	// 进行比较
    for (int i=0,j=0; i<m; i++){
        // 匹配不成功,将j赋值为前一个相同字串的位置
        while (j!=0 && ms[i]!=ns[j])
            j = next[j];
        // 匹配成功,将j++
        if (ms[i]==ns[j])
            j++;
        // 是否结束
        if (j==n)
            // 比较的当前位置减去子串长度加一即为 开始位置
            return i-n+1;
    }

    return -1;
}

`next` 数组从 1 开始使用

next数组记录，当子串与主串不符合时需要回退的位置

假设子串 1 2 3 4 5

A B A B A

0 1 1 2 3

另一种则是利用其规律：

next[j] 的值每次最多增加1
子串的最后一位字符不影响next数组的结果

next[j] 的值 = 第 j 为字符前面 j-1 位字符组成的子串的前后缀重合字符数+1

假如当前位为i

i==1: 默认为0

i==2：第1位字符组成的子串A前后缀字符数位0加一，所以为1

当i=2按字符不匹配时，去下标为1继续比较

i==3：子串为AB，前后缀无重合字符，为0，加一后为1

i==4：子串为ABA ，前后缀重合字符为A，长度为1，加一后为2

当i=4按字符不匹配时，去下标为2继续比较

由于记录的前后缀完全重合，所以前面的A已经比较过，避免回头

i==5：子串为ABAB，前后缀重合字符为AB，长度为2，加一后为3

可以理解为和上面从0 开始一样计算，只不过再原有基础上再加1

代码

public int[] getNext(String pattern){
    // 子串长度
    int n = pattern.length();
    // 构建next数组
    int[] next = new int[n+1];
    // 由于0为不用，所以需要空出一位
    char[] ns = (" "+pattern).toCharArray();
    next[1] = 0;
    // j 代表了此位置之前的最长的重合前后缀位置下标
    for (int i=1,j=0; i<n;){
        if (j==0||ns[i]==ns[j]){
            // 前缀位置加1即为需要比较的位置
            next[++i] = ++j;
        } else {
            j = next[j];
        }
    }
    return next;
}

与主串进行比较

public int strStr(String haystack, String needle) {
    int m = haystack.length();
    int n = needle.length();
    if (n==0)
        return 0;
    if (n>m)
        return -1;

    char[] ms = (" "+haystack).toCharArray();
    char[] ns = (" "+needle).toCharArray();

    // 构建next数组
    int[] next = getNext(needle);
    next = getNextByZero(needle);


    System.out.println(Arrays.toString(next));

    for (int i=1,j=1; i<=m; i++){
        // 匹配不成功,将j赋值为前一个相同字串的位置
        while (j!=1 && ms[i]!=ns[j])
            j = next[j];
        // 匹配成功,将j++
        if (ms[i]==ns[j])
            j++;
        // 是否结束
        if (j==n+1)
            return i-j+1;
    }

    return -1;
}

String封装源码分析

String 的 indexOf 方法
主要思想为先找到第一个匹配的字符，然后比较后面的字符串

$-[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y6GyF0Tx-1664981330075)(C:\Users\HP\Desktop\学习笔记\java\算法\Leetcode28 找出字符串中第一个匹配项的下标.assets\image-20221005222901710-16649801437731-16649801479763.png)]$

public int indexOf(String str) {
    return indexOf(str, 0);
}

public int indexOf(String str, int fromIndex) {
    return indexOf(value, 0, value.length,
                   str.value, 0, str.value.length, fromIndex);
}

最终调用

String 和 StringBuffer共享的用于搜索的代码。

source是要搜索的字符数组，target是要搜索到的字符串。

形参:

source：正在搜索的字符。

sourceOffset：source字符串的偏移量。

sourceCount： source字符串的计数。

targer：要搜索的字符。

targetOffset：目标字符串的偏移量。

targetCount：目标字符串的计数。

fromIndex：开始搜索的索引。

// 此处偏移量均为0
static int indexOf(char[] source, int sourceOffset, int sourceCount,
                   char[] target, int targetOffset, int targetCount,
                   int fromIndex) {
    // 开始搜索位置大于主串长度
    if (fromIndex >= sourceCount) {
        // 子串为0则返回主串长度，不然返回-1表示找不到
        return (targetCount == 0 ? sourceCount : -1);
    }
    // 开始搜索位置小于0则赋值为0
    if (fromIndex < 0) {
        fromIndex = 0;
    }
    // 子串长度为0 直接返回开始搜索位置,即子串不存在默认与任何位置匹配
    if (targetCount == 0) {
        return fromIndex;
    }

    // 找到子串需要匹配的第一个字符，此处偏移量为0，即为子串第一个
    char first = target[targetOffset];
    // 开始搜索的位置到 从后往前一个子串长度的位置，之间为可能存在第一个字符的最大区间
    int max = sourceOffset + (sourceCount - targetCount);
	// 开始位置为主串偏移量加上寻找位置，此处偏移量为0，即可开始搜索位置
    for (int i = sourceOffset + fromIndex; i <= max; i++) {
        // 寻找匹配子串第一个字符的位置
        if (source[i] != first) {
            while (++i <= max && source[i] != first);
        }
		// 运行到此处已经找到第一个字符，开始匹配后面的字符
        if (i <= max) {
            // j初始化为第二个字符下标
            int j = i + 1;
            // 从第二个字符再比较子串长度-1个数即可，此间为比较的最大区间
            int end = j + targetCount - 1;
            // 跳出循环要么主子串不匹配，要么完美匹配后跳出
            for (int k = targetOffset + 1; j < end && source[j]
                 == target[k]; j++, k++);
			// 利用j判断是否匹配成功，完美匹配则j将等于end
            if (j == end) {
                // 找到则返回i减去偏移量，此处偏移量为0
                return i - sourceOffset;
            }
        }
    }
    // 找不到返回-1
    return -1;
}