算法基础:KMP算法详细详解

目录

1、几个最基本的概念

2、暴力算法 

3、KMP算法 

4、KMP代码实现

5、时间复杂度


1、几个最基本的概念

  1. 字符串的前缀: 主串(目标串)从索引0开始的子串被称为主串的前缀。

  2. 字符串的后缀: 主串从索引大于0的位置到结尾的子串称为主串的后缀。

  3. 目标串: 也称为主串,是比较长的字符串。

  4. 模式串: 也称为子串,是较短的字符串,用来在目标串中进行匹配。

  5. KMP算法的目的: 以O(m+n)的时间复杂度,在目标串中找到模式串,并返回模式串在目标串中的第一个字符的索引位置。其中,m为模式串的长度,n为目标串的长度。

2、暴力算法 
 

暴力算法是一种简单直观但效率较低的字符串匹配算法。其基本思想是,对于目标串的每一个可能的起始位置,都尝试将模式串与目标串进行比较,直到找到匹配或者遍历完整个目标串。以下是暴力算法的详细讲解:

public class BruteForce {

    // 暴力匹配算法
    public static int bruteForceSearch(String text, String pattern) {
        int n = text.length();
        int m = pattern.length();

        // i为目标串的起始位置
        for (int i = 0; i <= n - m; i++) {
            int j;

            // j为模式串的索引,用于和目标串的子串进行比较
            for (j = 0; j < m; j++) {
                if (text.charAt(i + j) != pattern.charAt(j)) {
                    break;  // 如果不匹配,退出内循环
                }
            }

            if (j == m) {
                return i;  // 找到匹配,返回起始位置
            }
        }

        return -1;  // 未找到匹配
    }

    public static void main(String[] args) {
        String text = "ABABDABACDABABCABAB";
        String pattern = "ABABCABAB";
        int index = bruteForceSearch(text, pattern);

        if (index != -1) {
            System.out.println("匹配成功,起始位置:" + index);
        } else {
            System.out.println("未找到匹配");
        }
    }
}

3、KMP算法 

KMP算法(Knuth-Morris-Pratt算法)是一种用于字符串匹配的经典算法,它能够在文本串和模式串不匹配的情况下,通过已经匹配的部分信息,避免将模式串移动到所有可能的位置进行匹配,从而提高匹配效率。下面我将用Java语言详细讲解KMP算法的实现。

KMP算法的关键在于构建一个部分匹配表(Partial Match Table),该表记录了模式串每个位置的最长前缀和最长后缀的匹配长度。这个表可以帮助算法在匹配失败时,跳过一些不可能匹配的位置,从而减少匹配次数。

4、KMP代码实现

public class KMP {

    // 构建部分匹配表
    private static int[] buildPartialMatchTable(String pattern) {
        int[] lps = new int[pattern.length()];
        int len = 0;  // 当前最长匹配前缀和后缀的长度

        for (int i = 1; i < pattern.length(); ) {
            if (pattern.charAt(i) == pattern.charAt(len)) {
                len++;
                lps[i] = len;
                i++;
            } else {
                if (len != 0) {
                    len = lps[len - 1];
                } else {
                    lps[i] = 0;
                    i++;
                }
            }
        }

        return lps;
    }

    // KMP匹配算法
    public static int kmpSearch(String text, String pattern) {
        int[] lps = buildPartialMatchTable(pattern);
        int i = 0;  // text的索引
        int j = 0;  // pattern的索引

        while (i < text.length()) {
            if (pattern.charAt(j) == text.charAt(i)) {
                i++;
                j++;
            }

            if (j == pattern.length()) {
                // 匹配成功
                return i - j;
            } else if (i < text.length() && pattern.charAt(j) != text.charAt(i)) {
                // 不匹配时,根据部分匹配表跳过一些可能不匹配的位置
                if (j != 0) {
                    j = lps[j - 1];
                } else {
                    i++;
                }
            }
        }

        // 没有找到匹配
        return -1;
    }

    public static void main(String[] args) {
        String text = "ABABDABACDABABCABAB";
        String pattern = "ABABCABAB";
        int index = kmpSearch(text, pattern);

        if (index != -1) {
            System.out.println("匹配成功,起始位置:" + index);
        } else {
            System.out.println("未找到匹配");
        }
    }
}

5、时间复杂度

KMP算法的时间复杂度为O(m + n),其中m是模式串的长度,n是目标串的长度。相较于暴力算法,KMP算法在大多数情况下具有更好的性能。

下面是对KMP算法时间复杂度的详细讲解:

  1. 构建部分匹配表的时间复杂度: 构建部分匹配表的过程只需要遍历一次模式串,时间复杂度为O(m)。

  2. KMP匹配的时间复杂度: KMP算法的匹配阶段,在最坏情况下需要遍历整个目标串,但由于KMP算法的特性,它能够避免不必要的比较。具体而言,当模式串与目标串的某一部分不匹配时,KMP算法可以通过部分匹配表跳过一些已经比较过的字符。因此,在匹配阶段的总体时间复杂度为O(n)。

因此,KMP算法的总体时间复杂度为O(m + n)。相较于暴力算法的O((n-m+1) * m)来说,在目标串很长而模式串较短的情况下,KMP算法的性能更好。

你可能感兴趣的:(数据结构,算法)