朴素模式匹配与KMP模式匹配算法

一、朴素模式匹配

朴素模式匹配算法

就是遍历主串，然后把待匹配字符串与子串进行比对，先把待匹配子串的第一个字母与主串进行匹配，若匹配成功，则两串的坐标依次 ++，匹配不成功时，主串坐标返回到开始匹配时的坐标，待匹配串坐标清零，若待匹配坐标等于待匹配子串长度，则证明匹配成功， 返回匹配完毕主串的第一个坐标，否则返回-1

假设主串的长度为N，待匹配串的长度为M，因为需要遍历主串，每次匹配的长度都小于等于M，所以

它的时间复杂度是O(M*N)的

	public static int puSu(String str1, String match1) {
		int length1 = str1.length();
		int length2 = match1.length();
		//i，j，k分别表示的是主串下标、匹配串下标、记录下次循环主串开始的位置
		int i = 0;
		int j = 0;
		int k = 0;
		char [] str = str1.toCharArray();
		char [] match = match1.toCharArray();
		while(i < length1 && j < length2) {
			if(str[i] == match[j]) {
				i++;
				j++;
			}else {
				k++;
				j = 0;
				i = k;
			}
		}
		if(j == length2) {
			return k;
		}else {
			return -1;
		}	
	}
	public static void main(String[] args) {
		String str = "asdfghg";
		String m1 = "sd";
		String m2 = "ad";
		System.out.println(puSu(str, m1));
		System.out.println(puSu(str, m2));
	}

二、KMP模式匹配算法

KMP模式匹配算法

因为朴素匹配的时间复杂复杂度为O(M*N)，因此我们寻求一个时间复杂度较小的模式匹配算法，

KMP，一般用来表示克努斯-莫里斯-普拉特算法（Knuth-Morris-Pratt），是在一个“主文本字符串” Str内查找一个“词” Match 的出现，通过观察发现，在不匹配发生的时候这个词自身包含足够的信息来确定下一个匹配将在哪里开始， 以此避免对以前匹配过的字符重新检查。KMP模式匹配算法主要解决的是传统朴素模式匹配算法，当主串从i开始进行匹配，当匹配到j位置时，发现不匹配，主串跳回i+1位置，匹配串跳回0位置，这就导致匹配的效率很低，时间复杂度很高。KMP则当到j位置不匹配时，主串不动，匹配串先通过计算从当前位置的前缀子串和后缀子串的最大匹配串的长度， KMP算法的精髓就是在于求nextArray的过程，这个数组的作用就是把待匹配字符串从头开始向右滑动和主串进行匹配（每次滑动的大小就是nextArray[i]存储的值的大小）从而省去了match字符串返回到终点和主串返回到i+1位置 上的过程。

逻辑思路：

①求nextArray数组的值。我们在进行KMP模式匹配的时候，因为每次匹配失败，match字符串都要向右滑动nextArray[j-i]

个长度的值，所以，第一步就是要求得nextArray数组的值。如何求nextArray的值？首先我们来看nextArray数组的定义：

当主串从i位置开始匹配，到j位置失败的时候，match指针现在的位置是在j-i位置上的，我们得到一个必须一match[0]开头的前缀字符串，必须以match[j-i-1]结尾的后缀字符串，这两个字符串的最大匹配长度就是nextArray[j-i]的值。举个例子：假设match="aaaaabb",这个字符串，匹配失败的时候j-i的值为6，则match[j-i]="b",所以它之前的字符串为 "aaaaab",其前缀字符串为match[1,2,3,4,5]="aaaab",后缀字符为match[0,1,2,3,4]="aaaaa"所以它的最大匹配字符串为"aaaa",长度为4，所以，nextArray[j-i]的值为4.

②当主串从i位置开始匹配的时候，匹配到j位置发现不匹配。如果，此时nextArray的值为-1也就是没有找到滑动的字符串 的时候，主串的位置++，否则，把match的字符串的从头向右滑动nextArray[j-i]个字符，让match[k],k的值为 nextArray[j-i]的值+1，与str[j]的值进行匹配，直至str在某一位置把match匹配完，则证明str中有match 返回的位置为si-mi的值，如果match滑到最后也没有匹配出来，则证明该主串中没有match，返回-1，整个过程结束。

public static int getIndexOf(String s, String m) {
		if(s == null || m == null || m.length() < 1 || s.length() < m.length()) {
			return -1;
		}
		char [] ss = s.toCharArray();
		char [] ms = m.toCharArray();
		int si = 0;
		int mi = 0;
		int [] nextArray  = getNextArray(ms);
		while(si < s.length() && mi < m.length()) {
			if(ss[si] == ms[mi]) {
				si++;
				mi++;
			}else if(nextArray[mi] == -1) {
				si++;
			}else {
				mi = nextArray[mi];
			}
		}
		
		return mi == m.length() ? si - mi : -1;
		
	}
	
	//求nextArray的过程
	public static int[] getNextArray(char[] ms) {
		//当待匹配串不匹配时已匹配串的的长度+1等于1时，由定义可知nextArray==-1
		if(ms.length == 1) {
			return new int [] {-1};
		}
		int [] nextArray = new int [ms.length];
		//由定义可知，nextArray的第一个值和第二个值为-1和0
		nextArray[0] = -1;
		nextArray[1] = 0;
		//匹配失败的位置
		int pos = 2;
		//因为是从头向后进行匹配，所以在算nextArray[j-1]的值得时候nextArray[j-i-1]的值就已经知道了
		//cn代表的值就是最大匹配长度，他的含义是已匹配字符串的前缀字符串的下一个字符串，
		//match[cn]和match[j-i-1]进行比较,若相等，则nextArray[j-i] = nextArray[j-i-1]+1
		//若不相等，则看match[cn]这个字符的最长前缀和后缀匹配情况，也就是求nextArray[cn],
		//求这个数组的长度和上一步一样，看nextArray[cn-1]的值，和两个前缀字符串假设两个区域是n和m，n的下一个
		//字符串的值为x，则判断x的值和match[cn-1]的值是否相等，若相等，则nextArray[j-i] = nextArray[cn]+1
		//不相等则继续进行判断，直至match[cn] <= 0时证明该段字符串的最长匹配值为0，即nextArray[j-i] = 0
		int cn = 0;
		while(pos < ms.length) {
			if(ms[pos] == ms[cn]) {
				nextArray[pos++] = ++cn;
			}else if(cn > 0) {
				cn = nextArray[cn];
			}else {
				nextArray[pos++] = 0;
			}
		}
	
		return nextArray;
	}
	public static void main(String[] args) {
		String str = "asdfghg";
		String m1 = "df";
		String m2 = "ad";
		System.out.println(getIndexOf(str,m1));
		System.out.println(getIndexOf(str, m2));
	}

KMP算法的时间复杂度：

匹配的过程会遍历主串，遍历主串的代价是O(N)的，再来看求nextArray这个方法的时间复杂度，主要是两个量，一个是pos这个变量，它的含义就是匹配失败的坐标，所以大小肯定小于M，再来看pos-cn这个变量，也就是滑动的次数，因为破损最大值为M-1，cn最小值为0，所以pos-cn的值还是小于M的，因此它的时间复杂度不会超过2M,也就是O(M)，所有他的时间复杂度为O(N)+O(M)，因为在实际情况中，M的大小要远小于N的，所以，我们可以把它的时间复杂度看成O(N).