1. 程式人生 > >字串匹配——樸素演算法、KMP演算法

字串匹配——樸素演算法、KMP演算法

字串匹配(string match)是在實際工程中經常會碰到的問題,通常其輸入是原字串(String)和子串(又稱模式,Pattern)組成,輸出為子串在原字串中的首次出現的位置。通常精確的字串搜尋演算法包括樸素搜尋演算法,KMP, BM(Boyer Moore), sunday, robin-karp 以及 bitap。下面分析樸素搜尋演算法和KMP這兩種方法並給出其實現。假設原字元T串長度N,子串P長度為M。

1.NAIVE—STRING—MATCHING.

樸素演算法,該方法又稱暴力搜尋,也是最容易想到的方法。

預處理時間 O(0)

匹配時間複雜度O(N*M)

主要過程:從原字串開始搜尋,若出現不能匹配,則從原搜尋位置+1繼續。

程式碼如下:

  1. void NAIVE_STRING_MATCHING(string T,string P)

  2. {

  3. int n=T.size();

  4. int m=P.size();

  5. int i;

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

  7. {

  8. for (i=0;i<m;i++)

  9. {

  10. if (P[i]!=T[s+i])

  11. {

  12. break;

  13. }

  14. }

  15. if (i==m)

  16. {

  17. cout<<"pattern occurs with shift "<<s<<endl;

  18. }

  19. }

  20. }

2.Knuth—Morris—Pratt演算法

簡稱KMP演算法,舉例來說,有一個字串”BBC ABCDAB ABCDABCDABDE”,我想知道,裡面是否包含另一個字串”ABCDABD”?

字串匹配的KMP演算法

許多演算法可以完成這個任務,Knuth-Morris-Pratt演算法(簡稱KMP)是最常用的之一。它以三個發明者命名,起頭的那個K就是著名科學家Donald Knuth。

字串匹配的KMP演算法

這種演算法不太容易理解,網上有很多解釋,但讀起來都很費勁。直到讀到Jake Boxer的文章,我才真正理解這種演算法。下面,我用自己的語言,試圖寫一篇比較好懂的KMP演算法解釋。

1.

字串匹配的KMP演算法

首先,字串”BBC ABCDAB ABCDABCDABDE”的第一個字元與搜尋詞”ABCDABD”的第一個字元,進行比較。因為B與A不匹配,所以搜尋詞後移一位。

2.

字串匹配的KMP演算法

因為B與A不匹配,搜尋詞再往後移。

3.

字串匹配的KMP演算法

就這樣,直到字串有一個字元,與搜尋詞的第一個字元相同為止。

4.

字串匹配的KMP演算法

接著比較字串和搜尋詞的下一個字元,還是相同。

5.

字串匹配的KMP演算法

直到字串有一個字元,與搜尋詞對應的字元不相同為止。

6.

字串匹配的KMP演算法

這時,最自然的反應是,將搜尋詞整個後移一位,再從頭逐個比較。這樣做雖然可行,但是效率很差,因為你要把”搜尋位置”移到已經比較過的位置,重比一遍。

7.

字串匹配的KMP演算法

一個基本事實是,當空格與D不匹配時,你其實知道前面六個字元是”ABCDAB”。KMP演算法的想法是,設法利用這個已知資訊,不要把”搜尋位置”移回已經比較過的位置,繼續把它向後移,這樣就提高了效率。

8.

字串匹配的KMP演算法

怎麼做到這一點呢?可以針對搜尋詞,算出一張《部分匹配表》(Partial Match Table)。這張表是如何產生的,後面再介紹,這裡只要會用就可以了。

9.

字串匹配的KMP演算法

已知空格與D不匹配時,前面六個字元”ABCDAB”是匹配的。查表可知,最後一個匹配字元B對應的”部分匹配值”為2,因此按照下面的公式算出向後移動的位數:

  移動位數 = 已匹配的字元數 – 對應的部分匹配值

因為 6 – 2 等於4,所以將搜尋詞向後移動4位。

10.

字串匹配的KMP演算法

因為空格與C不匹配,搜尋詞還要繼續往後移。這時,已匹配的字元數為2(”AB”),對應的”部分匹配值”為0。所以,移動位數 = 2 – 0,結果為 2,於是將搜尋詞向後移2位。

11.

字串匹配的KMP演算法

因為空格與A不匹配,繼續後移一位。

12.

字串匹配的KMP演算法

逐位比較,直到發現C與D不匹配。於是,移動位數 = 6 – 2,繼續將搜尋詞向後移動4位。

13.

字串匹配的KMP演算法

逐位比較,直到搜尋詞的最後一位,發現完全匹配,於是搜尋完成。如果還要繼續搜尋(即找出全部匹配),移動位數 = 7 – 0,再將搜尋詞向後移動7位,這裡就不再重複了。

14.

字串匹配的KMP演算法

下面介紹《部分匹配表》是如何產生的。

首先,要了解兩個概念:”字首”和”字尾”。 “字首”指除了最後一個字元以外,一個字串的全部頭部組合;”字尾”指除了第一個字元以外,一個字串的全部尾部組合。

15.

字串匹配的KMP演算法

“部分匹配值”就是”字首”和”字尾”的最長的共有元素的長度。以”ABCDABD”為例,

  - ”A”的字首和字尾都為空集,共有元素的長度為0;

- ”AB”的字首為[A],字尾為[B],共有元素的長度為0;

- ”ABC”的字首為[A, AB],字尾為[BC, C],共有元素的長度0;

