字符串匹配算法

今天一天鼓捣了两种字符串匹配的算法，KMP算法和BM算法，说实话，BM算法还是第一次听说，以前只知道BM算法的说，总之一句话，要学习的还是很多的，看了BM算法，只能感叹作者的高大上了。看了好几篇文章，终于算是把BM算法实现了，并且调试运行成功了，把这学习的经过记录下来，聊表纪念。

#include <iostream>
#include <string.h>
#include <stdlib.h>

using namespace std;
//字符串匹配算法，普通的双字符扫描算法不多讲效率很慢O(m*n)的复杂度
//下面主要讲述的KMP算法和BM算法
//http://www.searchtb.com/2011/07/%E5%AD%97%E7%AC%A6%E4%B8%B2%E5%8C%B9%E9%85%8D%E9%82%A3%E4%BA%9B%E4%BA%8B%EF%BC%88%E4%B8%80%EF%BC%89.html

//KMP算法；http://www.ruanyifeng.com/blog/2013/05/Knuth%E2%80%93Morris%E2%80%93Pratt_algorithm.html
//此方法主要利用了已经搜索过的字符串的位置信息，利用被搜索的字符串的字符出现位置规律
//时间复杂度O(m+n)

void getNext(string p,int *next){
    int len=p.length(),i=0,k=-1;
    if(len<=0) return;
    next[i]=-1;
    
    while(i<len-1){
        if(k==-1||p[i]==p[k]){//p[k]表示前缀，p[i]表示后缀 
            k++;
            i++;
            if(p[i]!=p[k]) 
                next[i]=k;//若只有这一行，则会做很多无用功
            else 
                next[i]=next[k];//因为不能出现p[i] = p[ next[i ]]，所以当出现时需要继续递归，k = next[k] = next[next[k]]  
        } else {
            k=next[k];
        }
    }
}

int kmp_search(string s,string p,int *next){
    int sLen=s.length(),pLen=p.length();
    if(sLen<=0||pLen<=0) return -1;

    int i=0,j=0;
    while(i<sLen&&j<pLen){
        if(j==-1||s[i]==p[j]){
            i++;
            j++;
        } else if(s[i]!=p[j]) {
            j=next[j];
        }
    }
    if(j==pLen) return i-j;
    return -1;
}


//BM算法 http://www.ruanyifeng.com/blog/2013/05/boyer-moore_string_search_algorithm.html
//http://www.cnblogs.com/a180285/archive/2011/12/15/BM_algorithm.html
//此方法从被搜索字符串的最后一个位置来比较字符串，当失配时候，可以根据失配位置和被搜索字符串本身省去无效回溯。要比KMP算法更快
//坏字符规则 好后缀规则 
//最好情况下的时间复杂度为O(n/m)，最坏情况下时间复杂度为O(m·n)。n为母串长度，m是模式串长度

//创建坏字符规则，若坏字符没有出现在模式串中，则直接将模式串移动到坏字符的下一个字符中
//若坏字符在模式串中，则把字符串移动到第一个出现坏字符的位置与坏字符重合的位置
#define ASIZE 256
#define XSIZE 100
//坏字符规则
void preBmBc(char *x, int m, int bmBc[]) {
    int i;
    for (i = 0; i<ASIZE; ++i)
        bmBc[i] = m;
    for (i = m-2; i >=0; --i)
        bmBc[x[i]] = m - i - 1;
 68 }

//好后缀规则，前缀和后缀的最大公共串的长度,从串开头到下标为i的前缀
void suffixes(char* P, int m, int suffix[]){
    int i=0,q=0;
    suffix[m-1]=m;
    for (i=m-2;i>=0;--i){
        q=i;
        while(q>=0&&P[q]==P[m-1-i+q])
            --q;
        suffix[i]=i-q;
    }
}
//计算完好后缀之后，要计算bmGs[i] 表示遇到好后缀时，模式串应该移动的距离，
//其中i表示好后缀前面一个字符的位置（也就是坏字符的位置）
void preBmGs(char *x, int m, int bmGs[]) {
    int i, j, suff[XSIZE];
    suffixes(x, m, suff);
    for (i = 0; i < m; ++i)
        bmGs[i] = m;
    j = 0;
    for (i = m - 1; i >= 0; --i)
        if (suff[i] == i + 1)
            for (; j < m - 1 - i; ++j)//模式串中没有子串匹配上好后缀，但找到一个最大前缀
                if (bmGs[j] == m)
                    bmGs[j] = m - 1 - i;
    for (i = 0; i <= m - 2; ++i)//模式串中有子串匹配上好后缀
        bmGs[m - 1 - suff[i]] = m - 1 - i;
    }

void BM_search(char*T,char*P,int m,int bmGs[],int bmBc[]){
    int i=0,j = 0;
    while (j <= strlen(T) - strlen(P)) {
        for (i = strlen(P) - 1; i >= 0 && P[i] ==T[i + j]; --i){}
        if (i < 0){
            cout<<j<<endl;//找到匹配
            break;
        } else {
            j += max(bmGs[i], bmBc[T[i]]-(m-1-i));
        }
    }
}

int main(int argc,char**argv)
{
    char* s="abcdababda", *p="ababda";
    
    /*int *next=(int*)malloc(p.length()*sizeof(int));
    getNext(p,next);
    int i=kmp_search(s,p,next);
    cout<<i<<endl;*/

    int bmBc[ASIZE],bmGs[XSIZE];
    preBmBc(p,strlen(p),bmBc);
    preBmGs(p,strlen(p),bmGs);
    BM_search(s,p,strlen(p),bmGs,bmBc);

    return 0;
}