Leetcode | Implement strStr()

Implement strStr().

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

此题我觉得并不是真要你写出kmp算法。 指针暴力法我觉得可能是考察点。而且要accept的话，必须要忽略后面一段不可能匹配的串。指针的操作要非常小心。

Of course, you can demonstrate to your interviewer that this problem can be solved using known efficient algorithms such as Rabin-Karp algorithm, KMP algorithm, and the Boyer-Moore algorithm. Since these algorithms are usually studied in advanced algorithms class, for an interview it is sufficient to solve it using the most direct method — The brute force method.

非指针代码很好小，很难有错。最长扫描n1-n2+1个就够了。

class Solution {
public:
    char *strStr(char *haystack, char *needle) {
        if (haystack == NULL || needle == NULL) return NULL;
        int n1 = strlen(haystack);
        int n2 = strlen(needle);
        int j; 
        
        for (int i = 0; i < n1 - n2 + 1; ++i) {
            j = 0;
            while (j < n2 && needle[j] == haystack[i + j]) j++;
            if (j == n2) return haystack + i;
        }
        return NULL;
    }
};

c指针代码：

class Solution {
public:
    char *strStr(char *haystack, char *needle) {
        if (haystack == NULL || needle == NULL) return NULL;
        if (*needle == '\0') return haystack;
        char *ph = haystack, *pn = needle, *count = ph, *tmp;
        while (*pn) {
            if (!*count) return NULL;
            pn++; 
            count++;
        }
        if (*needle) count--;
        while (*count) {
            pn = needle;
            tmp = ph;
            while (*pn && *tmp && *pn == *tmp) {
                pn++; tmp++;
            }
            if (!*pn) return ph;
            ph++;
            count++;
        }    
        
        return NULL;
    }
};

如果是needle是空串，返回应该是haystack整个串。

最长扫描n1-n2+1个就够了。所以要让count循环m-1次。优化后的代码如下：

class Solution {
public:
    char *strStr(char *haystack, char *needle) {
        if (*needle == '\0') return haystack;
        char *ph = haystack, *pn = needle, *count = ph, *tmp;
        while (*++pn) {
            if (!*count) return NULL;
            count++;
        }
        while (*count) {
            pn = needle;
            tmp = ph;
            while (*pn && *tmp && *pn == *tmp) {
                pn++; tmp++;
            }
            if (!*pn) return ph;
            ph++;
            count++;
        }    
        
        return NULL;
    }
};

 kmp算法的话，直接看wiki就好。看完也实现一遍。

Partial match 数组里面存的是当前位置的前缀等于整个匹配串的某个前缀。

比如"ABCDABC"，第二个B（红色）对应的值就是1（绿色）. 

匹配失败后，假设haystack的当前位置是i，匹配到i+j失败了，假设就匹配到第二个B失败。那么就要j就要指向第一个B那里，然后i就要跳到第二个A，也就是i = i + j - P[j].

class Solution {
public:
    char *strStr(char *haystack, char *needle) {
        if (haystack == NULL || needle == NULL) return NULL;
        if (*needle == '\0') return haystack;
        
        int n1 = strlen(haystack), n2 = strlen(needle), count = 0;
        vector<int> kmp(n2, 0);
        kmp[0] = -1;
        
        for (int i = 2; i < n2; ) {
            if (needle[i - 1] == needle[count]) {
                count++;
                kmp[i++] = count;
            } else if (count > 0) {
                count = kmp[count];
            } else {
                kmp[i++] = 0;
            }
        }
        
        for (int i = 0, j = 0; i + j < n1; ) {
            if (haystack[i + j] == needle[j]) {
                j++;
                if (j == n2) return haystack + i;
            } else if (kmp[j] > 0) {
                i = i + j - kmp[j];
                j = kmp[j];
            } else {
                j = 0;
                i++;
            }
        }
        
        return NULL;
    }
};

前面也有摘过KMP算法。

建立表的算法的复杂度是 O(n)，其中 n 是 W 的长度。除去一些初始化的工作，所有工作都是在 while 循环中完成的，足够说明这个循环执行用了 O(n) 的时间，同时还会检查 pos 和 pos - cnd 的大小。在第一个分支里，pos - cnd 被保留，而 pos 与 cnd 同时递增，自然，pos 增加了。在第二个分支里，cnd 被 T[cnd] 所替代，即以上总是严格低于 cnd，从而增加了 pos - cnd。在第三个分支里，pos 增加了，而 cnd 没有，所以 pos 和 pos - cnd 都增加了。因为 pos ≥ pos - cnd，即在每一个阶段要么 pos 增加，要么 pos 的一个下界增加；所以既然此算法只要有 pos = n 就终止了，这个循环必然最多在 2n 次迭代后终止, 因为 pos - cnd 从 1 开始。因此建立表的算法的复杂度是 O(n)。