BMY、KMP、BM、BMHS算法性能比较

　　前些日子研究了一下字符串匹配算法，突发奇想自己设计了一种新的字符串匹配算法，因为是基于BM的思想，所以暂且叫他BMY算法吧。传统的BM算法是基于坏字符规则和好后缀规则，从后向前的匹配字符串，每次发现失配时，会比较坏字符表和好后缀表，哪个对应的跳跃值大就用哪个跳跃值，这样的跳跃幅度比KMP算法要大很多。而我设计的BMY算法在失配后（失配字符称为尾1），会再比较一下失配字符前面那个字符（称为尾2）：如果尾1和尾2都不在模式串中，直接跳跃模式串长度+2；如果尾1在模式串尾，则跳跃1；如果尾1和尾2的组合在模式串中，则跳跃模式串长度-尾1尾2在模式串中的位置；如果尾2在模式串头，则跳跃模式串长度+1；其他情况一律跳跃模式串长度+2。流程框图如下：

　　　　　　

　　BMY算法设计维护了两张哈希表，其中哈希表m1用于验证匹配到的字符是否在模式串，哈希表m2存储【尾1+尾2】的双字符在模式串中的位置，具体的代码如下：

void BMY(string &pstr, const size_t &plen, string &sstr, const size_t &slen, int (&m1)[ALPHABET_SIZE], int (&m2)[ZuHe_SIZE], vector<int> &res) { int i,j;  //i:模式串游标 j:文本串游标 
    i = j = plen-1; int cnt = -1; while(j < slen) { num_bmy++; //模式串和文本串从后向前匹配 
        while( (i!=0) && pstr[i] == sstr[j]) { --i; --j; bidui_bmy++; } bidui_bmy++; //发现一个匹配的模式串 
        if(i==0 && pstr[i] == sstr[j]) { res.push_back(j); match_bmy++; } //匹配成功及出现失配的情况 
        j += (plen-i-1); if(m1[sstr[j+1]] == 0 && m1[sstr[j+2]] == 0)            //尾1和尾2都不在模式串中
            j += (plen + 2); else if(sstr[j+1] == pstr[plen-1])                      //尾1在模式串尾
            j += 1; else if( (cnt = m2[sstr[j+1]*256+sstr[j+2]]) != -1)     //尾1和尾2的组合在模式串中 
            j += (plen - cnt); else if(sstr[j+2] == pstr[0])                           //尾2在模式串头 
            j += (plen + 1); else j += (plen + 2); cnt = -1; i = plen - 1; } }

　　最后，比较KMP、BM、BMHS、BMY四种算法的匹配时间、匹配次数、比对次数，得到的结果如下：

　　　　　　

　　 从结果可以看出，自己设计的BMY算法和BM、BMHS相比时间性能上略差，但是已经比KMP强很多了。此外，BMY的匹配次数和比对次数明显少于其他算法，但在运行时间上却没有对应的优势，我猜想是BMY在选择跳跃幅度上做了太多选择比较耗费了时间。

　　下面贴出全部测试代码：

#include <iostream> #include <cstring> #include <sstream> #include <vector> #include <algorithm> #include <unordered_map> #include <map> #include <ctime> #include <iterator> #include <fstream>
using namespace std; #define ALPHABET_SIZE 32767
#define ZuHe_SIZE 32767

