字符串匹配算法(KMP、BM和Sunday)，及Python实现



分类： Python/Ruby

这篇博客主要对三种字符串匹配算法(KMP、BM、Sunday)进行总结。这三种字符串匹配算法之间的主要区别在于：如果在匹配过程中遇到一个不匹配位，该用何种策略进行移位。例如，存在两个字符串，如下：

 

字符串：      ABCADAB ABCDABCDABD

搜索字符串：ABCDA

 

下面给出三种算法的例子

KMP：在此算法中当从前往后搜索时遇到第一个不匹配：A->D时，它将从搜索字符串入手决定移动多少位。在KMP算法的初始阶段会生成一张表，例如，上面搜索字符串生成的表为：pi[0,...,4] = {0,0,0,0,1}。这张表决定上面提到的移位。此时的移位为：3-pi[2]（因为已经匹配了三个字符）。KMP算法的关键就是：匹配字符的初始生成表，而且是从前往后进行搜索。

BM：在此算法中，字符串搜索不是从头开始的，而是从末尾开始的，例如上面的例子中，首先比较的是D和A，因为不相同，则在搜索字符中从后往前进行匹配查找，找到最右边的匹配字符后进行移位，如果找不到的话移位长度与匹配字符一样长，如下：

字符串：      ABCADAB ABCDABCDABD

搜索字符串：   ABCDA(移两位)

此时继续进行比较，不过此时的比较要考虑两方面以上上面提到的过程，还有一种情况就是已匹配的字符串中(DA)，包含了搜索字符串的前缀(A)，我们知道此时移动1~3位是没有意义的。所以BM算法的关键就是找到两种移位中的最大移位，进行以为。

Sunday：上面的两种字符串匹配算法都涉及到了对搜索字符的预处理，但Sunday算法预期完全不同。同样是上面的例子当搜到不匹配的字符串时，Sunday算法采用了一种完全不同的以为确定法。它会先找到字符串的第K+1个字符，K是搜索字符的长度。如果搜索字符串中不包含字符串中第K+1个字符，则直接移动K+1位。否则，按着BM算法移动搜索串中最右端的该字符到末尾的距离+1位。

下面给出具体的代码：

点击(此处)折叠或打开

1. class StringPatternt(object):
   
2.     def __init__(self,chr,p):
   
3.         self.chr = chr;
   
4.         self.p = p;
   
5.         self.p_len = len(p);
   
6.         self.pi = [0 for i in range(self.p_len)];
   
7.     def set_pattern(self,p):
   
8.         self.p = p;
   
9.         self.p_len = len(p);
   
10.     def set_chr(self,chr):
    
11.         self.chr = chr;
    
12.         
    
13.     '''KMP'''
    
14.     def __kmp_partial_match_table__(self):
    
15.         k=0;q = 1;
    
16.         #self.pi[0] = 0;
    
17.         while q < self.p_len:
    
18.             while (k > 0) and (self.p[k] != self.p[q]):
    
19.                 k = self.pi[k-1];
    
20.             if self.p[k] == self.p[q]:
    
21.                 k = k+1;
    
22.             self.pi[q] = k;
    
23.             q = q+1;
    
24.         return 0;
    
25.     
    
26.     def string_pattern_kmp(self):
    
27.         self.__kmp_partial_match_table__();
    
28.         print(self.pi);
    
29.         list_size = len(self.chr);
    
30.         pi_len = len(self.pi);
    
31.         k=0;
    
32.         for q in range(list_size):
    
33.             while (k > 0) and (self.p[k] != self.chr[q]):
    
34.                 k = self.pi[k-1];
    
35.             if self.p[k] == self.chr[q]:
    
36.                 k = k+1;
    
37.             if k == pi_len:
    
38.                 return q-pi_len+1;
    
39.             #q = q+1;
    
40.         return 0;
    
41.     
    
42.     '''BM'''
    
43.     def __calc_match__(self,num):
    
44.         k=num;j=0;
    
45.         while k>=0:
    
46.             if self.p[-k] == self.p[j]:
    
47.                 k = k-1; j=j+1;
    
48.                 if k<=0:
    
49.                     self.pi[num-1] = num;
    
50.                     return 0;
    
51.             else:
    
52.                 if num == 1:
    
53.                     return 0;
    
54.                 self.pi[num-1] = self.pi[num-2];
    
55.                 return 0;
    
56.         
    
57.     def __init_good_table__(self):
    
58.         i=1;
    
59.         while i <= self.p_len:
    
60.             self.__calc_match__(i);
    
61.             i=i+1;
    
62.         print (self.pi);
    
63.         return 0;
    
64.     
    
65.     def __check_bad_table__(self,tmp_chr):
    
66.         i=1;
    
67.         while self.p_len-i >= 0:
    
68.             if self.p[-i] == tmp_chr:
    
69.                 return i;
    
70.             else:
    
71.                 i = i+1;
    
72.         return self.p_len+1;
    
73.     
    
74.     def __check_good_table__(self,num):
    
75.         if not num:
    
76.             return self.p_len;
    
77.         else:
    
78.             return self.pi[num];
    
79.     
    
80.     def string_pettern_bm(self):
    
81.         self.__init_good_table__();
    
82.         tmp_len = self.p_len;
    
83.         i = 1;
    
84.         while tmp_len <= len(self.chr):
    
85.             if self.p[-i]==self.chr[tmp_len-i]:
    
86.                 i = i+1;
    
87.                 if i > self.p_len:
    
88.                     return tmp_len-self.p_len;
    
89.             else:
    
90.                 tmp_bad = self.__check_bad_table__(self.chr[tmp_len-i])-i;
    
91.                 tmp_good= self.p_len-self.__check_good_table__(i-1);
    
92.                 tmp_len = tmp_len+ max(tmp_bad,tmp_good);
    
93.                 print(tmp_bad,tmp_good,tmp_len);
    
94.                 i=1;
    
95.         return 0;
    
96.     
    
97.     '''sunday'''
    
98.     def __check_bad_shift__(self,p):
    
99.         i=0;
    
100.         while i<self.p_len:
     
101.             if self.p[i] == p:
     
102.                 return i;
     
103.             else:
     
104.                 i = i+1;
     
105.         return -1;
     
106.     
     
107.     def string_pattern(self):
     
108.         #self.__init_good_table__();
     
109.         tmp_len = 0;
     
110.         tmp_hop = self.p_len;
     
111.         i=0;
     
112.         while tmp_hop <= len(self.chr):
     
113.             if self.p[i] == self.chr[tmp_len+i]:
     
114.                 i = i+1;
     
115.                 if i == self.p_len:
     
116.                     return tmp_len;
     
117.             else:
     
118.                 tmp_len = tmp_len+self.p_len-self.__check_bad_shift__(self.chr[tmp_hop]);
     
119.                 tmp_hop = tmp_len+self.p_len;
     
120.                 i=0;
     
121.         return 0;

本文出自： http://blog.chinaunix.net/uid-28311809-id-4243589.html