字串匹配演算法總結

來源:互聯網
上載者:User

我想說一句“我日,我討厭KMP!”。
KMP雖然經典,但是理解起來極其複雜,好不容易理解好了,便起碼來巨麻煩!
老子就是今天圖書館在寫了幾個小時才勉強寫了一個有bug的、效率不高的KMP,特別是計算next數組的部分。

其實,比KMP演算法速度快的演算法大把大把,而且理解起來更簡單,為何非要抓住KMP呢?筆試出現字串模式比對時直接上sunday演算法,既簡單又高效,何樂而不為?
說實話,想到sunday演算法的那個人,絕對是發散思維,絕對牛。當我在被KMP折磨的夠嗆的時候,我就琢磨,有沒有別的好演算法呢??琢磨了半天也沒想出個所以然來。笨啊,腦子不夠發散。

下面貼上一位兄弟寫的演算法總結,很簡單(建議KMP部分就不用看了,看了費腦子)。
參見:http://hi.baidu.com/willamette/blog/item/02bd0b5599c8b4c0b645ae06.html

趁著做Presentation的功夫,順便做一個總結

字串匹配:

---willamette

在匹配串中尋找模式串是否出現,注意和最長公用子序列相區別(LCS: Longest Common Substring)

-: Brute Force(BF或蠻力搜尋) 演算法:

這是世界上最簡單的演算法了。
首先將匹配串和模式串靠左對齊,然後從左向右一個一個進行比較,如果不成功則模式串向右移動一個單位。

速度最慢。

那麼,怎麼改進呢?

我們注意到Brute Force 演算法是每次移動一個單位,一個一個單位移動顯然太慢,是不是可以找到一些辦法,讓每次能夠讓模式串多移動一些位置呢?

當然是可以的。

我們也注意到,Brute Force 是很不intelligent 的,每次匹配不成功的時候,前面匹配成功的資訊都被當作廢物丟棄了,當然,就如現在的變廢為寶一樣,我們也同樣可以將前面匹配成功的資訊利用起來,極大地減少電腦的處理時間,節省成本。^_^

注意,蠻力搜尋演算法雖然速度慢,但其很通用,文章最後會有一些更多的關於蠻力搜尋的資訊。

-: KMP演算法

首先介紹的就是KMP 演算法。

原始論文:Knuth D.E., Morris J.H., and Pratt V.R., Fast pattern matching in strings, SIAM Journal on Computing, 6(2), 323-350, 1977.

這個演算法實在是太有名了,大學上的演算法課程除了最笨的Brute Force 演算法,然後就介紹了KMP 演算法。也難怪,呵呵。誰讓Knuth D.E. 這麼world famous 呢,不僅拿了圖靈獎,而且還寫出了電腦界的Bible <The Art of Computer Programming>( 業內人士一般簡稱TAOCP). 稍稍提一下,有個叫H.A.Simon 的傢伙,不僅拿了Turing Award ,順手拿了個Nobel Economics Award ,做了AI 的爸爸,還是Chicago
Univ 的Politics PhD ,可謂全才。

KMP 的思想是這樣的:

利用不匹配字元的前面那一段字元的最長前尾碼來儘可能地跳過最大的距離

比如

模式串ababac 這個時候我們發現在c 處不匹配,然後我們看c 前面那串字串的最大相等前尾碼,然後再來移動

下面的兩個都是模式串,沒有寫出來匹配串

原始位置 ababa c

移動之後 aba bac

因為尾碼是已經匹配了的,而首碼和尾碼是相等的,所以直接把首碼移動到原來尾碼處,再從原來的c 處,也就是現在的第二個b 處進行比較。 這就是KMP 。

-:Horspool演算法

Horspool 演算法。

當然,有市場就有競爭,字串匹配這麼大一個市場,不可能讓BF 和KMP 全部佔了,於是又出現了幾個強勁的對手。

第一個登場的是

論文:Horspool R.N., 1980, Practical fast searching in strings, Software - Practice & Experience, 10(6):501-506