- ”ABCD”的字首為[A, AB, ABC],字尾為[BCD, CD, D],共有元素的長度為0;

- ”ABCDA”的字首為[A, AB, ABC, ABCD],字尾為[BCDA, CDA, DA, A],共有元素為”A”,長度為1;

- ”ABCDAB”的字首為[A, AB, ABC, ABCD, ABCDA],字尾為[BCDAB, CDAB, DAB, AB, B],共有元素為”AB”,長度為2;

- ”ABCDABD”的字首為[A, AB, ABC, ABCD, ABCDA, ABCDAB],字尾為[BCDABD, CDABD, DABD, ABD, BD, D],共有元素的長度為0。

16.

字串匹配的KMP演算法

“部分匹配”的實質是,有時候,字串頭部和尾部會有重複。比如,”ABCDAB”之中有兩個”AB”,那麼它的”部分匹配值”就是2(”AB”的長度)。搜尋詞移動的時候,第一個”AB”向後移動4位(字串長度-部分匹配值),就可以來到第二個”AB”的位置。

KMP演算法主要分為兩個部分:

一、求子串P部分匹配值陣列;

上面已經分析過,具體程式碼如下,其中pi指的是部分匹配陣列;

  1. void COMPUTE_PREIFX_FUNCTION(string P,vector<int>& pi)

  2. {

  3. int m=P.size();

  4. pi[0]=0;

  5. pi[1]=0;

  6. int k=0;

  7. for (int q=2;q<m;q++)

  8. {

  9. while (k>0&&P[k+1]!=P[q])

  10. {

  11. k=pi[k];

  12. }

  13. if (P[k+1]==P[q])

  14. {

  15. k=k+1;

  16. }

  17. pi[q]=k;

  18. }

  19. }

二、求字元匹配位置;

按上面分析給出如下程式碼,為了方便,我們給T,P前面分別增加一個字元“%”和“*”,這樣字串中的第i個字元在程式碼中的下標也為i,這樣可以防止陣列溢位,易於理解。

  1. void KMP_MATCHER(string &T,string &P)

  2. {

  3. T="%"+T;

  4. P="*"+P;

  5. int m=P.size();

  6. vector<int> pi(m);

  7. int n=T.size();

  8. COMPUTE_PREIFX_FUNCTION(P,pi);

  9. int q=0;

  10. int i;

  11. for (i=1;i<n;i++)

  12. {

  13. while (q>0&&P[q+1]!=T[i])

  14. {

  15. q=pi[q];

  16. }

  17. if (P[q+1]==T[i])

  18. {

  19. q=q+1;

  20. }

  21. if (q==m-1)

  22. {

  23. cout<<"pattern occurs with shift "<<i-q<<endl;

  24. q=pi[q];

  25. }

  26. }

  27. }

完整程式碼如下:

標頭檔案:

  1. #include <iostream>

  2. #include <string>

  3. #include <vector>

  4. using namespace std;

  5. void COMPUTE_PREIFX_FUNCTION(string P,vector<int>& pi);

  6. void KMP_MATCHER(string &T,string &P);

  7. void NAIVE_STRING_MATCHING(string T,string P);

main函式:

  1. #include"head.h"

  2. void main()

  3. {

  4. string T="BBC ABCDAB ABCDABCDABDEFABCDABDff";

  5. string P="ABCDABD";

  6. cout<<"NAIVE:"<<endl;

  7. NAIVE_STRING_MATCHING(T,P);

  8. cout<<"KMP:"<<endl;

  9. KMP_MATCHER(T,P);

  10. }

  11. void COMPUTE_PREIFX_FUNCTION(string P,vector<int>& pi)

  12. {

  13. int m=P.size();

  14. pi[0]=0;

  15. pi[1]=0;

  16. int k=0;

  17. for (int q=2;q<m;q++)

  18. {

  19. while (k>0&&P[k+1]!=P[q])

  20. {

  21. k=pi[k];

  22. }

  23. if (P[k+1]==P[q])

  24. {

  25. k=k+1;

  26. }

  27. pi[q]=k;

  28. }

  29. }

  30. void KMP_MATCHER(string &T,string &P)

  31. {

  32. T="%"+T;

  33. P="*"+P;

  34. int m=P.size();

  35. vector<int> pi(m);

  36. int n=T.size();

  37. COMPUTE_PREIFX_FUNCTION(P,pi);

  38. int q=0;

  39. int i;

  40. for (i=1;i<n;i++)

  41. {

  42. while (q>0&&P[q+1]!=T[i])

  43. {

  44. q=pi[q];

  45. }

  46. if (P[q+1]==T[i])

  47. {

  48. q=q+1;

  49. }

  50. if (q==m-1)

  51. {

  52. cout<<"pattern occurs with shift "<<i-q<<endl;

  53. q=pi[q];

  54. }

  55. }

  56. }

  57. void NAIVE_STRING_MATCHING(string T,string P)

  58. {

  59. int n=T.size();

  60. int m=P.size();

  61. int i;

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

  63. {

  64. for (i=0;i<m;i++)

  65. {

  66. if (P[i]!=T[s+i])

  67. {

  68. break;

  69. }

  70. }

  71. if (i==m)

  72. {

  73. cout<<"pattern occurs with shift "<<s<<endl;

  74. }

  75. }

  76. }


執行結果如下:


ABCDABD繼BBC ABCDAB ABCDABCDABDEFABCDABDff第15個元素出現了一次,繼第24個元素之後出現了一次。

本文程式碼參照演算法導論第32章虛擬碼編寫;

部分內容參考:http://blog.jobbole.com/39066/