【笔记】字符串

原创已于 2022-12-09 12:21:03 修改 · 538 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #leetcode #数据结构

于 2022-12-09 12:03:04 首次发布

刷题总结专栏收录该内容

11 篇文章

订阅专栏

本系列总计六篇文章，是基于STL实现的笔试题常考七大基本数据结构该文章在《代码随想录》和《labuladong的算法笔记》题目中的具体实践，每篇的布局是这样的：开头是该数据结构的总结，然后是在不同场景的应用，以及不同的算法技巧。本文是系列第四篇，介绍了字符串的相关题目，重点是要掌握快慢、左右双指针算法，滑动窗口算法（与哈希表结合），KMP算法。

下面文章是在《代码随想录》和《labuladong的算法笔记》题目中的具体实践：
【笔记】数组
 【笔记】链表
 【笔记】哈希表
 【笔记】字符串
 【笔记】栈与队列
 【笔记】二叉树

0、总结

双指针（头尾、快慢、滑动窗口、KMP）
涉及反转的，巧用库函数和迭代器，亦可自己定义reverse
string是字符串版本的vector，重载了+以拼接字符
KMP算法

1、普通双指针

344. 反转字符串 - 力扣（LeetCode）

两个思路：

库函数+迭代器
双指针，自写reverse+swap

class Solution {
public:
    void reverseString(vector<char>& s) {
        if (s.size() == 0) return;
        for (int i = 0, j = s.size() - 1; i < j; i++, j--) {
            swap(s[i], s[j]);
        }
        return;
    }
};

541. 反转字符串 II - 力扣（LeetCode）

【思路很巧妙】

思路：

每次遍历时只要让 i += (2 * k) 就可以了，然后判断是否需要有反转的区间，这样子每次i更新完都是需要翻转的区间起点

class Solution {
public:
    string reverseStr(string s, int k) {
        if (s.size() == 0) return "";
        // 遍历时只要让 i += (2 * k) 就可以了，然后判断是否需要有反转的区间，每次都是区间起点
        for (int i = 0; i < s.size(); i += 2 * k) {
            // 剩余字符小于2k个，但大于等于k个，反转前k个
            if (i + k < s.size()) {
                reverse(s.begin() + i, s.begin() + i + k);
            } 
            // 剩余字符少于k个，全部反转
            else if (i + k >= s.size()) {
                reverse(s.begin() + i, s.end());
            }
        }
        return s;
    }
};

剑指 Offer 05. 替换空格 - 力扣（LeetCode）

思路：

先遍历一遍，记录空格数并且扩容，然后 双指针 从后向前，原地填充

若从前向后原地填充，每次更新元素都要将后面所有元素后移，时间复杂度O(n2)

若开辟新空间用于填充，则有额外O(n)空间开销

class Solution {
public:
    string replaceSpace(string s) {
        if (s.size() == 0) return "";
        int oldSize = s.size();
        // 先扩容
        int num = 0;
        for (char c : s) {
            if (c == ' ') num++;
        }
        s.resize(oldSize + num * 2);
        // 双指针原地从后向前填充
        for (int i = oldSize - 1, j = s.size() - 1; i >= 0; i--, j--) {
            if (s[i] != ' ') {
                s[j] = s[i];
            }
            else {
                s[j] = '0';
                s[j - 1] = '2';
                s[j - 2] = '%';
                j -= 2;
            }
        }
        return s;
    }
};

151. 反转字符串中的单词 - 力扣（LeetCode）

【相当的好题】

思路：

三步走，先用 双指针 去除开头、中间、结尾处多余的括号，这一步是难点

然后，翻转整个字符串

最后，再反转每个单词

class Solution {
public:
    string reverseWords(string s) {
        removeBlankspace(s);
        reverse(s, 0, s.size() - 1);
        int start = 0;
        for (int i = 0; i <= s.size(); i++) {
            // 每逢单词结束或字符串结束，才反转
            if (i == s.size() || s[i] == ' ') {
                reverse(s, start, i - 1);
                start = i + 1;
            }
        }
        return s;
    }
    void reverse(string& s, int start, int end){ //翻转，区间写法：左闭又闭
        for (int i = start, j = end; i < j; i++, j--) {
            swap(s[i], s[j]);
        }
    }
    // 双指针去除多余前、后空格，保证每个单词中间只有一个空格
    void removeBlankspace(string& s) {
        // 确定初始位置
        int slow = 0;
        for (int i = 0; i < s.size(); ++i) {
            // s[i]不为空时才处理，这就保证了去除多余前、后空格
            if (s[i] != ' ') {
                // slow已经记录至少一个单词，在记录下一个单词时，需要补充空格
                // 这就保证每个单词中间只有一个空格
                if (slow != 0) s[slow++] = ' ';
                // 将非空的字符串覆盖到前面来
                while (i < s.size() && s[i] != ' ') {
                    s[slow++] = s[i++];
                }
            }
        }
        // 返回实际长度
        s.resize(slow);
    }
};

