暴力解决（略）

字符串匹配的KMP算法

http://blog.jobbole.com/39066/

字符串匹配是计算机的基本任务之一。

举例来说，有一个字符串”BBC ABCDAB ABCDABCDABDE”，我想知道，里面是否包含另一个字符串”ABCDABD”？

许多算法可以完成这个任务，Knuth-Morris-Pratt算法（简称KMP）是最常用的之一。它以三个发明者命名，起头的那个K就是著名科学家Donald Knuth。

这种算法不太容易理解，网上有很多解释，但读起来都很费劲。直到读到Jake Boxer的文章，我才真正理解这种算法。下面，我用自己的语言，试图写一篇比较好懂的KMP算法解释。

首先，字符串”BBC ABCDAB ABCDABCDABDE”的第一个字符与搜索词”ABCDABD”的第一个字符，进行比较。因为B与A不匹配，所以搜索词后移一位。

因为B与A不匹配，搜索词再往后移。

就这样，直到字符串有一个字符，与搜索词的第一个字符相同为止。

接着比较字符串和搜索词的下一个字符，还是相同。

直到字符串有一个字符，与搜索词对应的字符不相同为止。

这时，最自然的反应是，将搜索词整个后移一位，再从头逐个比较。这样做虽然可行，但是效率很差，因为你要把”搜索位置”移到已经比较过的位置，重比一遍。

一个基本事实是，当空格与D不匹配时，你其实知道前面六个字符是”ABCDAB”。KMP算法的想法是，设法利用这个已知信息，不要把”搜索位置”移回已经比较过的位置，继续把它向后移，这样就提高了效率。

怎么做到这一点呢？可以针对搜索词，算出一张《部分匹配表》（Partial Match Table）。这张表是如何产生的，后面再介绍，这里只要会用就可以了。

已知空格与D不匹配时，前面六个字符”ABCDAB”是匹配的。查表可知，最后一个匹配字符B对应的”部分匹配值”为2，因此按照下面的公式算出向后移动的位数：

　　移动位数 = 已匹配的字符数 – 对应的部分匹配值

因为 6 – 2 等于4，所以将搜索词向后移动4位。

10.

因为空格与Ｃ不匹配，搜索词还要继续往后移。这时，已匹配的字符数为2（”AB”），对应的”部分匹配值”为0。所以，移动位数 = 2 – 0，结果为 2，于是将搜索词向后移2位。

11.

因为空格与A不匹配，继续后移一位。

12.

逐位比较，直到发现C与D不匹配。于是，移动位数 = 6 – 2，继续将搜索词向后移动4位。

13.

逐位比较，直到搜索词的最后一位，发现完全匹配，于是搜索完成。如果还要继续搜索（即找出全部匹配），移动位数 = 7 – 0，再将搜索词向后移动7位，这里就不再重复了。

14.

下面介绍《部分匹配表》是如何产生的。

首先，要了解两个概念：”前缀”和”后缀”。 “前缀”指除了最后一个字符以外，一个字符串的全部头部组合；”后缀”指除了第一个字符以外，一个字符串的全部尾部组合。

15.

“部分匹配值”就是”前缀”和”后缀”的最长的共有元素的长度。以”ABCDABD”为例，

　　－　”A”的前缀和后缀都为空集，共有元素的长度为0；

－　”AB”的前缀为[A]，后缀为[B]，共有元素的长度为0；

－　”ABC”的前缀为[A, AB]，后缀为[BC, C]，共有元素的长度0；

－　”ABCD”的前缀为[A, AB, ABC]，后缀为[BCD, CD, D]，共有元素的长度为0；

－　”ABCDA”的前缀为[A, AB, ABC, ABCD]，后缀为[BCDA, CDA, DA, A]，共有元素为”A”，长度为1；

－　”ABCDAB”的前缀为[A, AB, ABC, ABCD, ABCDA]，后缀为[BCDAB, CDAB, DAB, AB, B]，共有元素为”AB”，长度为2；

－　”ABCDABD”的前缀为[A, AB, ABC, ABCD, ABCDA, ABCDAB]，后缀为[BCDABD, CDABD, DABD, ABD, BD, D]，共有元素的长度为0。

16.

“部分匹配”的实质是，有时候，字符串头部和尾部会有重复。比如，”ABCDAB”之中有两个”AB”，那么它的”部分匹配值”就是2（”AB”的长度）。搜索词移动的时候，第一个”AB”向后移动4位（字符串长度-部分匹配值），就可以来到第二个”AB”的位置。

按照上面的思路可以知道只需要构建出来部分匹配数组就可以了。

上图就是数据结构（严蔚敏）上定义的next