Horspool 演算法的思想很簡單的。不過有個創新之處就是模式串是從右向左進行比較的。很好很強大,為後來的演算法影響很大。

匹配串:abcbc sdxzcxx

模式串:cbcac

這個時候我們從右向左進行對暗號,c-c ,恩對上了,第二個b-a ,不對啊,我們應該怎麼辦?難道就這麼放棄麼。於是,模式串從不匹配的那個字元開始從右向左尋找匹配串中不匹配的字元b 的位置,結果發現居然有,趕快對上趕快對上,別耽誤了。

匹配串:abcbcsd xzcxx

模式串: cbcac

然後繼續從最右邊的字元從右向左進行比較。這時候,我們發現了,d-c 不匹配啊,而且模式穿裡面沒有噢,沒辦法,只好移動一個模式串長度的單位了。

匹配串:abcbcsdxzcxx

模式串:      cbcac

-:Boyer-Moore演算法

第二個上來的是Boyer-Moore 演算法。

是一個很複雜的演算法,當然,雖然理論上時間複雜度和KMP 差不多,但是實際上卻比KMP 快數倍,可見實踐是檢驗真理的唯一標準。

原始論文:R.S.Boyer, J.S.Moore, A fast string searching algorithm , Communications of the ACM,20(10):762-772 ,1977

分為兩步預先處理,第一個是bad-character heuristics ,也就是當出現錯誤匹配的時候,移位,基本上就是做的Horspool 那一套。

第二個就是good-suffix heuristics ,當出現錯誤匹配的時候,我還要從不匹配點向左看啊,以前匹配的那段子字串是不是在模式串本身中還有重複的啊,有重複的話,那麼我就直接把重複的那段和匹配串中已經匹配的那一段對齊就是了。再比較

匹配串:abaccba bbazz

模式串:cbadcba

我們看到已經匹配好了cba ,但是c-d 不匹配,這個時候我們發現既可以採用bad-character heuristics ,也可以使用good-suffix heuristics( 模式串:cba dcba ) ,在這種情況下,邪不壓正。毅然投奔good 。移動得到

匹配串:abaccbabbaz z

模式串:    cbadcba

可是,我們有時候也發現,已經匹配好的那一部分其實並沒有再有重複了的啊。這個時候,我們發現已經匹配好的那串字串有一部分在開頭重新出現了,那麼,趕快,對齊吧。

匹配串:abacccb bbazz

模式串:cbadccb

然後得到

匹配串:abacccbbbazz

模式串:     cbadccb

當兩種Good-Suffix 出現的時候,取移動距離最大的那個。
(
對於BM演算法,好規則和壞規則,這裡講的不夠明確,下面推薦一個講解非常優秀的文章,可謂圖文並茂啊,而且還是個MM寫的。
Boyer-Moore 經典單模式比對演算法
http://blog.csdn.net/iJuliet/archive/2009/05/19/4200771.aspx

)

-:Sunday演算法

最後一個是Sunday 演算法,實際上比Boyer-Moore 還快,呵呵。長江後浪推前浪。

原始論文:Daniel M. Sunday, A very fast substring search algorithm, Communications of the ACM, v.33 n.8, p.132-142, Aug. 1990

看原始論文的題目,D.M. Sunday 貌似是故意想氣氣Boyer-Moore 兩位大牛似的。呵呵。不過實際上的確Sunday 演算法的確比BM 演算法要快,而且更簡單。

Sunday 的演算法思想和Horspool 有些相似,但是。當出現不匹配的時候,卻不是去找匹配串中不匹配的字元在模式串的位置,而是直接找最右邊對齊的右一位的那個字元在模式串的位置。

比如:

匹配串:abcbc zdxzc

模式串:zbcac

恩,這裡我們看到b-a 沒有對上,我們就看匹配串中的z 在模式串的位置,然後,嘿嘿。

匹配串:abcbczdxzc

模式串:     zbcac

如果模式串中的沒有那個字元怎麼辦呢?很簡單,跳過去唄。

