代码随想录算法训练营第九天 | 28. 实现 strStr()、459.重复的子字符串、字符串总结、双指针回顾

最新推荐文章于 2024-08-13 14:56:59 发布

Wowblk

最新推荐文章于 2024-08-13 14:56:59 发布

阅读量65

点赞数

文章标签：算法

本文链接：https://blog.csdn.net/Wowblk/article/details/134906846

版权

Leetcode 28.实现strStr()

题目链接：28.实现strStr()
解题思路：

KMP解法：

class Solution {
public:
    void getNext(int *next,  const string &s) {
        int j = 0;
        next[0] = 0;
        for(int i = 1; i < s.size(); i++) {
            while(j > 0 && s[i] != s[j]) {
                j = next[j-1];
            }
            if(s[i] == s[j]) j++;
            next[i] = j;
        }
    }

    int strStr(string haystack, string needle) {
        if(needle.size() == 0) return 0;

        int next[needle.size()];
        getNext(next, needle);

        int j = 0;
        for(int i = 0; i < haystack.size(); i++) {
            while(j > 0 && haystack[i] != needle[j]) {
                j = next[j - 1];
            }
            if(haystack[i] == needle[j]) j++;

            if(j == needle.size()) {
                return (i - needle.size() + 1);
            }
        }
        return -1;
    }
};

时间复杂度为O(n + m)
空间复杂度为O(m)

朴素解法：

class Solution {
public:
    int strStr(string haystack, string needle) {
        if(needle.size() == 0) return 0;
        bool flag = true;
        for(int i = 0; i < haystack.size(); i++) {
            flag = true;
            for(int j = 0; j < needle.size(); j++) {
                if(haystack[i+j] != needle[j]) {
                    flag = false;
                    break;
                }
            }
            if(flag) return i;
        }
        return -1;
    }
};

时间复杂度为O(m*n)
空间复杂度为O(1)

Leetcode 459.重复的子字符串

题目链接：459.重复的子字符串
解题思路：

KMP解法：

class Solution {
public:
    void getNext (int* next, const string& s){
        next[0] = 0;
        int j = 0;
        for(int i = 1;i < s.size(); i++){
            while(j > 0 && s[i] != s[j]) {
                j = next[j - 1];
            }
            if(s[i] == s[j]) {
                j++;
            }
            next[i] = j;
        }
    }
    bool repeatedSubstringPattern (string s) {
        if (s.size() == 0) {
            return false;
        }
        int next[s.size()];
        getNext(next, s);
        int len = s.size();
        if (next[len - 1] != 0 && len % (len - (next[len - 1] )) == 0) {
            return true;
        }
        return false;
    }
};

时间复杂度为O(n)
空间复杂度为O(n)

移动匹配：

class Solution {
public:
    bool repeatedSubstringPattern(string s) {
        string ss = s + s;
        ss.erase(ss.begin());
        ss.erase(ss.end() - 1);

        if(ss.find(s) != s.npos) return true;
        else return false;
    }
};

时间复杂度为O(n)
空间复杂度为O(1)

暴力解法：

class Solution {
public:
    bool repeatedSubstringPattern(string s) {
        string str, temp;
        for(int i = 0; i < s.size() - 1; i++) {
            str += s[i];
            temp = str;
            for(int j = 0; j < s.size(); j++) {
                if(temp.size() > s.size()) break;
                if(temp != s) {
                    temp += str;
                } else {
                    return true;
                }
            }
        }
        return false;
    }
};