单模式匹配算法-KMP算法

    模式匹配，一般分为单模式匹配和多模式匹配。当然，通常都是指在字符序列中的匹配问题。   

    单模式匹配，对一个较长的字符序列，调用一次算法只匹配一个模式串。

    本文展示的是单模式匹配中的经典算法--KMP算法。

    KMP算法是一种高效的模式匹配算法，复杂度可以达到O(m+n)，而普通模式匹配算法的复杂度为O(m*n)。

    在普通匹配算法中子串与模式串都需要回溯，但这些回溯不是必要的。因为当某一位发生失配时，可以根据已匹配的结果进行判断。这个时候，会产生一个问题：当模式串中的第k位与主串的第i位比较时发生不匹配时，需要将模式串向右滑动到哪里继续与主串的第i位进行比较？如果解决了这个问题，就避免了不必要的主串回溯，减少了模式串回溯的位数，从而使算法复杂度提升到O(m+n)。

    KMP算法通过分析模式串，构建next数组，来辅助定位每次模式串向右滑动的位置。具体怎样理解，网上解释的文章非常多，大家可以百度一下，你就知道了。

    下面展示一下具体实现的Java代码，供大家讨论。

 

package houlei.support.matcher;

/**
 * 单模式匹配算法（KMP算法）的匹配器。匹配字符串。
 * <p>
 * 创建时间： 2012-7-22 上午00:52:49
 * </p>
 * @author 侯磊
 * @since 1.0
 * @version 1.0
 */
public class KMPStringMatcher {

	/**
	 * 当模式串匹配成功时，回调该接口方法。
	 */
	public interface StringHandler{
		void onMatch(int index,String str,String pattern);
	}
	
	static int[] getNext(char[] pattern){
		int next [] = new int[pattern.length];
		next[0] = -1;
		int j=0,k=-1;
		while(j<pattern.length-1){
			if(k==-1 || pattern[j]==pattern[k]){
				j++;k++;
				next[j] = k;
			}else{
				k = next[k];
			}
		}
		return next;
	}
	
	/**
	 * 字符数组的匹配。
	 * @param data 待匹配的数据
	 * @param pattern 模式串的字符数组
	 * @return 失配返回<code>-1</code>，首次匹配成功时，返回模式串的位置。
	 */
	public static int match(char[] data,char[] pattern){
		int[]next = getNext(pattern);
		for(int i=0,j=0;i<data.length;){
			if(j==-1 || data[i]==pattern[j]){
				i++;j++;
			}else{
				j = next[j];
			}
			if(j==pattern.length){
				return i-pattern.length;
			}
		}
		return -1;
	}
	/**
	 * 字符串的匹配。
	 * @param data 待匹配的数据
	 * @param pattern 模式串
	 * @return 失配返回<code>-1</code>，首次匹配成功时，返回模式串的位置。
	 */
	public static int match(String data,String pattern){
		return match(data.toCharArray(), pattern.toCharArray());
	}
	
	/**
	 * 字符串的匹配。当模式串匹配成功时，回调{@link StringHandler#onMatch(int, String, String)}接口方法。
	 * @param data 待匹配的数据
	 * @param pattern 模式串
	 * @param handler 处理器对象
	 */
	public static void match(String data, String pattern, StringHandler handler) {
		char[] string = data.toCharArray();
		char[] pChars = pattern.toCharArray();
		int[]next = getNext(pChars);
		for(int i=0,j=0;i<string.length;){
			if(j==-1 || string[i]==pChars[j]){
				i++;j++;
			}else{
				j = next[j];
			}
			if(j==pChars.length){
				handler.onMatch(i-pChars.length, data, pattern);
				j = next[--j];--i;
			}
		}
	}
	
}

    当然了，对于一次匹配一个模式串，并且，匹配过程中，字符序列不必回退，模式串有限回退，上述算法还是很可行的。

    用例的代码，我没有写上来，因为，根据意思，应该很好理解我的用意。对于一个字符串中，如果只需要首次匹配成功的位置，那就不需要Handler了。但是，如果一个字符序列存在多个模式串在里面，那你就要使用Handler了，每次匹配成功的时候，算法都会回调里面的onMatch方法。你只要实现这个StringHandler接口就可以了。

 

    之后是字节序列的模式匹配，虽然用的不多，但是，算法还是一样滴。

package houlei.support.matcher;

public class KMPBytesMatcher {

	public interface BytesHandler{
		void onMatch(int index,byte[]data,byte[]pattern);
	}
	
	static int[] getNext(byte[] pattern){
		int next [] = new int[pattern.length];
		next[0] = -1;
		int j=0,k=-1;
		while(j<pattern.length-1){
			if(k==-1 || pattern[j]==pattern[k]){
				j++;k++;
				next[j] = k;
			}else{
				k = next[k];
			}
		}
		return next;
	}
	
	public static int match(byte[] data,byte[] pattern){
		int[]next = getNext(pattern);
		for(int i=0,j=0;i<data.length;){
			if(j==-1 || data[i]==pattern[j]){
				i++;j++;
			}else{
				j = next[j];
			}
			if(j==pattern.length){
				return i-pattern.length;
			}
		}
		return -1;
	}
	
	public static void match(byte[] data,byte[] pattern, BytesHandler handler){
		int[]next = getNext(pattern);
		for(int i=0,j=0;i<data.length;){
			if(j==-1 || data[i]==pattern[j]){
				i++;j++;
			}else{
				j = next[j];
			}
			if(j==pattern.length){
				handler.onMatch(i-pattern.length, data, pattern);
				j = next[--j];--i;
			}
		}
	}
	
}

    是不是有些启发？可以再写写Reader的Matcher，或者InputStream的Matcher ？有时间的朋友可以实现一下，反正算法都是一样的嘛。