匹配串:abcbc edxzcs

模式串:zbcac

e 不在模式串中出現

那麼我們就

匹配串:abcbcedxzcs

模式串:      zbcac

(2009/10/20補充)
RK演算法

某一天在圖書館的一本演算法分析設計書上翻到的。思路很新穎!和大家分享下。
在串匹配的簡單演算法中,把文本每m個字元構成的字元段作為一個欄位,和模式進行匹配檢查。如果能對一個長度為m的字元

串賦以一個Hash函數。那麼顯然只有那些與模式具有相同hash函數值的文本中的字串才有可能與模式比對,這是必要條件

,而沒有必要去考慮文本中所有長度為m的欄位,因而大大提高了串匹配的速度。因此RK演算法的思想和KMP,BM,Sunday等思

路迥然不同!
(事實上,之前的串匹配方法,是將模式串的一個一個字元作為小的特徵去分別進行匹配,而RK演算法則是將串整體作為一個

特徵!難就難在單個字元的特徵很容易想得到,整體作為一個特徵就沒那麼容易想得到了)
如果把整體作為一個特徵,那麼如何快速的求出這個整體特徵的特徵值??
模式串的特徵值僅需求一次即可。對於文本中的任意m個字元構成的字串如何快速的求特徵就是個痛點了。
拋磚引玉,這裡給出一個簡單的特徵計算。 將字串的每一個字元看做一個數,那麼這個字串的就是一個數字數組,通

過積分向量可以快速任意一個長度子字串的向量和。可以把字串的對應的字元數組的元素和看做這個字串整體特徵。

這個特徵是可以再O(1)的時間內求出的。其實原始的RK演算法裡面是把字串看做一個26進位數在計算特徵的。這裡就不囉

嗦了,有興趣的可以深入尋找

aabsee sds 模式串 ees
      ees

發現 see向量和 == ees的向量和
然後就對see和ees做逐個字元的比較。發現不匹配繼續往下走
aabsees ds 模式串 ees
        ees
發現 ees向量和 == ees的向量和
然後就對ees和ees做逐個字元的比較。發現匹配OK。

另外還有 字串匹配自動機 尾碼樹演算法(分線上和非線上兩種)等 見如下文章。不能說那個比那個更好,各個演算法都有自己的優勢及最佳應用場合。參考:
http://blog.csdn.net/yifan403/archive/2009/06/16/4272793.aspx

另外,關於多模式字串匹配 有AC演算法(字串匹配自動機思想) WM演算法(BM在多模式的推廣應用)
參考:
http://blog.csdn.net/ijuliet/category/498465.aspx  該女子的blog有很多好文章。

/**********************華麗分割線******************************/
附上sunday代碼:
http://hi.baidu.com/kmj0217/blog/item/6f837f2f3da097311e3089cb.html

一種比KMP 和 BM 更高效的匹配演算法(如果想看原英文介紹,看下面分割線後的網址)

適用於:模式串較短的情況,最壞時間複雜性為O(N*M),不過一般沒這麼壞

Sunday 演算法其實思想跟BM演算法很相似,只不過Sunday演算法是從前往後匹配,在匹配失敗時關注的是文本串中參加匹配的最末位字元的下一位字元。如果該字元沒有在匹配串中出現則直接跳過,即移動步長= 匹配串長度+ 1;否則,同BM演算法一樣其移動步長=匹配串中最右端的該字元到末尾的距離+1。

 

代碼如下:

/*

Sunday-字串匹配演算法 -- 一種優於 KMP 的演算法

思想類似於BM 演算法,只不過是從左向右匹配

遇到不匹配的看大串中匹配範圍之外的右側第一個字元在小串中的最右位置

另外:採用BM/KMP 的預先處理的做法,事先計算好移動步長 ,等到遇到不匹配的值直接使用

*/

#include<iostream>

#include<string.h>

using namespace std;

//一個字元8位 最大256種

#define MAX_CHAR_SIZE 256

 

