暴力匹配算法

针对问题：
给定一个源文本串S，和一个模式匹配串P，需要查找P在S中第一次出现的下标位置。
若P在S中存在，则返回下标值；若P在S中不存在，则返回-1。

算法思路：
- 如果当前字符匹配成功，即 S[i]==P[j]，则i++,j++，继续匹配下一个字符
- 如果当前字符匹配失败，即 S[i]!=p[j]，则i回溯到i-(j-1)，j被重置为0。

代码：

//java
int match(char []s, char []p){
    int sLen = s.length;
    int pLen = p.length;
    int i = 0;
    int j = 0;
    while(i<sLen && j<pLen){
        if(s[i] == p[j]){//匹配成功
            i++;
            j++;
        }else{//匹配不成功
            i = i-j+1;
            j = 0;
        }
    }
    if(j == pLen)//匹配成功，返回下标位置
        return i-j;
    else//匹配不成功，返回-1
        return -1;
}

执行过程：
前提：
S为”bbc abcdab abcdabcdabde“，P为”abcdabd“。
过程：
1>>S[0]为b，P[0]为a，不匹配，执行第②个条件：“如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j =0”，S[1]跟P[0]匹配，相当于模式串要往右移动一位（i=1，j=0）
**b**bc abcdab abcdabcdabde
**a**bcdabd
2>> S[1]跟P[0]还是不匹配，继续执行第②个条件：“如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0”，S[2]跟P[0]匹配（i=2，j=0），从而模式串不断的向右移动一位（不断的执行“令i = i - (j - 1)，j = 0”，i从2变到4，j一直为0）
b**b**c abcdab abcdabcdabde
**a**bcdabd
3>>直到S[4]跟P[0]匹配成功（i=4，j=0），此时按照上面的暴力匹配算法的思路，转而执行第①个条件：“如果当前字符匹配成功（即S[i] == P[j]），则i++，j++”，可得S[i]为S[5]，P[j]为P[1]，即接下来S[5]跟P[1]匹配（i=5，j=1）
bbc **a**bcdab abcdabcdabde
**a**bcdabd
4>>S[5]跟P[1]匹配成功，继续执行第①个条件：“如果当前字符匹配成功（即S[i] == P[j]），则i++，j++”，得到S[6]跟P[2]匹配（i=6，j=2），如此进行下去
bbc a**b**cdab abcdabcdabde
a**b**cdabd
5>>直到S[10]为空格字符，P[6]为字符D（i=10，j=6），因为不匹配，重新执行第②个条件：“如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0”，相当于S[5]跟P[0]匹配（i=5，j=0）
bbc abcdab** **abcdabcdabde
abcdab**d**
6>>至此，我们可以看到，如果按照暴力匹配算法的思路，尽管之前文本串和模式串已经分别匹配到了S[9]、P[5]，但因为S[10]跟P[6]不匹配，所以文本串回溯到S[5]，模式串回溯到P[0]，从而让S[5]跟P[0]匹配
bbc a**b**cdab abcdabcdabde
**a**bcdabd
而S[5]肯定跟P[0]失配。为什么呢？因为在之前第4步匹配中，我们已经得知S[5] = P[1] = b，而P[0] = a，即P[1] != P[0]，故S[5]必定不等于P[0]，所以回溯过去必然会导致失配。

衍生问题：
那有没有一种算法，让i 不往回退，只需要移动j 即可呢？？？
答案是肯定的。这就是KMP算法，它利用之前已经部分匹配这个有效信息，保持i 不回溯，通过修改j 的位置，让模式串尽量地移动到有效的位置。

http://blog.csdn.net/u013076044/article/details/41833325