int match_kmp = 0; int match_bmy = 0; int match_bm = 0; int match_bmhs = 0; int num_kmp = 0; int num_bmy = 0; int num_bm = 0; int num_bmhs = 0; int bidui_kmp = 0; int bidui_bm = 0; int bidui_bmy = 0; int bidui_bmhs = 0; void InitBMHS(int *alphabet, string &des, size_t plen) { for (int i=0; i<ALPHABET_SIZE; i++) alphabet[i] = plen; for (int i=0; i<plen; i++) alphabet[des[i]] = plen - i - 1; } void sunday(string &src, size_t len_s, string &des, size_t len_d, int *alphabet, vector<int> &res) { int i, pos = 0; for (pos = 1; pos <= len_s - len_d + 1;) { num_bmhs++; for (i=pos+len_d-2; i>=pos-1 ; i--) { if (src[i] == des[i-pos+1]) { bidui_bmhs++; } else if (src[i] != des[i-pos+1]) { bidui_bmhs++; break; } } if ((i-pos+2+len_d) == len_d) { match_bmhs++; res.push_back(pos-1); pos += len_d; } else { pos += alphabet[src[pos+len_d-1]] + 1; } } } void initP(string &pstr, int (&m1)[ALPHABET_SIZE], int (&m2)[ZuHe_SIZE]) { int len = pstr.size(); for(int i=0; i<len; ++i) { m1[pstr[i]] = 1; } for(int i=0; i<len-1; ++i) { m2[pstr[i]*256+pstr[i+1]] = i; } } void BMY(string &pstr, const size_t &plen, string &sstr, const size_t &slen, int (&m1)[ALPHABET_SIZE], int (&m2)[ZuHe_SIZE], vector<int> &res) { int i,j;  //i:模式串游标 j:文本串游标 
    i = j = plen-1; int cnt = -1; while(j < slen) { num_bmy++; //模式串和文本串从后向前匹配 
        while( (i!=0) && pstr[i] == sstr[j]) { --i; --j; bidui_bmy++; } bidui_bmy++; //发现一个匹配的模式串 
        if(i==0 && pstr[i] == sstr[j]) { res.push_back(j); match_bmy++; } //匹配成功及出现失配的情况 
        j += (plen-i-1); if(m1[sstr[j+1]] == 0 && m1[sstr[j+2]] == 0)          //尾1和尾2都不在模式串中
            j += (plen + 2); else if(sstr[j+1] == pstr[plen-1])                    //尾1在模式串尾
            j += 1; else if( (cnt = m2[sstr[j+1]*256+sstr[j+2]]) != -1)   //尾1和尾2的组合在模式串中 
            j += (plen - cnt); else if(sstr[j+2] == pstr[0])                         //尾2在模式串头 
            j += (plen + 1); else j += (plen + 2); cnt = -1; i = plen - 1; } } void GetNext(string p, int (&next)[ALPHABET_SIZE]) { int pLen = p.size(); next[0] = -1; int k = -1; int j = 0; while (j < pLen-1 ) { if(k == -1 || p[j] == p[k]) //p[k]表示前缀，p[j]表示后缀 
 { ++k; ++j; next[j] = k;  // k == next[j-1] + 1
 } else { k = next[k];  // next[k] == next[next[j]](递归的思想）
 } } } void KMP_Search(string &s, size_t slen, string &p, size_t plen, int (&next)[ALPHABET_SIZE], vector<int> &res) { int i = 0; int j = 0; while (j < slen)  // i:模式串游标 j:文本串游标 
 { num_kmp++; //模式串和文本串从前向后匹配 
        while(i == -1 || s[j] == p[i]) { i++; j++; bidui_kmp++; if(i == plen) break; } bidui_kmp++; //找到匹配的模式串 
          if(i == plen) { res.push_back(j-i); j += 1; i = 0; match_kmp++; } //出现失配的情况 
         else { //如果i != -1，且当前字符匹配失败（即S[i] != P[j]），则令j不变，i = next[j],使模式串右移 
             i = next[i]; } } } void BuildBadC(string &pattern, size_t pattern_length, unsigned int *badc, size_t alphabet_size) { unsigned int i; for(i = 0; i < alphabet_size; ++i) { badc[i] = pattern_length; } for(i = 0; i < pattern_length; ++i) { badc[pattern[i] ] = pattern_length - 1 - i; } } void BuildGoodS(const char *pattern, size_t pattern_length, unsigned int* goods) { unsigned int i, j, c; for(i = 0; i < pattern_length - 1; ++i) { goods[i] = pattern_length; } //初始化pattern最末元素的好后缀值 
    goods[pattern_length - 1] = 1; //此循环找出pattern中各元素的pre值，这里goods数组先当作pre数组使用 
    for(i = pattern_length -1, c = 0; i != 0; --i) { for(j = 0; j < i; ++j) { if(memcmp(pattern + i, pattern + j, (pattern_length - i) * sizeof(char)) == 0) { if(j == 0) { c = pattern_length - i; } else { if(pattern[i - 1] != pattern[j - 1]) { goods[i - 1] = j - 1; } } } } } //根据pattern中个元素的pre值，计算goods值 
    for(i = 0; i < pattern_length - 1; ++i) { if(goods[i] != pattern_length) { goods[i] = pattern_length - 1 - goods[i]; } else { goods[i] = pattern_length - 1 - i + goods[i]; if(c != 0 && pattern_length - 1 - i >= c) { goods[i] -= c; } } } } void BM(string &pattern, size_t pattern_length, string &text, size_t text_length, unsigned int *badc, unsigned int *goods, vector<int> &res) { unsigned int i, j; i = j = pattern_length - 1; while(j < text_length) { num_bm++; //发现目标传与模式传从后向前第1个不匹配的位置 
        while((i != 0) && (pattern[i] == text[j])) { --i; --j; bidui_bm++; } bidui_bm++; //找到一个匹配的情况 
        if(i == 0 && pattern[i] == text[j]) { res.push_back(j); j += goods[0]; match_bm++; } else { //坏字符表用字典构建比较合适 
            j += goods[i] > badc[text[j]] ? goods[i] : badc[text[j]]; } i = pattern_length - 1; } } int main() { string pstr = "want"; ifstream fin("2.txt"); string sstr( (istreambuf_iterator<char>(fin)), istreambuf_iterator<char>() ); for(int i=0; i<5; i++) sstr.insert(sstr.end(),sstr.begin(),sstr.end()); const char* pstr_ = pstr.data(); const size_t plen = pstr.size(); const size_t slen = sstr.size(); /*BMHS*/
    int alphabet[ALPHABET_SIZE] = { 0 }; InitBMHS(alphabet, pstr, plen); vector<int> res4; clock_t start4 = clock(); sunday(sstr, slen, pstr, plen, alphabet, res4); cout<<"BMHS 时间: "<<(double)(clock()-start4)/CLOCKS_PER_SEC*1000<<"ms"<<endl; cout<<"BMHS 识别模式串个数: "<<match_bmhs<<endl; cout<<"BMHS 匹配次数: "<<num_bmhs<<endl; cout<<"BMHS 比对次数："<<bidui_bmhs<<endl<<endl; // for(auto it : res4) // cout<<it<<endl;

    /*KMP*/
    int next[ALPHABET_SIZE]; for(int i=0; i<ALPHABET_SIZE; i++) next[i] = -1; GetNext(pstr, next); vector<int> res2; clock_t start2 = clock(); KMP_Search(sstr, slen, pstr, plen, next, res2); cout<<"KMP 时间: "<< (double)(clock()-start2)/CLOCKS_PER_SEC*1000<<"ms"<<endl; cout<<"KMP 识别模式串个数: "<<match_kmp<<endl; cout<<"KMP 匹配次数: "<<num_kmp<<endl; cout<<"KMP 比对次数："<<bidui_kmp<<endl<<endl; // for(auto it : res2) // cout<<it<<endl;

    /*BMY*/
    int m1[ALPHABET_SIZE] = {0}; int m2[ZuHe_SIZE]; for(int i=0; i<ZuHe_SIZE; i++) m2[i] = -1; initP(pstr, m1, m2); vector<int> res1; clock_t start = clock(); BMY(pstr, plen, sstr, slen, m1, m2, res1); cout<<"BMY 时间: "<< (double)(clock()-start)/CLOCKS_PER_SEC*1000<<"ms"<<endl; cout<<"BMY 识别模式串个数: "<<match_bmy<<endl; cout<<"BMY 匹配次数: "<<num_bmy<<endl; cout<<"BMY 比对次数："<<bidui_bmy<<endl<<endl; // for(auto it : res1) // cout<<it<<endl;

    /*BM*/ unsigned int badc[256]; unsigned int goods[plen]; BuildBadC(pstr, plen, badc, 256); BuildGoodS(pstr_, plen, goods); vector<int> res3; clock_t start3 = clock(); BM(pstr, plen, sstr, slen, badc, goods, res3); cout<<"BM 时间: "<< (double)(clock()-start3)/CLOCKS_PER_SEC*1000<<"ms"<<endl; cout<<"BM 识别模式串个数: "<<match_bm<<endl; cout<<"BM 匹配次数: "<<num_bm<<endl; cout<<"BM 比对次数："<<bidui_bm<<endl<<endl; // for(auto it : res3) // cout<<it<<endl;
    
    return 0; }