Brute-Force算法

算法思想

Brute-Force算法是一种简单、直观的模式匹配算法。

其实现方式是：
设 s 是主串， t 为模式串； i 为主串当前比较字符的下标；j 为模式串当前比较字符的下标。令 i 的初值为 start，j 的初值为 0 。
从主串的第 start 个字符 ( i = start ) 起和模式串的第一个字符 ( j = 0 )比较,若相等,则继续逐个比较后续字符 ( i++，j++)；

否则从主串的第二个字符起重新和模式串比较( i 返回到原位置加 1， j 返回到 0 )依此类推，直至模式串t中的每一个字符依次和主串 s 的一个连续的字符序列相等，则称匹配成功，函数返回模式串 t 的第一个字符在主串 s 中的位置;否则称匹配失败，函数返回 -1。

步骤图解

主串 s 为“ababcabdabcabca”,模式串 t 为“abcabc”,匹配过程如下：

代码实现

代码如下：

package com.yyl.algorithm.questions;

public class StringMatchDemo {
    public static void main(String[] args) {
        String s = "ababcabdabcabca";
        String t = "abcabc";
        StringMatchDemo bruteforce = new StringMatchDemo();
        int index = getIndex(s, t);
        System.out.println("对应相同字符在原字符串的第" + index + "位开始到" + (index + t.length() - 1) + "位");
    }

    public static int getIndex(String s, String t) {
        //主串比模式串长时开始比较
        if (s != null && t != null && t.length() > 0 && s.length() >= t.length()) {
            int sLen = s.length(), tLen = t.length();
            // i j 分别是原字符串 与 目标串下标
            int i = 0, j = 0;
            while ((i < sLen) && (j < tLen)) {
                if (s.charAt(i) == t.charAt(j)) {
                    i++;
                    j++;              //当主串字符与模式串字符相同时，查找成功，主串和模式串同时往后开始遍历匹配
                } else {
                    i = i - j + 1;
                    j = 0;          //主串字符与模式串字符不相同时，查找失败，i 返回到原来位置加 1 ，j 返回到0
                }
            }
            if (j >= t.length()) {    // 匹配成功，返回子串的序号
                return i - tLen;
            } else {                  // 匹配失败，返回-1
                return -1;
            }
        }
        return -1;
    }
}

运行结果：

复杂度分析

Brute Force模式匹配算法简单且易于理解，但在一些情况下 ,时间效率非常低，其原因是主串 s 和模式串 t 中已有多个字符比较相等时，只要后面遇到一个字符比较不相等，就需将主串的比较位置 i 回退。

假设主串的长度为 n ,子串的长度为 m ,则模式匹配的BF算法在最好情况下的时间复杂度为O(m)，即主串的前 m 个字符刚好等于模式串的 m 个字符。

BF算法在最坏情况下的时间复杂度为O(nm)，分析如下：假设模式串的前 m-1 个字符序列和主串的相应字符序列比较总是相等，而模式串的第 m 个字符和主串的相应字符比较总是不相等，此时，模式串的 m 个字符序列必须和主串的相应字符序列块一共比较 n-m+1次，每次比较 m 个字符，总共需比较m×(n- m+1)次，因此，其时间复杂度为O(nm)。

KMP算法

算法思想

KMP是一个解决模式串在文本串中是否出现过，如果出现过，最早出现的位置的经典算法

KMP算法常用于在一个文本串S中查找一个模式串P的出现位置，这个算法在1977年由Donald Knuth、Vaughan Pratt、James H.Morris三人发表

KMP算法利用之前判断过信息，通过一个next数组，保存模式串中前后最长公共子序列的长度，每次回溯时，通过next数组找到，前面匹配过的位置，省去了大量的计算时间

KMP算法的时间复杂度O(m+n)

部分匹配值产生过程

首先我们要了解字符串的前缀后缀，例如bread这个词

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

“A”的前缀和后缀都为空集，共有元素的长度为0
“AB”的前缀为A，后缀为B，共有元素为0
“ABC”的前缀为A，AB后缀为BC，C共有元素的长度为0
“ABCDA”的前缀为A，AB,ABC,ABCD，后缀为BCDA,CDA,DA,A共有元素为A，长度为1

我们可以这样理解，对于一个字符的匹配值判断，就看他和前面的第几个字符相等

