数据结构——串的模式匹配算法

2、串的模式匹配算法

       串的查找操作也称作串的模式匹配操作，模式匹配操作的具体含义是：在主串（也称作目标串）中，从位置start开始查找是否存在子串（也称作模式串），如在主串中查找到一个与模式串相同的子串，则称查找成功；如在主串中为查找到一个与模式串相同的子串，则称查找失败。当模式匹配成功时函数返回模式串的第一个字符在主串中的位置，当模式匹配失败时返回-1。

2、1 Brute-Force算法

       Brute-Force算法实现模式匹配的思想是：设主串为s=" s ₀ s ₁ …s _n-1 "，模式串为t=" t ₀ t ₁ …t _n-1 "。

（1）从主串s的第一个字符开始和模式串t的第一个字符比较，若相等则继续比较后续字符。

（2）若主串s的第一个字符和模式串t的第一个字符比较不相等，则从主串s的第二个字符开始重新与模式串t的第一个字符串比较，若相等则继续比较后续字符。

（3）如此不断继续。若存在模式串t中的每个字符依次和主串s中的一个连续字符序列相等，则模式匹配成功，函数返回模式串t的第一个字符在主串s中的下标；若比较完主串s的所有字符序列，不存在一个和模式串t相等的子串，则模式匹配失败，函数返回-1。

public class BruceForce {
	public static int bruceForce(String str , String subStr) {
		int result = 0;
		int len = str.length();
		int lenSub = subStr.length();
		if (lenSub > len) {
			result = -1;
		}
		int i = 0 , j = 0;
		while (i < len && j < lenSub) {
			if (str.charAt(i) == subStr.charAt(j)) {
				i ++;
				j ++;
			}
			else {
				i = i - j + 1;
				j = 0;
			}
		}
		if (j == lenSub) {
			result = i - lenSub + 1;
		}
		return result;
	}
	
	public static void main(String[] args) {
		String str = "cddcdc";
		String subStr = "cdc";
		int result = bruceForce(str, subStr);
		if (result > 0) {
			System.out.println("pos = " + result);
		}
		else if (result == 0) {
			System.out.println("未找到!");
		}
		else if (result == -1) {
			System.out.println("子串比主串长");
		}
	}
}

输出结果为：

pos = 4

       这个算法简单并易于理解，但是有些情况下时间效率并不高。主要原因是：在主串和子串已有相当多个字符比较相等的情况下，只要有一个字符比较不相等，便需要把主串的比较位置（即函数中变量i的值）回退。设主串的长度为n，子串的长度为m，则Brute-Force算法在最好情况下的时间复杂度为O(m)，在最坏的情况下的时间复杂度为O(n*m)。

2、2 KMP算法

1、Bruce-Force算法的缺点以及解决方法分析

        KMP算法是Brute-Force算法基础上的改进算法。KMP算法的特点主要是，消除了Brute-Force算法的主串比较位置在相当多字符比较相等后，只要有一个字符比较不相等，主串位置便需要回退的特点。

       分析Brute-Force算法的匹配过程可以发现，算法中的主串比较位置的回退并非一定比较。这可分为以下两种情况。

（1）第一种情况如上节的图中所示。主串s="cddcdc"、模式串t="cdc"的模式匹配过程为：当s₀₌ t₀，s₁₌ t₁，s₁≠t₁时，算法中下一次的比较位置为i=1，j=0，接下来比较s₁和t₀。但是因为t₀≠t₁，而s₁=t₁，所以一定有s₁≠t₀。所以此时比较s₁和t₀无意义，实际上随后可直接比较s₂和t₀。

