既然談論到字串相關演算法，那麼字串匹配是根本繞不過去的坎。在面試中，面試官可能會要你寫或談談字串的匹配演算法，也就是給定兩個字串，s 和 t, s是要查詢的字串，t是被查詢的文字，要求你給出一個演算法，找到s在t中第一次出現的位置，假定s為 acd, t為acfgacdem, 那麼s在t中第一次出現的位置就是4.

字串匹配演算法有多種，每種都有它的優點和缺陷，沒有哪一種演算法是完美無缺的。如果在面試中被問到這個問題，最好的處理方法是先詳細的給出一個具體演算法，然後再去大概的探討其他方法的優劣，做到這一點，通過的勝算就相當大了，由此，我們需要了解主流的字串匹配演算法。我們先總結一下常用匹配演算法的特點：

上標中，m是匹配字串s的長度，n是被匹配文字t的長度，符號∑, 表示的是文字的字符集，如果文字是二進位制檔案，那麼文字t和s只有兩個字元即0，1組成，那麼 ∑={0,1}. 如果t和s表示的是基因序列那麼 ∑ = {A, C, G, T}，如果t和s是由26個英文字元組成那麼，那麼 ∑

同時符號 | | 表示文字長度，例如s=”abcd”, 那麼|s| 就等於4.所以，如果 ∑ = {a,b … z}， 那麼|∑| 就等於26.

大家如果對字串匹配演算法比較瞭解的話，一定對KMP演算法早有耳聞，雖然它在理論上的時間複雜度是最好的，但這並不意味著，它就是最好的演算法，因為它實現起來比較複雜，因此在大多數情況下，其他演算法往往優於KMP,並且在很多運用情形下，其他演算法的執行效率未必比KMP差多少。

我們需要定義幾個概念：
1. 字首，如果字串w是x的字首，那意味著x可以分解成兩個字串的組合, x = wy, 例如 w=ab, x =abcd, 於是x可以分解成w=ab , y = cd兩個字串的組合，如果w是x的字首，那麼|x| <= |w|
2. 字尾，如果字串w是x的字尾，那就是x可以分解成兩個字串的組合，x=yw, 而且有 |w| <= |x|

還有一個簡單的定理：
有三個字串x, y ,z. 如果x, y 都是z 的字首，那麼當|x| < |y| 時，x是y的字首，如果|x|>|y| ，那麼y是x的字首。如果x,y是z的字尾，那麼也同理可證。

如果字串P含有m個字元，記為P[1…m], 那麼P的長度為k的字首P[1…k], 記做Pk. 於是 P0 = ϵ, Pm= P = P[1…m].同理，對於被匹配的文字T，長度為n, T的k字元長度的字首也可以用Tk 來表示，於是，如果要查詢P是否是T的子串，那麼，我們需要找到一個值s, 0<=s<=n - m. 使得 P 是 Ts+m 的字尾。

上面的定義有點燒腦，大家可以拿筆畫畫，以便於理解。

暴力列舉法

列舉法的流程是，在範圍[0, n-m] 中，查詢是否存在一個值s, 0<=s<=n-m, 使得 P[1…m] = T[s+1, … , s+m].java程式碼如下：

int match(String p, String t) {
    for (int s = 0; s < t.length() - p.length(); s++) {
        for (int i = 0; i < p.length(); i++) {
              if (p.charAt(i) == t.charAt(s+i) 
              && i == p.length() - 1) {
                   return s;
              } else if(p.charAt(i) != t.charAt(s+i)){
                   break;
             }
         }
    }

    return -1;
}

如果t = “acaabc”, p = “aab”, 那麼上面演算法執行流程如下：

 a  c  a  a  b  c
 a  a  b

 a  c  a  a  b  c
    a  a  b

 a  c  a  a  b  c
       a  a  b  （成功匹配）

程式碼中，最壞情況下，外層的for迴圈次數為m - n + 1 次，內層for迴圈執行 m 次，所以列舉法的演算法複雜度是O((m-n+1) m)。列舉法的效率很低，因為在匹配過程中，它完全忽略了P的自身組成特點。後面的演算法之所以效率得以提高，很大程度上，就是重複考慮了P自身的字元組合特點。

Rabin-Karp演算法

該演算法在實際運用中，表現不錯，RK演算法需要O(m) 時間做預處理,在最壞情況下，該演算法的複雜度與列舉法一樣都是，O((n - m + 1) m).但在實際運用中，最壞情況極少出現。

假設字符集全是由0到9的數字組成，∑ = {0,1,2…9}.一個長度為k的字串，例如k=3的字串”123”, “404”, 等，都可以看成是含有k個數字的整形數，例如前頭兩個字串可看做兩個整形數:123, 404.由此，對於一個長度為m的字串P[1…m],用p表示該字串對應的含有m個數字的整形數，我們用ts 來表示T[s+1, … , s+m] 這m個字元對應的整形數值，不難發現，當兩個數值相等時，這兩個數值對應的字串就相等，也就是當且僅當p = ts 有 P[1…m] = T[s+1,…,s+m].

把數字從字串轉換為對應的整形數值，我們前頭講過，時間複雜度為O(m).通過下面的公式進行轉換即可：