比如ABCDABD，ABCD的匹配值均为0，但是A与前缀ABCD中的A相同，故匹配值为1，AB与前缀ABCD中的AB相同，故B的匹配值为2，ABD没有与之相同的前缀，故D为0

步骤图解

举个例子：

字符串：str1=“BBC ABCDAB ABCDABCDABDE”，
子串：str2=“ABCDABD”

利用KMP算法判断str1第一次在str2中出现的位置

1.首先，用str1的第一个字符和str2的第一个字符去比较，不符合，关键词向后移动一位

2.重复第一步，还是不符合，再后移

3.一直重复，直到str1有一个字符与str2的第一个字符符合为止

4.接着比较字符串和搜索词的下一个字符，还是符合

5.遇到str1有一个字符与str2对应的字符不符合

6.这时候按照传统算法，我们会继续便利str1的下一个字符，重复第一步，但是这样我们会做很多无用的工作，比如BCD我们已经判断过，已经不用再次进行判断，当空格与D不匹配时，你其实知道前面6个字符是“ABCDAB”。

KMP算法的想法是：设法利用这个已知信息，不要把搜索位置移回已经比较过的位置，而是继续将他向后移，这样就提高了效率

7.我们可以对str2计算出一张部分匹配表如下：

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

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

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

9.因为空格与C不匹配，搜索词继续向后移动，这时，已匹配的字符数为2（“AB”）对应的部分匹配值为0

所以移动为数=2-0，结果为2，于是将搜索词向后移2位

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

11.逐位比较，直到发现C与D不匹配

于是，移动为数=6-2，继续向后移动4位

移动完后

12.逐位比较，直到搜索词的最后一位，发现完全匹配，于是搜索完成，如果还要继续搜索（即找出全部匹配），移动位数=7-0，再将搜索词向后移动7位

代码实现

代码如下：

package com.yyl.algorithm.questions;

import java.util.Arrays;

public class StringMatchDemo {
    public static void main(String[] args) {
        String str1 = "BBC ABCDAB ABCDABCDABDE";
        String str2 = "ABCDABD";

        int index2 = strStr(str1, str2);
        System.out.println("KMP算法：对应相同字符在原字符串的第" + index2 + "位开始到" + (index2 + str2.length() - 1) + "位");
    }

    /**
     * KMP算法
     *
     * @param source
     * @param target
     * @return
     */
    public static int strStr(String source, String target) {
        if (target.length() == 0) {
            return 0;
        }
        // 记录前缀
        int[] next = new int[target.length()];
        getNext(next, target);
        System.out.println(Arrays.toString(next));

        // i 原字符串遍历的下标  j 目标字符串遍历的下标
        for (int i = 0, j = 0; i < source.length(); i++) {
            // 如果不相等就要一直等于前缀
            /*
            因为j表示当前遍历到的目标串的下标，都不一样了，按照常理是j=0直接从头查，但是可能有重复前缀
            那么只能移动到上一个元素的前缀里了就OK了
            
            比到这样的时候
            BBC ABCDAB ABCDABCDABDE
                ABCDABD
                0000122
            不用到下一个再比一下，直接看D的上一个还一样的值的前缀，前缀是2
            BBC ABCDAB ABCDABCDABDE
                    ABCDABD
                    0000122
            那么j再比的时候就直接从 2开始比  也就是比C和空格
            此时 i 就是空格的位置     
            还是在  while (j > 0 && source.charAt(i) != target.charAt(j)) 此时发现还是不同
            j就等于前缀0了  j不大于0了 跳出while，然后i++，再继续比        
             */
            while (j > 0 && source.charAt(i) != target.charAt(j)) {
                j = next[j - 1];
            }
            if (source.charAt(i) == target.charAt(j)) {
                j++;
            }
            if (j == target.length()) {
                return i - j + 1;
            }
        }
        return -1;
    }

    private static void getNext(int[] next, String target) {
        int len = target.length();
        next[0] = 0;
        //ABCDABD
        for (int i = 1, j = 0; i < len; i++) {
            while (j > 0 && target.charAt(i) != target.charAt(j)) {
                // 如果不同  当前的包含元素的前缀就和前一个一样
                j = next[j - 1];
            }
            if (target.charAt(i) == target.charAt(j)) {
                j++;
            }
            next[i] = j;
        }
    }
}

运行结果：