字符串匹配——BF算法与KMP算法

本文详细介绍了两种常用的字符串匹配算法——BF算法和KMP算法。通过具体实例解释了这两种算法的工作原理,并提供了相应的代码实现。此外,还分析了两种算法的时间复杂度。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

【问题描述】

给定两个字符串S和T,在主串S中查找子串T,若主串中包含子串,则返回子串在主串中开始的位置,否则返回-1。

 


【BF算法】

匹配过程:

假设主串S为 abcabcacb

       子串T为 abcac

第一趟匹配:a b c a b c a c b \0

                      a b c a c \0

第二趟匹配:a b c a b c a c b \0

                         a b c a c \0

第三趟匹配:a b c a b c a c b \0

                           a b c a c \0

第四趟匹配:a b c a b c a c b \0

                               a b c a c \0

算法描述:

输入:主串S,模式T

输出:T在S中的位置

1.初始化主串比较的开始位置index=0;

2.在串S和串T中设置比较的起始下标i=0,j=0;

3.重复下述操作,直到S或T的所有字符均比较完毕:

   3.1   如果S[i]等于T[j],则继续比较S和T的下一对字符;

   3.2   否则,下一趟匹配的开始位置index++,回溯下标i=index,j=0;

4.如果T中所有字符均比较完,则返回匹配的开始位置index;否则返回0;

代码实现:


int BF(char s[],char t[])
{
    int index=0;
    int i=0,j=0;
    while((s[i]!='\0')&&(t[j]!='\0'))
    {
        if(s[i]==t[j])
        {i++;j++;}
        else
        {index++;i=index;j=0;}
    }
    if(t[j]=='\0')return index;
    else return 0;
}

算法分析:

设主串S长度为n,模式T长度为m,在匹配成功的情况下,考虑最坏情况,即每趟不成功的匹配都发生在模式T的最后一个字符。

例如 :S="aaaaaaaaaaaaaab"

            T="aaab"

设匹配成功发生在 Si 处,则在 i-1 趟不成功的匹配中共比较了 (i-1)×m 次,第 i 趟成功的匹配共比较了 m 次,所以总共比较次数是:

\sum_{i=1}^{n-m+1}Pi\ast \left ( i\ast m \right )= \sum_{i=1}^{n-m+1}\frac{1}{n-m+1}\ast \left ( i\ast m \right )= \frac{m\left ( n-m+2 \right )}{2}

一般情况下,m\lln,因此最坏情况下的时间复杂度为O(m×n)。

 【KMP算法】

确定Next数组:

next=\left\{\begin{matrix} -1 &&j=0 \\ max\left \{ k|1\leqslant k< j,T[0]\cdot\cdot\cdot T[k-1]=T[j-k]\cdot \cdot \cdot T[j-1]\right \}&& empty\\ 0& &else \end{matrix}\right.

例如:子串=“ababc”

jT比较前后缀比较最长匹配度next[j]
0 -1
1a0
2ab0
3aba1
4abab2

KMP匹配:

算法描述:

输入:主串S,模式T

输出:T在S中的位置

1.  在串S中和串T中分别设置比较的起始下标 i = 0 , j = 0;

2.  重复下述操作,知道S或T的所有字符均比较完毕:

  2.1   如果S[i]等于T[j],则继续比较S和T的下一对字符;

  2.2   否则,将下标j回溯到next[j]的位置,即j=next[j];

  2.3   如果 j 等于-1,则将下标 i 和 j 分别加 1 ,准备下一趟比较;

3.  如果T中所有字符均比较完毕,则返回本趟比较匹配的开始位置;否则返回-1;

代码实现:

void getNext(char *p,int next[])
{
    int j=0,k=-1,plen=strlen(p);
    next[0]=-1;
    while(j<plen-1)
    {
        if(k==-1||p[j]==p[k])
        {
            ++k;++j;
            next[j]=k;
        }
        else
            k=next[k];
    }
}
int KMPsearch(char* s,char* p)
{
    int i=0,j=0,slen=strlen(s),plen=strlen(p),next[100];
    getNext(p,next);
    while(i<slen&&j<plen)
    {
        if(j==-1||s[i]==p[j])
        {
            i++;j++;
        }
        else
            j=next[j];
    }
    if(j==plen)
        return i-j;
    else
        return -1;
}

 

算法分析:

算法getNext只需将模式扫描一遍,设模式的长度为 m ,则算法的时间复杂性为O(m)。

【参考文献】《算法设计与分析(第2版)》王红梅 胡明 编著

### BF算法KMP算法的实现方式 #### BF算法 暴力匹配BF算法是一种简单的字符串匹配方法。该算法通过逐一比较模式中的字符来查找匹配项。具体来说,在每次不匹配的情况下,指针会回溯到上一次匹配起始位置之后的一个新位置,而模式则重新从头开始匹配[^2]。 ```java public boolean bf(String text, String pattern) { int n = text.length(); int m = pattern.length(); for (int i = 0; i <= n - m; ++i) { int j; for (j = 0; j < m && pattern.charAt(j) == text.charAt(i + j); ++j); if (j == m) return true; // 找到了完整的匹配 } return false; } ``` #### KMP算法 相比之下,KMP算法利用了部分匹配的信息以避免不必要的重复扫描。当遇到不匹配的情况时,不是简单地将指针向前推进一位并重置模式指针至开头,而是依据预先计算好的`next`数组调整模式的位置继续尝试匹配。这样可以显著减少比较次数,提高效率[^3]。 ```java public class KMP { private static final void computeLPSArray(char[] pat, int M, int lps[]) { int length = 0; // 长度 of the previous longest prefix suffix int i = 1; lps[0] = 0; // LPS 的第一个值总是 0 while (i < M) { if (pat[i] == pat[length]) { length++; lps[i] = length; i++; } else { if (length != 0) { length = lps[length - 1]; } else { lps[i] = 0; i++; } } } } public static int KMPSearch(String txt, String pat) { int N = txt.length(), M = pat.length(); char T[] = txt.toCharArray(); char P[] = pat.toCharArray(); int lps[] = new int[M]; /* Preprocess the pattern */ computeLPSArray(P, M, lps); int i = 0; // index for txt[] int j = 0; // index for pat[] while ((N - i) >= (M - j)) { if (P[j] == T[i]) { j++; i++; } if (j == M) { System.out.println("Found pattern at index " + (i-j)); j = lps[j-1]; } // mismatch after j matches else if (i < N && P[j] != T[i]) { // Do not match lps[0..lps[j-1]] characters, // they will match anyway if (j != 0) j = lps[j-1]; else i = i+1; } } return -1; } } ``` ### 性能对比 对于最坏情况下的时间复杂度而言: - **BF算法**: O(n * m),其中n为长度,m为模式长度。这是因为每当发生失配时,都需要回到之前的状态重新开始比较。 - **KMP算法**: O(n + m),因为预处理阶段构建`next`数组的时间开销是O(m),而在实际搜索过程中每个字符最多只会被访问两次——一次作为的一部分,另一次可能是在模式内参比较。因此整体性能更优。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值