(with example) Why is KMP string matching O(n). Shouldn't it be O(n*m)?

Question

Why is KMP O(n + m)?

I know this question has probably been asked a million times on here but I haven't find a solution that convinced me/I understood or a question that matched my example.

/**
 * KMP algorithm of pattern matching.
 */
public boolean KMP(char []text, char []pattern){

    int lps[] = computeTemporaryArray(pattern);
    int i=0;
    int j=0;
    while(i < text.length && j < pattern.length){
        if(text[i] == pattern[j]){
            i++;
            j++;
        }else{
            if(j!=0){
                j = lps[j-1];
            }else{
                i++;
            }
        }
    }
    if(j == pattern.length){
        return true;
    }
    return false;
}

n = size of text
m = size of pattern

I know why its + m, thats the runtime it takes to create the lsp array to do lookups. I'm not sure why the code I passed above is O(n).

I see that above "i" always progresses forwards EXCEPT when it doesn't match and j!= 0. In that case, we can do iterations of the while loop where i doesn't move forward, so its not exactly O(n)

If the lps array is incrementing like [1,2,3,4,5,6,0]. If we fail to match at index 6, j gets updated to 5, and then 4, and then 3.... and etc and we effectively go through m extra iterations (assuming all mismatch). This can occur at every step.

so it would look like

for (int i = 0; i < n; i++) {
    for (int j = i; j >=0; j--)  {
    }
}

and to put all the possible ij combinations aka states would require an m array so wouldn't the runtime be O(n m).

So is my reading of the code wrong, or the runtime analysis of the for loop wrong, or my example is impossible?

Answer 1

Actually, now that I think about it. It is O(n+m). Just visualized it as two windows shifting.