剑指 Offer 58 - II. 左旋转字符串 - 力扣（LeetCode）

思路：

两次局部反转 + 一次全局翻转，reverse中传递引用，因为要修改s

class Solution {
public:
    string reverseLeftWords(string s, int n) {
        if (s.size() == 1) return s;
        reverse(s, 0, n - 1);
        reverse(s, n, s.size() - 1);
        reverse(s, 0, s.size() - 1);
        return s;
    }
    void reverse(string& s, int start, int end) {
        for (int i = start, j = end; i < j; ++i, --j) {
            swap(s[i], s[j]);
        }
    }
};

2、滑动窗口（双指针），全面总结见数组笔记

3. 无重复字符的最长子串 - 力扣（LeetCode）

思路：

双指针 的最难版本，滑动窗口

辅助数据结构用unordered_map，map内始终维护着不重复的子串

未遇到重复元素，right++不断扩大窗口，若map中出现重复元素，left++减小窗口直到重复元素被删除

扩大窗口和缩小窗口的操作对称

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        if (s.size() == 0) return 0;
        unordered_map<char, int> window;
        // 双指针
        int left = 0, right = 0;
        int result = 0;
        while (right < s.size()) {
            // 未遇到重复字符串就一直加，right右移
            char c = s[right];
            right++;    
            window[c]++;
            // 有重复left左移直到删除该重复的字符串
            while (window[c] > 1) {
                char d = s[left];
                left++;
                window[d]--;
            }
            // 收缩完后肯定剩下不重复的字串，记录长度
            result = max(result, right - left);
        }
        return result;
    }
};

3、KMP算法，还算双指针

KMP勉强算是双指针的另一种应用，主要思想是 当出现字符串不匹配时，可以知道一部分之前已经匹配的文本内容，可以利用这些信息避免从头再去做匹配了 ，关键是求前缀表next数组，其中 包含起始位置到下标i之前（包括i）的子串中，有多大长度的相同前缀后缀 ，也可以理解为回退的位置

前缀是指不包含最后一个字符的所有以第一个字符开头的连续子串。

后缀是指不包含第一个字符的所有以最后一个字符结尾的连续子串。

KMP算法主要解决匹配问题和重复字串问题

28. 找出字符串中第一个匹配项的下标 - 力扣（LeetCode）

思路：先根据模式串构造next数组，再根据next数组，比较文本串和模式串

其实是手动实现C语言中的strstr()函数

C 库函数 char *strstr(const char *haystack, const char *needle) 在字符串 haystack 中查找第一次出现字符串 needle 的位置，不包含终止符 ‘\0’。

class Solution {
public:
    // const&防止传值时拷贝构造函数的调用开销，即不希望改变、不希望拷贝
    void getNext(int* next, string s) {
        // 双指针，j指向前缀末尾位置，i指向后缀开头位置
        int j = 0;
        next[0] = j;
        // 后缀定义不包含首元素，从下标1开始
        for (int i = 1; i < s.size(); ++i) {
            // 不匹配时，一直后退到匹配
            while (j > 0 && s[i] != s[j]) { // j必须大于0，因为后面要-1
                j = next[j - 1];
            }
            // 匹配时，累加公共前后缀串长度，i、j后移
            if (s[i] == s[j]) {
                ++j;
            }
            // next记录相同前后缀的长度
            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; // 与next[0]初始值相同
        for (int i = 0; i < haystack.size(); ++i) {
            // 利用next数组进行匹配
            while (j > 0 && haystack[i] != needle[j]) {
                j = next[j - 1];
            }
            if (haystack[i] == needle[j]) {
                ++j;
            }
            // needle全部被匹配了，返回其在haystack中下标
            if (j == needle.size()) return (i - j + 1);
        }
        return -1;
    }
};

459. 重复的子字符串 - 力扣（LeetCode）

KMP解法思路：next数组中本就是存储着最长相等前后缀长度。如果打印出next数组，会发现，如果s由若干t组成，next中的最后一个元素的值，也是最长相等前后缀长度，一定与s串相差一个循环单位t的长度。可利用这点，先构造next数组，然后进行判断

class Solution {
public:
    void getNext(int* next, string s) {
        int j = 0;
        next[0] = j;
        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) {
        int next[s.size()];
        getNext(next, s);
        // next[s.size() - 1] != 0说明有最长相同的前后缀，且与s差一个循环单位长度
        if (next[s.size() - 1] != 0 && s.size() % (s.size() - next[s.size() - 1]) == 0) return true;
        return false;
    }
};

移动匹配思路：若s由若干t组成，那么拼接后的s+s，不算头尾，必定能在中间段找出s。以此进行判断。用到了重载运算符+，用到了库函数erase，find，用到了迭代器，用到了size_t最大值string::npos

class Solution {
public:
    bool repeatedSubstringPattern(string s) {
        string t = s + s;
        t.erase(t.begin());
        t.erase(t.end() - 1);
        if (t.find(s) != string::npos) return true;
        return false;
    }
};