Java实现KMP算法(转)

1. 转自：http://blog.csdn.net/tkd03072010/article/details/6824326
2. package arithmetic;  
3.   
4. /** 
5.  * Java实现KMP算法 
6.  *  
7.  * 思想：每当一趟匹配过程中出现字符比较不等，不需要回溯i指针，  
8.  * 而是利用已经得到的“部分匹配”的结果将模式向右“滑动”尽可能远  
9.  * 的一段距离后，继续进行比较。 
10.  *  
11.  * 时间复杂度O(n+m) 
12.  *  
13.  * @author xqh 
14.  *  
15.  */  
16. public class KMPTest {  
17.     public static void main(String[] args) {  
18.         String s = "abbabbbbcab"; // 主串  
19.         String t = "bbcab"; // 模式串  
20.         char[] ss = s.toCharArray();  
21.         char[] tt = t.toCharArray();  
22.         System.out.println(KMP_Index(ss, tt)); // KMP匹配字符串  
23.     }  
24.   
25.     /** 
26.      * 获得字符串的next函数值 
27.      *  
28.      * @param t 
29.      *            字符串 
30.      * @return next函数值 
31.      */  
32.     public static int[] next(char[] t) {  
33.         int[] next = new int[t.length];  
34.         next[0] = -1;  
35.         int i = 0;  
36.         int j = -1;  
37.         while (i < t.length - 1) {  
38.             if (j == -1 || t[i] == t[j]) {  
39.                 i++;  
40.                 j++;  
41.                 if (t[i] != t[j]) {  
42.                     next[i] = j;  
43.                 } else {  
44.                     next[i] = next[j];  
45.                 }  
46.             } else {  
47.                 j = next[j];  
48.             }  
49.         }  
50.         return next;  
51.     }  
52.   
53.     /** 
54.      * KMP匹配字符串 
55.      *  
56.      * @param s 
57.      *            主串 
58.      * @param t 
59.      *            模式串 
60.      * @return 若匹配成功，返回下标，否则返回-1 
61.      */  
62.     public static int KMP_Index(char[] s, char[] t) {  
63.         int[] next = next(t);  
64.         int i = 0;  
65.         int j = 0;  
66.         while (i <= s.length - 1 && j <= t.length - 1) {  
67.             if (j == -1 || s[i] == t[j]) {  
68.                 i++;  
69.                 j++;  
70.             } else {  
71.                 j = next[j];  
72.             }  
73.         }  
74.         if (j < t.length) {  
75.             return -1;  
76.         } else  
77.             return i - t.length; // 返回模式串在主串中的头下标  
78.     }  
79. }  

以下为原创：

关于KMP的一些资料,网上说的比较清楚的有：

http://www.matrix67.com/blog/archives/115

http://billhoo.blog.51cto.com/2337751/411486

最后我要补充一点：

不是说什么情况都是KMP算法比BF算法好，像Java里面String的indexof就用的是BF算法。

这怎么说？KMP虽然消除了指针i的回溯，但是引入了预处理的开销。当如果需要匹配汉字时，KMP往往比BF效率低，因为汉字很多，所以很少有匹配了几个词而又不匹配的情况出现，于是next数组里面大部分都是0，很少有-1，因而，KMP效率就比BF差。

虽然KMP的复杂度是o(m+n),而BF的复杂度是o(mn)，但是复杂度跟实际开销是不同的，两者不能混淆。复杂度反应的是一种变化趋势！

说的不是很清楚，但也就说到这里吧。