p = P[m] + 10(P[m-1] + 10(P[m-2]+ …. + ( 10(P[2]) + P[1])…).

RK演算法有一個巧妙之處在於如何通過ts 去計算ts+1.假設m=5,
T=”314152”, 那麼可以算出t0 = 31415. t1的數值可以通過一步運算得出： t1 =10* (t0 - 105−1T[1]) + T[6] = 10(31415 - 105−1 * 3) + 2 = 14152. （請大家忽略公式中的那根豎線 |, 這根豎線應該是部落格編輯器的bug).

由此可以得到通用公式： ts+1 =10* (ts - 10m−1 * T[s+1]) + T[s + m + 1], 0 <= s <= n - m

由於一次計算的複雜度是O(1), 計算t0, t1, … , tn−m ,所需要的時間複雜度是O(n - m + 1). 從而，要在 T[1…n] 中查詢P[1..m], 所需要的時間複雜度就是O(n - m + 1).

雖說我們當前處理的是數字字串，如果處理的文字是小寫字元{a,b…z}, 其實本質是一樣的，只要把十進位制的數值{0,1..9}換成26進位制的數字{0, 1, 2, ….25}，那面公式中的10換成26即可。

上面演算法，含有一個問題，那就是當m過大，於是對應的數值p或ts過大，會導致溢位，同時就如以前在二進位制演算法章節中談到過，當兩個過大的數值比較大小時，CPU需要多個運算週期來進行，這樣兩數比較，我們就不能假定他們可以在單位時間內完成了。處理這種情況的處理辦法就是求餘。

ts+1 = (d*(ts - T[s+1] * h ) + T[s+m+1]) mod q

其中， h ≡ dm−1 (mod q), h的值可以預先通過O(m)次計算得到， q 是一個素數。

然而引入求餘又會引發新的問題，ts ≡ p (mod q), 並不意味著就一定有 ts = p. 但相反，ts ! ≡ p (mod q),那麼一定有 ts ！= p. 由此，一旦ts ≡ p (mod q) 滿足，我們還需要把T[s+1, … , s+m] 和 P[1…m] 這兩個字串逐個字元比較，每個字元都一樣，才能最終斷定T[s+1,…,s+m] = P[1…m].

這就解釋了為何RK演算法最壞情況下，複雜度會是O(m (n - m + 1)). 因為有可能出現這樣情況，ts ≡ p (mod q)， 但T[s+1, … s+m] 與 P[1…m]不匹配。

舉個具體例子看看：
T = “2359023141526739921”, q = 13, d = 10, P=31415,m=5,不難發現s = 6 的時候，滿足T[s+1, … s+m+1] = P[1..5], 但是當s=12時，T[s+1, …, s+m+1] = “67399”, 然而7 ≡ 67399 ≡ 31415 (mod 13). 但是字串”67399” 與字串 “31415”並不匹配。

下面我們看看java實現程式碼：

public class RabinKarp {
    private String  T ;
    private String  P ;
    private int d;
    private int q;
    private int n = 0;
    private int m = 0;
    private int h = 1;
    //假設要匹配的文字字符集是小寫字母{a...z}

    public RabinKarp(String t, String p, int d, int q) {
        T = t;
        P = p;
        this.d = d;
        this.q = q;
        n = T.length();
        m = P.length();

        for (int i = 0; i < m-1 ; i++) {
            h *= (d );
            h = (h % q);
        }
    }

   public int match() {
       int p = 0;
       int t = 0;

       //預處理，計算p 和 t0.
       for (int i = 0; i < m; i++) {
           p = (d*p + (P.charAt(i) - 'a')) % q;
           t = (d*t + (T.charAt(i) - 'a')) % q;
       }

       for (int s = 0; s <= n - m; s++) {

           if (p == t) {
               //如果求餘後相等，那麼就逐個字元比較
               for (int i = 0; i < m; i++) {
                   if (i == m-1 && P.charAt(i) == T.charAt(s+i)) {
                       return s;
                   } else if (P.charAt(i) != T.charAt(s+i)){
                       break;
                   }
               }
           }

           if (s <= n - m) {

               t = (d*(t-(T.charAt(s) - 'a')*h) + T.charAt(s+m) - 'a') % q;

               if (t < 0) {
                   t += q;
               }
           }
       }

       return -1;
   }
}

public class ArrayAndString {

    public static void main(String[] args) {
        String T = "abcabaabcabac";
        String P = "abaa";
        RabinKarp rk = new RabinKarp(T, P, 26, 29);
        int s = rk.match();

        System.out.println("Valid shift is: "+ s);
    }
}

在match 呼叫中，一開始就先計算p 和 t0, 在上面的for迴圈中，不斷的在ts 基礎上計算ts+1, 在程式碼中，需要注意的是，等式中有：t-(T.charAt(s) - ‘a’)*h， 由於每次計算完ts後，我們都會將結果與q求餘，這就使得ts的值不會大於q, 這樣在下一次迴圈計算ts+1時，t-(T.charAt(s) - ‘a’)*h 這一部分的運算結果會有負值出現，在求餘運算下，負值不會影響最終結果，但對計算的值需要做一些修正，例如當q = 29 時， -1 ≡ 28 (mod 29), 所以如果等式計算出負值時，我們需要修正一下，將負值加上q,得到等價的正值，例如-1等價的正值是28，所以-1 + 29就等於28.

上面的程式碼執行後，輸出結果s 等於3, 也就是T[3,..6] = P[1..4].執行結果顯示程式碼實現，基本正確。

後面的兩種演算法，將在後續章節中，我們再深入研究。