brute force/BF 暴力法查找子字符串

暴力匹配算法

BF法就是brute force暴力法，就是在主串里面一个一个字符向后移去查找是否存在需要查找的子字符串。

 如果用暴力匹配的思路，并假设现在文本串S匹配到 i 位置，模式串P匹配到 j 位置，则有：

如果当前字符匹配成功（即S[i] == P[j]），则i++，j++，继续匹配下一个字符；
如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0。相当于每次匹配失败时，i 回溯，j 被置为0。

 理清楚了暴力匹配算法的流程及内在的逻辑，咱们可以写出暴力匹配的代码，如下：

int ViolentMatch(char* s, char* p)
{
	int sLen = strlen(s);
	int pLen = strlen(p);
 
	int i = 0;
	int j = 0;
	while (i < sLen && j < pLen)
	{
		if (s[i] == p[j])
		{
			//①如果当前字符匹配成功（即S[i] == P[j]），则i++，j++    
			i++;
			j++;
		}
		else
		{
			//②如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0    
			i = i - j + 1;
			j = 0;
		}
	}
	//匹配成功，返回模式串p在文本串s中的位置，否则返回-1
	if (j == pLen)
		return i - j;
	else
		return -1;
}

举个例子，如果给定文本串S“BBC ABCDAB ABCDABCDABDE”，和模式串P“ABCDABD”，现在要拿模式串P去跟文本串S匹配，整个过程如下所示：

    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）

    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）

    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）

    4. S[5]跟P[1]匹配成功，继续执行第①条指令：“如果当前字符匹配成功（即S[i] == P[j]），则i++，j++”，得到S[6]跟P[2]匹配（i=6，j=2），如此进行下去

    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）

    6. 至此，我们可以看到，如果按照暴力匹配算法的思路，尽管之前文本串和模式串已经分别匹配到了S[9]、P[5]，但因为S[10]跟P[6]不匹配，所以文本串回溯到S[5]，模式串回溯到P[0]，从而让S[5]跟P[0]匹配。

    而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 的位置，让模式串尽量地移动到有效的位置。
 

来源：https://blog.csdn.net/v_july_v/article/details/7041827

/*其他代码*/

第一种方法查找所有出现的字符串在主字符串里的下标：

vector<int> bfSearch(string &text, string &substr)
{
    vector<int> begIndex;
    int n = text.size();
    int m = substr.size();
 
    //注意这里是i<=n-m不是i<n-m
    for (int i = 0; i <= n - m; i++)
    {
        int j = 0;
        for (; j < m; j++)
        {
            if (substr[j] != text[i+j])
            {
                break;
            }
        }
        if (j == m)
        {
            //注意这里是i，不是i-m
            begIndex.push_back(i);
        }
    }
    return begIndex;
}

测试：

int main()
{
    string str1 = "abcddbeddbaddb";
    string substr = "ddb";
    vector<int> vi = bfSearch(str1, substr);
    for(auto x:vi)
        cout<<x<<" ";
    cout<<endl;
    system("pause");
    return 0;
}

运行：

显式回溯，查找第一个出现的字符串在主串中的下标：

int bfSearchTrackBack(string &text, string &substr)
{
    int n = text.size();
    int m = substr.size();
    int j = 0;
    int i = 0;
    for (; i<=n-m && j<m; i++)
    {
        if (text[i] == substr[j])
        {
            j++;
        }
        else
        {
            i = i-j; //回溯，后面还有i++，所以这里不用+1.
            j = 0;
        }
    }
    if (j == m)
        return i-m;
    return n;
}

测试：

int main()
{
    string str1 = "abcddbeddbaddb";
    string substr = "ddb";
    cout<<bfSearchTrackBack(str1, substr)<<endl;
 
    system("pause");
    return 0;
}

运行：

原文：https://blog.csdn.net/kenden23/article/details/15811425