字符串匹配---暴力匹配算法

假設現在我們面臨這樣一個問題：有一個文本串S，和一個模式串P，現在要查找P在S中的位置，怎么查找呢？

首先，先理清楚了暴力匹配算法的流程及內在的邏輯：

如果用暴力匹配的思路，並假設現在文本串S匹配到 i 位置，模式串P匹配到 j 位置，則有：

• 如果當前字符匹配成功（即S[i] == P[j]），則i++，j++，繼續匹配下一個字符；
• 如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0。相當於每次匹配失敗時，i 回溯，j 被置為0。

 舉個例子，如果給定文本串S：“BBC ABCDAB ABCDABCDABDE”，和模式串P：“ABCDABD”，現在要拿模式串P去跟文本串S匹配，整個過程如下所示：

    1. S[0]為B，P[0]為A，不匹配，執行第②條指令：“如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0”，然后該判斷S[1]跟P[0]是否匹配，相當於模式串要往右移動一位（i=1，j=0）

   2. S[1]跟P[0]還是不匹配，繼續執行第②條指令：“如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0”，然后該判斷S[2]跟P[0]是否匹配（i=2，j=0），從而模式串不斷的向右移動一位（不斷的執行“令i = i - (j - 1)，j = 0”，i從2變到4，j一直為0）

   3. 直到S[4]跟P[0]匹配成功（i=4，j=0），此時按照上面的暴力匹配算法的思路，轉而執行第①條指令：“如果當前字符匹配成功（即S[i] == P[j]），則i++，j++”，可得S[i]為S[5]，P[j]為P[1]，即接下來判斷S[5]跟P[1]是否匹配（i=5，j=1）

 4. S[5]跟P[1]匹配成功，繼續執行第①條指令：“如果當前字符匹配成功（即S[i] == P[j]），則i++，j++”，得到S[6]跟P[2]匹配也成功（i=6，j=2），如此進行下去

5. 直到S[10]為空格字符，P[6]為字符D（i=10，j=6），因為不匹配，重新執行第②條指令：“如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0”，此時，i=5，j=0，相當於判斷S[5]跟P[0]是否匹配

 6. 至此，我們可以看到，如果按照暴力匹配算法的思路，盡管之前文本串和模式串已經分別匹配到了S[9]、P[5]，但因為S[10]跟P[6]不匹配，所以文本串就得回溯到S[5]，模式串回溯到P[0]，從而讓文本串又接着開始從S[5]跟模式串的P[0]去匹配。接下來的匹配過程無非就是類似的邏輯思路，直到找到匹配的字符串或文本串遍歷結束退出。

 

 

Java代碼實現暴力匹配字符串

/**
     * 暴力匹配字符串算法
     * 思路：
     * ①如果當前字符匹配成功（即S[i] == P[j]），則i++，j++
     * ②如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0 .相當於每次匹配失敗時，i 回溯，j 被置為0。
     * 時間復雜度為O(mn)（m、n分別為文本串和模式串的長度）。無需擴展存儲空間。
     * @param text 文本串
     * @param pattern 模式串
     * @return  pattern返回在text中的位置
     */
    public static int bruteForceSearchPatternInText(String text,String pattern){
        int sLen = text.length();
        int pLen = pattern.length();
        
        char[] s = text.toCharArray();
        char[] p = pattern.toCharArray();
        
        while(sLen < pLen){
            return -1;
        }
        
        int i = 0 ;
        int j = 0 ;
        while(i < sLen && j < pLen){
            if(s[i] == p[j]){
                //如果當前字符匹配成功（即S[i] == P[j]），則i++，j++     
                i = i+1;
                j = j+1;
            }else{
                //如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0 
                i = i - (j-1);
                j = 0;
            }
        }
        //匹配成功，返回模式串p在文本串s中的位置，否則返回-1  
        if(j == pLen){
            return i-j;
        }else{
            return -1;
        }
        
    }
    

 

結束語：上面的算法分析過程中，第6步后，我們會發現S[5]肯定跟P[0]失配。為什么呢？因為在之前第4步匹配中，我們已經得知S[5] = P[1] = B，而P[0] = A，即P[1] != P[0]，故S[5]必定不等於P[0]，所以回溯過去必然會導致失配。那有沒有一種算法，讓i 不往回退，只需要移動j 即可呢？答案是肯定的。這種算法就是KMP算法，它利用之前已經部分匹配這個有效信息，保持i 不回溯，通過修改j 的位置，讓模式串盡量地移動到有效的位置。

 

整理自：http://blog.csdn.net/v_july_v/article/details/7041827