LeetCode ImplementStrstr

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

        for (int i=; (cur =  needle[i]) != '\0'; i++, len++) wpos[cur] = i;
        int p = , q = ;
        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 = ;
            if (move < ) {
                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 -;
        }

        int hlen = strlen(haystack);
        int nlen = strlen(needle);

        if (nlen > hlen) {
            return -;
        }

        int hi = ;
        int ni = ;
        while (hi < (hlen - nlen + )) {
            int ti = hi;
            ni = ;
            // 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 -;
    }
};

下面就超时：

class Solution {
public:
    int strStr(char *haystack, char *needle) {
        if (haystack == NULL || needle == NULL) {
            return -;
        }

        for (int i=; true; i++) {
            int ci = i;
            int ni;
            for(ni = ; 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 -;
    }
};

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

class Solution {
public:
    int strStr(char *haystack, char *needle) {
        int i,j;
        for (i = j = ; haystack[i] && needle[j];) {
            if (haystack[i] == needle[j]) {
                ++i;
                ++j;
            } else {
                i = i - j + ;
                j = ;
            }
        }
        return needle[j] ? - : (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 = ;
    int dict[] = {};
    memset(dict, -, sizeof(dict));
    for (int i=; i<plen; i++) {
        dict[pattern[i]] = i;
    }

    while (cpos + plen <= slen) {
        int i = ;
        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 < ) {
            cpos = cpos + plen;
        } else {
            cpos = cpos + plen - move;
        }
        // printf("next pos:%d, %c\n", cpos, src[cpos]);
    }
    return -;
}

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

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

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

可以再简化代码：

#include <iostream>
#include <cstdlib>

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

    while (pattern[plen] != '\0') plen++;
    while (str[slen] != '\0') slen++;

    int tbl[];
    for (int i=; i<; i++) tbl[i] = -;
    for (int i=; i<plen; i++) tbl[pattern[i]] = i;

    int pi = , si = ;

    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 = ;
    }
    return -;
}

int main() {
    char* pattern = "simple";
    char* str = "the example is a simple example.";

    int idx = sunday(pattern, str);
    if (idx < ) {
        printf("not found\n");
    } else {
        printf("found at: %d\n", idx);
        printf("str:%s\n", str + idx);
    }
    system("pause");
    return ;
}

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=; i<hlen; i++) {
            int p = i, q = ;
            if (hlen - i < nlen) {
                return -;
            }
            while (p < hlen && q < nlen && haystack[p] == needle[q]) p++, q++;
            if (q == nlen) {
                return i;
            }
        }
        return nlen ==  ?  : -;
    }
};