目录

BF算法

算法思路

完整代码

时间复杂度

查找所有起始位置

BF算法

BF算法：即暴力(Brute Force)算法，是一种模式匹配算法，将目标串 S 的第一个字符与模式串 T 的第一个字符进行匹配，若相等，则继续比较 S 的第二个字符和 T 的第二个字符；若不相等，则比较 S 的第二个字符和 T 的第一个字符，依次比较下去，直到得出最后的匹配结果

例如：

给定字符串S ："abcdef" 作为主串，给定字符串T： "cd" 作为子串，此时，就需要在主串中查找是否出现子串，若出现，则返回主串中第一个匹配字符的下标；若未出现，则返回 -1

接下来，我们就来看 BF 算法是如何在主串中查找子串的，也就是 BF 算法的思路

算法思路

我们通过一个具体的例子来看：

定义 i 指向主串的 0 下标，j 指向子串的 0 下标

以主串的 0 下标位置作为起始位置开始匹配：

判断 i 位置的字符是否和 j 位置的字符相等， i 位置和 j 位置字符都为 a，相等，则这两个字符匹配成功，i 和 j 向后移动，继续匹配

继续判断 i 位置字符 是否与 j 位置字符相等， i 位置和 j 位置字符都为 b，相等，这两个字符也匹配成功，i 和 j 继续向后移动，进行匹配

继续判断 i 位置字符 是否与 j 位置字符相等，i 位置字符为 c，j 位置字符为 e，不相等，说明以 a（0 下标位置） 为起始位置匹配子串匹配失败

此时，需要将 i 进行回退，由于 a（0下标）作为起始位置匹配失败，因此，继续以 b （1下标）作为起始位置开始尝试匹配，也就是以 原起始位置 + 1 作为新的起始位置开始重新匹配

同样，j 也需要回退，需要将 j 回退到 0 下标位置，与下一个起始位置重新开始匹配

 由于 i 向前移动，当匹配失败时，我们该如何确定起始位置呢？

 由于当 i 和 j 匹配成功时，两者会同时向后移动，因此，通过 j 就可以知道 i 向前移动了多少步

 i - j 就是本次匹配的起始位置，而 i - j + 1 也就是新的起始位置

以 1 下标为起始位置继续匹配：

 i 位置字符为 b，j 位置字符为 a，不相等，说明以 b 为起始位置匹配子串匹配失败，再次回退，由于 i = 1，j = 0，因此，新的起始位置为 2，j 的位置为 0 

继续匹配，  i 位置字符为 c，j 位置字符为 a，不相等，说明以 c 为起始位置匹配子串匹配失败，再次回退，由于 i = 2，j = 0，因此，新的起始位置为 3，j 的位置为 0 

继续匹配， i 位置和 j 位置字符都为 a，相等，这两个字符匹配成功，i 和 j 向后移动

继续匹配， i 位置和 j 位置字符都为 b，相等，这两个字符也匹配成功，i 和 j 向后移动

 继续匹配， i 位置和 j 位置字符都为 e，相等，这两个字符也匹配成功，i 和 j 向后移动 

此时，子串已经遍历完了，也就说明 子串 中的所有字符都与 主串 中的字符相匹配，在主串中找到了子串，此时，就可以直接返回主串中本次匹配的起始位置，也就是 i - j

而若是主串先遍历完成，也就说明 主串 中没有与 子串 中字符完全匹配的字符串，找不到，此时，就需要返回 -1

总结一下上述过程：

1. 定义 i 指向主串的 0 下标，j 指向子串的 0 下标

2. 判断 i 位置字符与 j 位置字符是否相同，若相同，i 和 j 同时向后移动（i++ 且 j++）；若不同，则i 和 j 都需要进行回退（i = i - j + 1，j = 0）

3. 重复 2 过程，直到遍历完 主串 或 子串，若子串先遍历完，说明在主串中找到了子串，匹配成功，返回起始位置（i - j）；若主串先遍历完，说明主串中找不到子串，匹配失败，返回 -1

