C++ KMP算法的时间复杂度

我正在尝试使用KMP算法实现strstr。这是维基百科中给出的算法。KMP算法的时间复杂度为O（n），其中n是较大字符串的大小

vector<int> KMP(string S, string K)
{
    vector<int> T(K.size() + 1, -1);
    vector<int> matches;

    if(K.size() == 0)
    {
        matches.push_back(0);
        return matches;
    }
    for(int i = 1; i <= K.size(); i++)
    {
        int pos = T[i - 1];
        while(pos != -1 && K[pos] != K[i - 1]) pos = T[pos];
        T[i] = pos + 1;
    }

    int sp = 0;
    int kp = 0;
    while(sp < S.size())
    {
        while(kp != -1 && (kp == K.size() || K[kp] != S[sp])) kp = T[kp];
        kp++;
        sp++;
        if(kp == K.size()) matches.push_back(sp - K.size());
    }

    return matches;
}

向量KMP（字符串S、字符串K） { 向量T（K.size（）+1，-1）； 向量匹配； 如果（K.size（）==0） { 匹配。推回（0）； 返回比赛； }

---

对于（int i=1；i我想您担心的是，在这两种情况下，每个外循环迭代可能执行多达m次内循环，从而导致您提到的最坏情况的复杂性。事实上，这是不可能发生的

从归纳的角度来看第一个循环，由于T[]被初始化为-1，我们有T[0]<0和T[1]<1，并且……您可以看到我们实际上有T[i] 现在转到第二个嵌套循环，看看kp在每个外部循环迭代中只增加一次，而内部while循环只能减少它。由于kp的边界低于-1，并且从0开始，在方法的整个生命周期中，我们总共只能执行一个比外部循环迭代多的内部循环迭代，否则kp将ld最终比-1小得多。因此，第二个嵌套循环的总开销仅为O（n）

---

第一个嵌套循环看起来更复杂，直到您注意到pos在外部循环开始时从T[i-1]读取，然后在结尾写入T[i]=pos+1，因此pos相当于我们刚才分析的嵌套循环中的kp，相同的参数显示成本最多为O（K.size（））.

我认为您担心的是，在这两种情况下，内循环每次外循环迭代可能执行多达m次，从而导致您提到的最坏情况的复杂性。事实上，这是不可能发生的

从归纳的角度来看第一个循环，由于T[]被初始化为-1，我们有T[0]<0和T[1]<1，并且……您可以看到我们实际上有T[i] 现在转到第二个嵌套循环，看看kp在每个外部循环迭代中只增加一次，而内部while循环只能减少它。由于kp的边界低于-1，并且从0开始，在方法的整个生命周期中，我们总共只能执行一个比外部循环迭代多的内部循环迭代，否则kp将ld最终比-1小得多。因此，第二个嵌套循环的总开销仅为O（n）

---

第一个嵌套循环看起来更复杂，直到您注意到pos在外部循环开始时从T[i-1]读取，然后在结尾写入T[i]=pos+1，因此pos相当于我们刚才分析的嵌套循环中的kp，相同的参数显示成本最多为O（K.size（））.

我认为您担心的是，在这两种情况下，内循环每次外循环迭代可能执行多达m次，从而导致您提到的最坏情况的复杂性。事实上，这是不可能发生的

从归纳的角度来看第一个循环，由于T[]被初始化为-1，我们有T[0]<0和T[1]<1，并且……您可以看到我们实际上有T[i] 现在转到第二个嵌套循环，看看kp在每个外部循环迭代中只增加一次，而内部while循环只能减少它。由于kp的边界低于-1，并且从0开始，在方法的整个生命周期中，我们总共只能执行一个比外部循环迭代多的内部循环迭代，否则kp将ld最终比-1小得多。因此，第二个嵌套循环的总开销仅为O（n）

---

第一个嵌套循环看起来更复杂，直到您注意到pos在外部循环开始时从T[i-1]读取，然后在结尾写入T[i]=pos+1，因此pos相当于我们刚才分析的嵌套循环中的kp，相同的参数显示成本最多为O（K.size（））.

我认为您担心的是，在这两种情况下，内循环每次外循环迭代可能执行多达m次，从而导致您提到的最坏情况的复杂性。事实上，这是不可能发生的

从归纳的角度来看第一个循环，由于T[]被初始化为-1，我们有T[0]<0和T[1]<1，并且……您可以看到我们实际上有T[i] 现在转到第二个嵌套循环，看看kp在每个外部循环迭代中只增加一次，而内部while循环只能减少它。由于kp的边界低于-1，并且从0开始，在方法的整个生命周期中，我们总共只能执行一个比外部循环迭代多的内部循环迭代，否则kp将ld最终比-1小得多。因此，第二个嵌套循环的总开销仅为O（n）

---

第一个嵌套循环看起来更复杂，直到您注意到pos在外部循环开始时从T[i-1]读取，然后在结尾写入T[i]=pos+1，因此pos相当于我们刚才分析的嵌套循环中的kp，相同的参数显示成本最多为O（K.size（））.

你认为这是什么并解释？我认为填充数组T是O（m^2），第二部分是O（n*m），其中m是较小字符串的大小。这可能会有帮助：。你认为这是什么并解释？我认为填充数组T是O（m^2），第二部分是O（n*m）其中m是较小字符串的大小。这可能会有帮助：。您认为这还会是什么并解释？我认为填充数组T是O（m^2），第二部分是O（n*m），其中m是较小字符串的大小。这可能会有帮助：。您认为这会是什么并解释？我认为填充数组T是O（m^2）第二部分是O（n*m），其中m是较小字符串的大小。这可能有帮助：。