[Leetcode 83] 28 Implement strStr()

Problem:

Implement strStr().

Returns a pointer to the first occurrence of needle in haystack, or null if needle is not part of haystack.

Analysis:

There are two ways: one is the naive comparing algorithm and the other is KMP algorithm.

For KMP algorithm, please refer the wiki page

For the naive algorithm, we start from the haystack's first position until the one plus needle's length is greater than the haystack's length.

For each position, we compare it with the needle. If they are the same, we compare the next position and repeat this process. If they are not the same, we know this i-position won't give a match. So we just break out of the loop and go to the next i position. If we reach the end of the needle position, then there is a match. And return the i. This algoritm is of complexity O(m*n)

 A special case is that the given needle is of length 0. In this case, we directly return the haystack.

Code:

Naive algorithm:

class Solution {
public:
    char *strStr(char *haystack, char *needle) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        int hlen = strlen(haystack);
        int nlen = strlen(needle);
        
        for (int i=0; i+nlen <= hlen; i++) {
            int j = 0;
            
            for (j=0; j<nlen; j++) {
                if (haystack[j+i] != needle[j])
                    break;
            }
            
            if (j == nlen) return haystack+i;
        }
        
        return NULL;
    }
};

KMP algorithm:

class Solution {
public:
    char *strStr(char *haystack, char *needle) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        int n = strlen(haystack), m = strlen(needle);
        
        if (m == 0)
            return haystack;
        
        failure_function(needle);
        int i = 0, j = 0;
        while (true) {
            if (i == n)
                break;
                
            if (haystack[i] == needle[j]) {
                i++;
                j++;
                if (j == m) 
                    return haystack + i - j;
            } else if (j > 0) {
                j = ff[j];
            } else
                i++;
        }
        
        return NULL;
    }
    
    
    void failure_function(char *s) {
        int n = strlen(s);
        
        ff = new int[n+1];
        
        ff[0] = ff[1] = 0;
        
        for (int i=2; i<=n; i++) {
            int j = ff[i-1];
            while (true) {
                if (s[j] == s[i-1]) {
                    ff[i] = j + 1;
                    break;
                }
                
                if (j == 0) {
                    ff[i] = 0;
                    break;
                }
                     
                j = ff[j];
            }
        }
    }
    
private:
    int *ff;
};