/*設定每個字元最右移動步長,儲存每個字元的移動步長

如果大串中匹配字元的右側一個字元沒在子串中,大串移動步長= 整個串的距離 +1

   如果大串中匹配範圍內的右側一個字元在子串中,大串移動距離= 子串長度 - 這個字元在子串中的位置

*/

int *setCharStep(char *subStr)

{

     int *charStep=new int[MAX_CHAR_SIZE];

     int subStrLen=strlen(subStr);

     for(int i=0;i<MAX_CHAR_SIZE;i++)

             charStep[i]=subStrLen+1;

     //從左向右掃描一遍 儲存子串中每個字元所需移動步長

     for(int i=0;i<subStrLen;i++)

     {

            charStep[(unsigned char)subStr[i] ]=subStrLen-i;
        

     }

     return charStep;

}

/*

   演算法核心思想,從左向右匹配,遇到不匹配的看大串中匹配範圍之外的右側第一個字元在小串中的最右位置

   根據事先計算好的移動步長移動大串指標,直到匹配

*/

int sundaySearch(char *mainStr,char *subStr,int *charStep)

{

     int mainStrLen=strlen(mainStr);

     int subStrLen=strlen(subStr);

     int main_i=0;

     int sub_j=0;

     while(main_i<mainStrLen)

     {                  

            //儲存大串每次開始匹配的起始位置,便於移動指標

             int tem=main_i;

             while(sub_j<subStrLen)

             {

                    if(mainStr[main_i] ==   subStr[sub_j])

                    {

                            main_i++;

                            sub_j++;

                            continue;                   

                    }                

                    else{

                        //如果匹配範圍外已經找不到右側第一個字元,則匹配失敗

                         if(tem+subStrLen > mainStrLen)

                                     return -1;

                         //否則 移動步長 重新匹配

                         char firstRightChar=mainStr[tem+subStrLen];

                         main_i =tem + charStep[(unsigned char)firstRightChar];

                         sub_j=0;   

                         break;//退出本次失敗匹配 重新一輪匹配

                    }  

             }

             if(sub_j == subStrLen)

                       return main_i-subStrLen;

     }

     return -1;

}

int main()

{

         char *mainStr="absaddsasfasdfasdf";

         char *subStr="dd";

         int *charStep=setCharStep(subStr);

         cout<<"位置: "<<sundaySearch(mainStr,subStr,charStep)<<endl;

         system("pause");

         return 0;    

}

 

/*************************************************華麗的分割線***************************************/

演算法介紹以及實現偽碼:http://www-igm.univ-mlv.fr/~lecroq/string/node19.html

void preQsBc(char *x, int m, int qsBc[]) {
   int i;

   for (i = 0; i < ASIZE; ++i)
      qsBc[i] = m + 1;
   for (i = 0; i < m; ++i)
      qsBc[x[i]] = m - i;
}

void QS(char *x, int m, char *y, int n) {
   int j, qsBc[ASIZE];

   /* Preprocessing */
   preQsBc(x, m, qsBc);

   /* Searching */
   j = 0;
   while (j <= n - m) {
      if (memcmp(x, y + j, m) == 0)
         OUTPUT(j);
      j += qsBc[y[j + m]];               /* shift */
   }
}


// 第三個代碼實現,貌似比較高效
http://hi.baidu.com/azuryy/blog/item/10d3d3460b97af0e6b63e5cd.html

標頭檔定義:
/* Sunday.h */
class Sunday
{
public:
   Sunday();
   ~Sunday();

public:
    int find(const char* pattern, const char* text);

private:
    void preCompute(const char* pattern);

private:
    //Let's assume all characters are all ASCII
    static const int ASSIZE = 128;
    int _td[ASSIZE] ;
    int _patLength;
    int _textLength;
};

源檔案
/* Sunday.cpp */

Sunday::Sunday()
{
}

Sunday::~Sunday()
{
}

void Sunday::preCompute(const char* pattern)
{
    for(int i = 0; i < ASSIZE; i++ )
        _td[i] = _patLength + 1;

    const char* p;
    for ( p = pattern; *p; p++)
        _td[*p] = _patLength - (p - pattern);
}

