LeetCode题解字符串篇（TS版）

344.反转字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。

示例 1：
输入：[“h”,“e”,“l”,“l”,“o”]
输出：[“o”,“l”,“l”,“e”,“h”]

示例 2：
输入：[“H”,“a”,“n”,“n”,“a”,“h”]
输出：[“h”,“a”,“n”,“n”,“a”,“H”]

双指针

• 时间复杂度：$O(N)$，其中 $N$ 为字符数组的长度。一共执行了 $N/2$ 的交换。
• 空间复杂度：$O(1)$。 只使用了常数空间来存放若干变量。

/**
 Do not return anything, modify s in-place instead.
 */
function reverseString(s: string[]): void {
    let L = 0
    let R = s.length - 1;
    while (L < R) {
        const temp = s[L];
        s[L] = s[R];
        s[R] = temp;
        L++;
        R--;
    }
};

541.反转字符串Ⅱ

给定一个字符串 s 和一个整数 k，从字符串开头算起, 每计数至 2k 个字符，就反转这 2k 个字符中的前 k 个字符。

如果剩余字符少于 k 个，则将剩余字符全部反转。

如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。

示例:

输入: s = “abcdefg”, k = 2
输出: “bacdfeg”

模拟

• 时间复杂度：$O(n)$，其中n是字符串 $s$ 的长度。
• 空间复杂度：$O(1$）或 $O(n)$，取决于使用的语言中字符串类型的性质。如果字符串是可修改的，那么我们可以直接在原字符串上修改，空间复杂度为 $O(1)$，否则需要使用 $O(n)$ 的空间将字符串临时转换为可以修改的数据结构（例如数组），空间复杂度为 $O(n)$。

反转每个下标从 $2k$ 的倍数开始的，长度为 $k$ 的子串。若该子串长度不足 $k$，则反转整个子串。

function reverse(arr: string[], left: number, right: number) {
    while (left < right) {
        [arr[left], arr[right]] = [arr[right], arr[left]];
        left++;
        right--;
    }
}

function reverseStr(s: string, k: number): string {
    const arr = s.split('');
    for (let i = 0; i < arr.length; i += 2 * k) {
        reverse(arr, i, Math.min(i + k, arr.length) - 1);
    }
    return arr.join('');
};

05.替换空格

请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

示例 1：

输入：s = "We are happy."
输出："We%20are%20happy."

字符数组

• 时间复杂度：$O(N)$
• 空间复杂度：$O(N)$

function replaceSpace(s: string): string {
    let arr = [];
    for (let i of s) {
        if (i === " ") {
            arr.push("%20");
        } else {
            arr.push(i);
        }
    }
    return arr.join("");
};

151.反转字符串中的单词

给定一个字符串，逐个翻转字符串中的每个单词。

示例 1：

输入: "the sky is blue"
输出: "blue is sky the"

示例 2：

输入: "  hello world!  "
输出: "world! hello"
解释: 输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。

示例 3：

输入: "a good  example"
输出: "example good a"
解释: 如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。

语言特性

思路：很多语言对字符串提供了 split（拆分），reverse（翻转）和 join（连接）等方法，因此我们可以简单的调用内置的 API 完成操作：

• 使用 split 将字符串按空格分割成字符串数组；

• 使用 reverse 将字符串数组进行反转；

• 使用 join 方法将字符串数组拼成一个字符串。

复杂度分析：

• 时间复杂度：$O(n)$，其中 $n$ 为输入字符串的长度。
• 空间复杂度：$O(n)$，用来存储字符串分割之后的结果。

function reverseWords(s: string): string {
    return s.trim().split(/\s+/).reverse().join(" ");
};

双端队列

• 时间复杂度：$O(n)$，其中 $n$ 为输入字符串的长度。
• 空间复杂度：$O(n)$，双端队列存储单词需要 $O(n)$ 的空间。

function reverseWords(s: string): string {
    let left = 0;
    let right = s.length - 1;
    let queue: string[] = [];
    let temp: string[] = [];
    while (left <= right && s[left] === " ") left++;
    while (left <= right && s[right] === " ") right--;

    while (left <= right) {
        if (s[left] !== " ") {
            temp.push(s[left]);
        } else if (s[left] === " " && temp.length !== 0) {
            queue.unshift(temp.join(""));
            temp = [];
        }
        left++;
    }

    queue.unshift(temp.join(""));
    return queue.join(" ");
};

剑指 Offer 58 - II. 左旋转字符串

字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。

示例 1：

输入: s = "abcdefg", k = 2
输出: "cdefgab"

示例 2：

输入: s = "lrloseumgh", k = 6
输出: "umghlrlose"

字符串切片

• 时间复杂度：$O(N)$，$N$ 为字符串s的长度。
• 空间复杂度：$O(N)$，两个字符串切片的总长度为 $N$。

function reverseLeftWords(s: string, n: number): string {
    return s.slice(n) + s.slice(0, n)
};

列表遍历拼接

• 时间复杂度：$O(N)$，线性遍历 $s$ 并添加。
• 空间复杂度：$O(N)$，新建的辅助 $arr$ 使用 $O(N)$ 大小的额外空间。

function reverseLeftWords(s: string, n: number): string {
    const arr: string[] = [];
    for (let i = n; i < s.length; i++) {
        arr.push(s[i]);
    }
    for (let i = 0; i < n; i++) {
        arr.push(s[i]);
    }
    return arr.join("");
};

28.找出字符串中第一个匹配项的下标

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回 -1 。

示例 1：

输入：haystack = "sadbutsad", needle = "sad"
输出：0
解释："sad" 在下标 0 和 6 处匹配。
第一个匹配项的下标是 0 ，所以返回 0 。

示例 2：

输入：haystack = "leetcode", needle = "leeto"
输出：-1
解释："leeto" 没有在 "leetcode" 中出现，所以返回 -1 。

提示：

• 1 <= haystack.length, needle.length <= 104
• haystack 和 needle 仅由小写英文字符组成

暴力匹配

我们可以让字符串 needle 与字符串 haystack 的所有长度为 $m$ 的子串均匹配一次。

为了减少不必要的匹配，我们每次匹配失败即立刻停止当前子串的匹配，对下一个子串继续匹配。如果当前子串匹配成功，我们返回当前子串的开始位置即可。如果所有子串都匹配失败，则返回 -1。

• 时间复杂度：$O(m\ast n)$。
• 空间复杂度：$O(1)$。

function strStr(haystack: string, needle: string): number {
    for (let i = 0; i < haystack.length; i++) {
        let a = i;
        let b = 0;
        if (haystack[i] === needle[b]) {
            while (b < needle.length && haystack[a] === needle[b]) {
                a++;
                b++;
            }
            if (b === needle.length) {
                return i;
            }
        }
    }
    return -1;
};

KMP

KMP算法是一种改进的字符串匹配算法，避免了朴素算法中不必要的字符比较，提高了匹配效率。它的主要思想是当出现字符比较不匹配时，可以记录一部分之前已经匹配的文本内容，利用这些信息使得下一步的搜索更加快捷。

• 时间复杂度：$O(m+n)$。
• 空间复杂度：$O(m)$，其中 $m$ 是字符串 needle 的长度。

思路：

1. 初始化next数组，并且开始填充它。这个过程就是在计算needle中每个位置的前缀和后缀的最长公共长度。
2. 接下来，函数开始在haystack中查找needle。它从haystack的第一个字符开始，同时也从needle的第一个字符开始。每当找到一个匹配的字符，就将needle的当前位置向前移动一位（即j++）。如果在某个位置找不到匹配的字符，就回溯到needle的某个较早位置（即设置j为next[j - 1]），然后再从那里开始比较。这就是利用next数组进行快速跳跃的关键步骤。
3. 如果在某个位置找到了整个needle（即j等于needle的长度），那么函数就返回这个位置（即返回i - m + 1，其中m是needle的长度）。
4. 如果遍历了整个haystack都没有找到needle，那么函数就返回-1。

function strStr(haystack: string, needle: string): number {
    let n = haystack.length, m = needle.length;
    if (m === 0) return 0;
    let next = new Array(m).fill(0);
    // 构建前缀表
    for (let i = 1, j = 0; i < m; i++) {
        while (j > 0 && needle[i] !== needle[j]) {
            j = next[j - 1];
        }
        if (needle[i] === needle[j]) {
            j++;
        }
        next[i] = j;
    }
    for (let i = 0, j = 0; i < n; i++) {
        while (j > 0 && haystack[i] !== needle[j]) {
            j = next[j - 1];
        }
        if (haystack[i] === needle[j]) {
            j++;
        }
        if (j === m) {
            return i - m + 1;
        }
    }
    return -1;
};

459.重复的子字符串

给定一个非空的字符串，判断它是否可以由它的一个子串重复多次构成。给定的字符串只含有小写英文字母，并且长度不超过10000。

示例 1:
输入: “abab”
输出: True
解释: 可由子字符串 “ab” 重复两次构成。

示例 2:
输入: “aba”
输出: False

示例 3:
输入: “abcabcabcabc”
输出: True
解释: 可由子字符串 “abc” 重复四次构成。 (或者子字符串 “abcabc” 重复两次构成。)

双倍长度字符串

思路：

1. 将原始字符串 s 复制并连接到自身，形成 s + s，其长度为原始字符串的两倍。
2. 移除新字符串的第一个和最后一个字符，也就是执行 .slice(1, -1) 操作。
3. 在这个新生成的字符串中搜索原始字符串 s。如果找到了（即 indexOf(s) 的结果不为 -1），那么原始字符串 s 包含重复的子字符串。如果没有找到，那么 s 不存在重复的子字符串。

function repeatedSubstringPattern(s: string): boolean {
    return (s+s).slice(1, -1).indexOf(s) !== -1;
};

KMP

方法一中使用了语言自带的查找函数indexOf。同样我们也可以自己实现这个函数，例如使用比较经典的KMP算法。

// KMP算法
function kmp(str: string, substr: string) {
    let n = str.length, m = substr.length;
    let next: number[] = new Array(m).fill(0);
    for (let i = 1, j = 0; i < m; i++) {
        while (j > 0 && substr[i] !== substr[j]) {
            j = next[j - 1];
        }
        if (substr[i] === substr[j]) {
            j++;
        }
        next[i] = j;
    }
    for (let i = 0, j = 0; i < n; i++) {
        while (j > 0 && str[i] !== substr[j]) {
            j = next[j - 1];
        }
        if (str[i] === substr[j]) {
            j++;
        }
        if (j === m) {
            return i - m + 1;
        }
    }
    return -1;
}

function repeatedSubstringPattern(s: string): boolean {
    return kmp((s+s).slice(1, -1), s) !== -1;
};