在分析了 BF 算法的思路之后，我们就来尝试编写代码

完整代码

<code> /**

* 判断主串中是否含有子串

* @param str 主串

* @param target 子串

* @return 主串中含有子串，返回主串中子串第一次出现的起始下标；若不含有，返回 -1

*/

public int BF(String str, String target) {

// 处理特殊情况

if (str == null || target == null) {

return -1;

}

int strLen = str.length();

int targetLen = target.length();

if (strLen == 0 || strLen < targetLen) {

return -1;

}

// 开始判断

int i = 0, j = 0;

while (i < strLen && j < targetLen) {

// 判断 str 中 i 位置字符是否与 target 中j 位置字符相同

if (str.charAt(i) == target.charAt(j)) {

// 相同，i 和 j 都向后移动

i++;

j++;

} else {

// 不相同，i 和 j 都进行回退

i = i - j + 1;

j = 0;

}

}

// 子串先遍历完

if (j >= targetLen) {

return i - j;

} else {

// 主串先遍历完

return -1;

}

}

接下来，我们来分析 BF 算法的时间复杂度

时间复杂度

假设主串长度为 M，子串长度为 N

在最坏情况下，

在主串的前 M - N 个位置，每一次匹配时，都要比较到子串的最后一个字符（比较 N 次），才发现匹配不成功，然后再将 i 和 j 退回，继续比较，一共比较了 （M - N） * N

在 主串的最后 N 个位置，也分别匹配了 N、N - 1、N - 2...次，也就是 (N + 1)(N) / 2

因此，时间复杂度为 O（M*N）

上述我们查找的是主串中子串第一次出现时的起始位置，那么， 若我们想要查找主串中与子串相同的字符串的所有起始位置，该如何实现呢？

查找所有起始位置

与查找 主串中子串第一次出现的起始位置 思路相同

但是，当我们找到第一个起始位置（也就是 j 第一次遍历完子串时）时，不能直接返回，而是要继续在主串中查找

例如：

j 第一次遍历完子串：

以 0 下标为起始的字符串与子串匹配成功，将 0 下标存储起来，然后继续查找 

此时，以 i + 1 为起始位置的字符串可能与字符相同，因此需要将 i 进行回退，继续查找

同时，也需要将 j 回退到 0 下标位置，重新开始匹配

总结一下上述过程：

1. 定义 i 指向主串的 0 下标，j 指向子串的 0 下标

2. 判断 i 位置字符与 j 位置字符是否相同，若相同，i 和 j 同时向后移动（i++ 且 j++）；若不同，则i 和 j 都需要进行回退（i = i - j + 1，j = 0）

3. 判断 j 是否遍历完子串，若遍历完，则存储起始位置（i - j），再将 i 和 j 进行回退（i = i - j + 1，j = 0）

4. 重复 2、3 直到主串遍历完成

 代码实现：

<code> /**

* 查找主串中与子串相同的字符串的所有起始位置

* @param str 主串

* @param target 子串

* @return 查询结果集

*/

public List<Integer> BF(String str, String target) {

List<Integer> ret = new ArrayList<>();

// 处理特殊情况

if (str == null || target == null) {

return ret;

}

int strLen = str.length();

int targetLen = target.length();

if (strLen == 0 || strLen < targetLen) {

return ret;

}

// 开始判断

int i = 0, j = 0;

while (i < strLen) {

// 判断 str 中 i 位置字符是否与 target 中j 位置字符相同

if (str.charAt(i) == target.charAt(j)) {

// 相同，i 和 j 都向后移动

i++;

j++;

} else {

// 不相同，i 和 j 都进行回退

i = i - j + 1;

j = 0;

}

// 判断子串是否遍历完成

if (j >= targetLen) {

ret.add(i - j);

i = i - j + 1;

j = 0;

}

}

return ret;

}