int Sunday::find(const char* pattern, const char* text)
{
    _patLength = strlen( pattern );
    _textLength = strlen( text );

    if ( _patLength <= 0 || _textLength <= 0)
        return -1;

    preCompute( pattern );

    const char *t, *p, *tx = text;

    while (tx + _patLength <= text + _textLength)
    {
        for (p = pattern, t = tx; *p; ++p, ++t)
        {
            if (*p != *t)
                break;
        }
        if (*p == 0)
            return tx-text;
        tx += _td[tx[_patLength]];
    }
    return -1;
}

簡單測試下:
int main()

{
    char* text = "blog.csdn,blog.net";
    char* pattern = "csdn,blog"    ;
    Sunday sunday;

    printf("The First Occurence at: %d/n",sunday.find(pattern,text));

    return 1;
}

////////////////////////////////////////////
strstr的實現。
需要說明的是strstr是c語言提供的使用Brute Force實現的字串匹配,簡單、通用是其最大的優點。時間複雜度是O(mn)
// 下面是Microsoft的實現
//經典演算法
//比KMP演算法簡單,沒有KMP演算法高效
char * __cdecl strstr (
        const char * str1,
        const char * str2
        )
{
        char *cp = (char *) str1;
        char *s1, *s2;
        if ( !*str2 )
            return((char *)str1);
        while (*cp)
        {
                s1 = cp;
                s2 = (char *) str2;
                while ( *s1 && *s2 && !(*s1-*s2) )
                        s1++, s2++;
                if (!*s2)
                        return(cp);
                cp++;
        }
        return(NULL);
}

本文來自CSDN部落格,轉載請標明出處:http://blog.csdn.net/whoismickey/archive/2009/02/08/3869367.aspx

strstr   glibc裡的strstr函數用的是brute-force(naive)演算法,它與其它演算法的區別是strstr不對pattern(needle)進行預先處理,所以用起來很方便。理論複雜度O(mn), 實際上,平均複雜度為O(n), 大部分情況下高度最佳化的演算法效能要優於基於自動機的匹配演算法,關於串匹配演算法可參考http://www-igm.univ-mlv.fr/~lecroq/string/ 。 glibc中使用了(1)Stephen R. van den Berg的實現,在他的基礎上,(2)Tor Myklebust
http://sources.redhat.com/ml/libc-alpha/2006-07/msg00028.html 給出了更複雜的實現,當然也更高效。  BF有一個重要性質是事先不用知道串的長度,而基於跳躍的演算法是需要用字串長度來判斷結束位置的。如何快速的確定字串結束位置,可參考http://www.cppblog.com/ant/archive/2007/10/12/32886.html ,寫的很仔細。 將兩種思想結合起來,可以做出更快的strstr(3)。約定(1) 為strstrBerg; (2) 為strstrBergo,(3)為lstrstr,(4)為glibc中的strstr,簡單測試了一下:從長度為2k的文本中尋找長度為1、2、9的模式串,結果如下         1               2              9 (1)0.000006 0.000006 0.000012    (2)0.000007 0.000004 0.000008 (3)0.000002 0.000002 0.000005 (4)0.000005 0.000005 0.000011
下載strstr和測試程式 ,
下載後執行 :
            unzip testStrstr.zip
            cd testStrstr
            make test 基於sse2的strstr函數 是用sse2指令集對strstr的最佳化

聯繫我們

該頁面正文內容均來源於網絡整理,並不代表阿里雲官方的觀點,該頁面所提到的產品和服務也與阿里云無關,如果該頁面內容對您造成了困擾,歡迎寫郵件給我們,收到郵件我們將在5個工作日內處理。

如果您發現本社區中有涉嫌抄襲的內容,歡迎發送郵件至: info-contact@alibabacloud.com 進行舉報並提供相關證據,工作人員會在 5 個工作天內聯絡您,一經查實,本站將立刻刪除涉嫌侵權內容。

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.