其中的P1...Pk-1和Pj-k-1...Pj-1是部分匹配串的前，后缀

import java.util.*;
public class KMP{
	public static void main(String[] args){
		String S = "acabaabaabcacaabc";
		String T = "abaabcac";
		System.out.println(Index_KMP(S,T));
	}
	private static int Index_KMP(String S,String T){
		int i = 0;
		int j = 0;
		int[] next = getNext(T);
		while(i < S.length() && j < T.length()){
			if(j == -1 || S.charAt(i) == T.charAt(j)){
				++i;
				++j;
			}else{
				j = next[j];
			}
			//System.out.println("i="+i+",j="+j);
		}
		if(j == T.length()){
			return i - T.length();
		}else{
			return -1;
		}
	}
	private static int[] getNext(String p){
		int[] next = new int[p.length()];
		next[0] = -1;
		int i = 0;
		int j = -1;
		while(i < p.length() - 1){
			if(j == -1 || p.charAt(i) == p.charAt(j)){
				++j;
				next[++i]=j;
			}else{
				j = next[j];
			}
			//System.out.println(i);
		}
		/*for(i = 0 ; i < p.length(); i ++){
			System.out.print(next[i] + "\t");
			System.out.println();
		}*/
		return next;
	}
}

Java实现的KMP，如果不存在模式串则返回-1，否则返回模式串第一次出现的位置。

字符串匹配的Sunday算法

听说这个算法比kmp效率还高，而且重要的是还好理解，所以就.....

好了，sunday算法还真的很好理解，用下面的例子来说明吧：

j k

这个例子中上面的字符串是待查找字符串，下面的是子串。sunday的思想是这样的：

首先i,j两个指针指示的位置（也就是从头开始匹配），当发现失配的时候就判断子串的后一位在母串的字符（在上面的例子中是空格字符，k标记处）是否在子串中存在？如果存在则将该位置和子串中的该字符对齐，在从头开始匹配。如果不存在就将子串向后移动，和母串k+1处的字符对齐，再进行匹配。重复上面的操作直到找到，或母串被找完结束。

对于上面的例子继续进行，刚才说了失配，并且空格在子串中不存在，所以子串向后移动，子串的第一个字符和母串的k+1位置的字符对齐，如下图：

j k

这次比较还是失配，但是k位置的e在子串中出现了，而且第一个就是，最后一个也是，这时候一定要将子串中靠后出现的e和母串中的e对齐如下图：

j k

为什么是最靠后的一个呢？如果这里用第一个e来和母串中的e对齐，就有可能将中间出现的可匹配字符串空过去。

同上这次还是失配，所以还要再进行一次。

这次就匹配成功了。

public class Sunday{
        public static void main(String[] args){
                //String s = "this is a simple example.";
                //String t = "examplo";
                String s = "substring searching algorithm";
                String t = "search";
                System.out.println(IndexSunday(s,t));
        }
        private static int IndexSunday(String s, String t){
                int i = 0, j = 0;
                int len = t.length();
                while(i < s.length() && j < len){
                        if(s.charAt(i) == t.charAt(j)){//匹配
                                i++;
                                j++;
                        }else{
                                if(i + len > s.length()){
                                        return -1;
                                }
                                int tmp = getIndex(t,s.charAt(i + len)) ;
                                //System.out.println(tmp);
                                if(tmp != -1){ //不匹配,但在子串中存在
                                        i = i + len - tmp;
                                        j = 0 ;
                                }else{//不匹配，且在子串中不存在
                                        i = i + len + 1;
                                        j = 0;
                                }
                        }
                        //System.out.println("i = " + i + ", j = " + j);
                }
                if(j >= len){
                        return i - len;
                }else{
                        return -1;
                }
        }
        private static int getIndex(String t,char c){//字符c在t的位置，-1代表不存在
                int index = t.length() - 1;
                for(;index >= 0; index--){
                        if(t.charAt(index) == c){
                                return index;
                        }
                }
                return index;
        }
}

java实现，主要是三个步骤

1，当匹配时，i++，j++

2，不匹配，但是k+1处的元素在模式串中存在，则i = i + len - tmp，j = 0；

3，不匹配且在模式串中不存在，则i = i + len + 1;j = 0;

这个算法简单好理解；

还有其他算法，如Boyer-Moore算法 Horspool算法 Sunday算法 KR算法 AC自动机

参考http://dsqiu.iteye.com/blog/1700312

字符串匹配算法总结

暴力解决（略）

字符串匹配的KMP算法

字符串匹配的Sunday算法

你可能感兴趣的:(数据结构,字符串匹配)