LeetCode ImplementStrstr

class Solution {
public:
    char *strStr(char *haystack, char *needle) {
        if (haystack == NULL || needle == NULL) return NULL;
        int wpos[256];
        char cur = 0;
        int len = 0;
        for (int i=0; i < 256; i++) wpos[i] = -1;

        for (int i=0; (cur =  needle[i]) != '\0'; i++, len++) wpos[cur] = i;
        int p = 0, q = 0;
        while (true) {
            while (haystack[p] != '\0'
                    && needle[q] != '\0'
                    && haystack[p] == needle[q]) p++, q++;

            if ( needle[q] == '\0') {
                return haystack + p - q;
            }

            if (haystack[p] == '\0') {
                return NULL;
            }

            int npos = p - q + len;
            int move = wpos[haystack[npos]];
            q = 0;
            if (move < 0) {
                p++;
            } else {
                p = npos - move;
            }
        }
        return NULL;
    }
};

又写了次sunday算法，还是磕磕碰碰

第二轮 3.21

Implement strStr().

Returns the index of the first occurrence of needle in haystack, or -1 if needle is not part of haystack.

kmp、sunday都想不起来了，直接暴力吧，超时，然后加上一些条件能过应该是testcase不好，否则还是应该能造成超时：

class Solution {
public:
    int strStr(char *haystack, char *needle) {
        if (haystack == NULL || needle == NULL) {
            return -1;
        }
        
        int hlen = strlen(haystack);
        int nlen = strlen(needle);
        
        if (nlen > hlen) {
            return -1;
        }
        
        int hi = 0;
        int ni = 0;
        while (hi < (hlen - nlen + 1)) {
            int ti = hi;
            ni = 0;
            // try to campare start from haystack[ti] & needle[ni] (ti=hi, ni=0)
            while (needle[ni] != '\0' && haystack[ti] != '\0') {
                if (needle[ni] == haystack[ti]) {
                    ni++, ti++;
                } else {
                    break;
                }
            }
            if (needle[ni] == '\0') {
                return hi;
            }
            // start from next char
            hi++;
        }
        // not found
        return -1;
    }
};

 下面就超时：

class Solution {
public:
    int strStr(char *haystack, char *needle) {
        if (haystack == NULL || needle == NULL) {
            return -1;
        }
        
        for (int i=0; true; i++) {
            int ci = i;
            int ni;
            for(ni = 0; needle[ni] && haystack[ci]; ni++, ci++) {
                if (needle[ni] != haystack[ci]) {
                    break;
                }
            }
            if (needle[ni] == '\0') {
                return i;
            }
            if (haystack[i] == '\0') {
                break;
            }
        }
        
        // not found
        return -1;
    }
};

下面又不超时，到底是为什么？不是一样的方式么

class Solution {
public:
    int strStr(char *haystack, char *needle) {
        int i,j;  
        for (i = j = 0; haystack[i] && needle[j];) {  
            if (haystack[i] == needle[j]) {  
                ++i;  
                ++j;  
            } else {  
                i = i - j + 1;  
                j = 0;  
            }  
        }  
        return needle[j] ? -1 : (i - j);  
    }
};

 

一次Sunday算法：

 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int sunday(const char* src, const char* pattern) {
    if (src == NULL || pattern == NULL) return -1;
    int slen = strlen(src);
    int plen = strlen(pattern);

    int cpos = 0;
    int dict[256] = {0};
    memset(dict, -1, sizeof(dict));
    for (int i=0; i<plen; i++) {
        dict[pattern[i]] = i;
    }

    while (cpos + plen <= slen) {
        int i = 0;
        while (i < plen) {
            if (src[i+cpos] != pattern[i]) {
                break;
            }
            i++;
        }

        if (i == plen) {
            return cpos;
        }

        int move = dict[src[cpos + plen]];
        // printf("tail char: %c\n", pattern[cpos + plen]);
        if (move < 0) {
            cpos = cpos + plen;
        } else {
            cpos = cpos + plen - move;
        }
        // printf("next pos:%d, %c\n", cpos, src[cpos]);
    }
    return -1;
}

int main(int argc, char* argv[]) {

    if (argc < 3) {
        printf("%s <src string> <pattern string>\n", argv[0]);
        return 0;
    }

    int idx = sunday(argv[1], argv[2]);
    if (idx < 0) {
        printf("not found pattern in src string\n");
        return 0;
    }
    printf("match idx: %d, string from: %s\n", idx, argv[1] + idx);
    return 0;
}

 可以再简化代码：

#include <iostream>
#include <cstdlib>

int sunday(const char* pattern, const char* str) {
    if (pattern == NULL || str == NULL) {
        return -1;
    }
    int slen = 0, plen = 0;

    while (pattern[plen] != '\0') plen++;
    while (str[slen] != '\0') slen++;
    
    int tbl[128];
    for (int i=0; i<128; i++) tbl[i] = -1;
    for (int i=0; i<plen; i++) tbl[pattern[i]] = i;
    
    int pi = 0, si = 0;
    
    while (si < slen) {
        while (str[si] == pattern[pi] && si < slen) si++, pi++;
        if (pi == plen) return si - plen;
        int nidx = plen - pi + si;
        int offset = tbl[str[nidx]];
        si = nidx - offset;
        pi = 0;
    }
    return -1;
}

int main() {
    char* pattern = "simple";
    char* str = "the example is a simple example.";
    
    
    int idx = sunday(pattern, str);
    if (idx < 0) {
        printf("not found\n");
    } else {
        printf("found at: %d\n", idx);
        printf("str:%s\n", str + idx);
    }
    system("pause");
    return 0;
}

si = nidx - offset;
这里当offset是负数时和非负数时其实是两种情况，但是因为将tbl数组初始化了为-1，所以nidx-offset其实相当于nidx + 1，刚刚可以把两种情况统一了。

感觉前面的暴力法写的复杂了，思路可以再清晰一些：

class Solution {
public:
    int strStr(string haystack, string needle) {
        int hlen = haystack.size();
        int nlen = needle.size();
        
        for (int i=0; i<hlen; i++) {
            int p = i, q = 0;
            if (hlen - i < nlen) {
                return -1;
            }
            while (p < hlen && q < nlen && haystack[p] == needle[q]) p++, q++;
            if (q == nlen) {
                return i;
            }
        }
        return nlen == 0 ? 0 : -1;
    }
};