（2）第二种情况，主串s="abacabab"、模式串t="abab"的第一次匹配如下图所示。此时有 s₀₌ t₀='a'，s₁₌ t₁='b'，s₂₌ t₂='a'，s₃≠t₃。因此有t₀≠t₁，s₁₌ t₁，所以必有s₁≠t₀。又因有t₀₌ t₂，s₂₌ t₂，所以必有s₂=t₀。因此下面可以直接比较s₃和t₁。

       总结以上两种情况可以发现，一旦s_i和t_j比较不相等时，主串s的比较位置不必回退，主串的s_i可直接和模式串的t k (0≤k

       现在讨论一般情况。设s=" s ₀ s ₁ …s _n-1 ",t="t ₀ t ₁ …t _m-1 ",当模式匹配比较到s _i ≠t _j (0≤i _i-j s _i-j+1 …s _i-1 "="t ₀ t ₁ …t _j-1 "。①若此时模式串"t ₀ t ₁ …t _j-1 "中不存在任何"t ₀ t ₁ …t _k-1 "="t _j-k t _j-k+1 …t _j-1 "(0 " t ₀ t ₁ …t _j-1 "中不存在任何以为t ₀ 首字符的字符串与主串 " s _i-j s _i-j+1 …s _i-1 "中分别以 s _i-j 、 s _i-j+1 、...、 s _i-1 为首字符的字符串匹配，下一次可直接比较 s _i 和 t ₀ 。②此时若模式中存在如 " t ₀ t ₁ …t _k-1 "=" t _j-k t _j-k+1 …t _j-1 "形式的真子串，则说明模式中的子串已经和主串匹配，下次可以直接比较 s _i 和 t k 。

2、KMP算法的改进

分析式"t₀t₁…t_k-1"="t_j-kt_j-k+1…t_j-1"(0s="s₀s₁…s_n-1"，子串,t="t₀t₁…t_m-1"，可以首先计算出模式串t中每个字符的最大榛子穿的字符个数k。当模式匹配到s_i≠t_j(0≤i

3、模式串中最大真子串的求法

       模式串中每个字符的最大真子串构成一个数组，定义为模式串的next[j]函数。模式串的next[j]函数定义如下：

       next[j]函数表示的是模式串t中是否存在最大真子串，以及最大真子串的字符个数k。这里之所以称为最大真子串，是因为：①求出的是所有子串中最大子串；②不允许k等于j。

             next[j]定义中的第一种情况，是在模式串"t₀t₁…t_j-1"中存在这样两个长度均小于j的字符串，其中一个字符串以t₀为首字符，另一个字符串以t_j-1为末字符，满足 "t₀t₁…t_k-1"="t_j-kt_j-k+1…t_j-1"， 且这样的相等子串是所有这种相等子串中长度最大的。

        next[j]定义中的第二种情况，是在模式串 " t ₀ t ₁ …t _j-1 " 中不存在任何满足"t₀t₁…t_k-1"="t_j-kt_j-k+1…t_j-1"条件的真子串。

        next[j]定义中的第三种情况，是当j=0是给出的特殊取值。当j=0是，令netx[j]函数取值为-1。在函数这几种，当netx[j]=-1时，令主串的下标和模式串的下标同时增1，即随后用子串的第一个字符和当前字符的下一个字符进行比较。

4、KMP函数设计

       KMP函数中，当模式串t中的t_j与主串s的s_i(i≥j)比较不相等时，若模式串t中不存在如上所说的真子串，有next[j]=0，则下一次比较s_i和t₀，这是第一种情况；若模式串t存在真子串"t₀t₁…t_k-1"="t_j-kt_j-k+1…t_j-1"，且满足0i和子串t的tk，这是第二种情况；当j=0时有next[j]=-1，则令主串的下标和模式串的下边同时增1，即随后用主串s当前字符的下一个字符和子串t的t₀比较。

       KMP函数可按如下方法设计：设s为主串，t为模式串，i为主串当前比较字符的下标，j为模式串当前比较字符的下标。令i的初值为start，j的初值为0。当s_i=t_j时，i和j分别增1再继续比较；否则i不变，j改为next[j]值在继续比较。笔记哦啊过程中有两种情况：一是j增加到某个值或j退回到某个j=next[j]值时有s_i=t_j，则此时i和j分别增1再继续比较；二是j退回到j=-1时，令主串和子串的下标各增1，随后比较s_i+1和t₀。这样的循环过程知道变量i大于等于主串s的长度或变量j大于等于子串t的长度终止。

5、计算next[j]值的函数设计

next[j]值的计算问题是一个递推计算问题。设有next[j]=k，即模式串t中存在，其中k为满足等式的最大值"t ₀t ₁…t _k-1"="t _j-kt _j-k+1…t _j-1"(0

（1）若t _k=t _j，则表明在模式串中有 "t ₀ t ₁ …t _k "="t _j-k t _j-k+1 …t _j "，且不可能存在任何一个k'>k满足上式，因此有：next[j+1]=next[j]+1=k+1。

（2）若 t _k ≠t _j ，则可把计算next[j+1]值的问题看成是把模式串t'向右滑动至k'=next[k](0t_k'=t_j，则表明在模式串t中有 "t₀t₁…t_k'"="t_j-k't_j-k'+1…t_j"(0t_k'≠t_j，则将模式串t'右滑到k''=next[k']后继续匹配。以此类推，直到某次比较有t_k=t_j（此即为上述情况），或某次比较有t_k≠t_j且k=0，此时有：next[j+1]=0。

6、代码示例

public class KMP {
	public static int indexKMP(String str , String subStr , int start) { //str表示主串,subStr表示子串,start表示开始比较的下标
		int[] next = getNext(subStr);
		int i = start , j = 0 , result;
		while ( i < str.length() && j < subStr.length() ) {
			if ( (j == -1) || (str.charAt(i) == subStr.charAt(j)) ) {
				i++;
				j++;
			}
			else
				j = next[j];
		}
		if(j == subStr.length())
			result = i - subStr.length() + 1;
		else
			result = -1;
		return result;
	}
	
	public static int[] getNext(String subStr) {
		int j = 1 , k = 0;
		int[] next = new int[subStr.length()];
		
		next[0] = -1;
		next[1] = 0;
		while (j < subStr.length() - 1) {
			if (subStr.charAt(j) == subStr.charAt(k)) {
				next[j + 1] = k + 1;
				j++;
				k++;
			}
			else if ( k == 0 ) {
				next[j + 1] = 0;
				j++;
			}
			else 
				k = next[k];
		}
		return next;
	}
	
	public static void main(String[] args) {
		String str = "cddcdc";
		String subStr = "cdc";
		int result = indexKMP(str , subStr , 0);
		if ( result == -1 ) 
			System.out.println("Not find!");
		else 
			System.out.println("pos = " + result);
	}
}

输出结果为：

pos = 4