TypeScript算法题实战——字符串篇（字符串的反转、旋转、查询、KMP算法）_typescript 算法

字符串的操作是算法题当中经常碰见的一类题目，主要考察对string类型的处理和运用，对字符串的翻转、反复、旋转、替换、查询、KMP查找子串等都是很经典的题目。

本系列博文将通过一些力扣算法题目，边学习TypeScipt边实战算法，这篇将通过一些经典算法题熟悉TS语言哈希表的一些基本操作。（部分算法思想参考于程序员Carl:代码随想录）

目录

• 零、常用库函数
• 一、反转字符串 II
• • 1.1、题目描述
  • 1.2、示例
  • 1.3、题解
• 二、反转字符串中的单词
• • 2.1、题目描述
  • 2.2、示例
  • 2.3、题解
• 三、找出字符串中第一个匹配项的下标
• • 3.1、题目描述
  • 3.2、示例
  • 3.3、题解
• 最后

零、常用库函数

1：join()和split()
join()将数组转换成字符串，是关于数组的方法;
split()将字符串切割成数组，是关于字符串的方法;
split()把一个字符串(根据某个分隔符字符串)切割成若干个字符串并存放在一个数组里。而join()把数组中的字符串连成一个长串， 可以认为它是split()的逆操作。
如 剑指 Offer 05. 替换空格:

let s:string = "abcdefg"
function replaceSpace(s: string): string {
    let arr: string[] = s.split(" ");
    return arr.join("%20");
};
1
2
3
4
5

一、反转字符串 II

1.1、题目描述

力扣链接：https://leetcode.cn/problems/reverse-string-ii/

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

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

1.2、示例

1.3、题解

将题目视作为多个长度为2k的子字符串，最后一位另外单独考虑，那么外循环可以设置为i = i + 2k，这样的话每次单独处理子串就好了，翻转可以设置两个指针。

function reverseStr(s: string, k: number): string {
    let tmp: string;
    let left: number;
    let right: number;
    let arr: string[] = s.split("")
    for(let i: number = 0; i < arr.length; i = i+ 2 * k){
        left = i;
        right = (i + k - 1) >= arr.length ? arr.length - 1 : i + k - 1;
        while(left < right){
            tmp = arr[left];
            arr[left] = arr[right];
            arr[right] = tmp;
            left ++;
            right --;
        }
    }
    return arr.join("");
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

二、反转字符串中的单词

2.1、题目描述

力扣链接：https://leetcode.cn/problems/reverse-words-in-a-string/
给你一个字符串 s ，请你反转字符串中 单词 的顺序。

单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。

返回 单词 顺序颠倒且 单词之间用单个空格连接的结果字符串。

注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格

2.2、示例

2.3、题解

很简单的思路是：使用split函数将原字符串拆成多个子字符串，但是子字符串里肯定有一些为’'的空字符串，设定一个额外的字符串数组，遍历原字符串数组，将有内容的存入新的字符串数组，空字符串跳过。
然后处理新的字符串数组，将其做反转就可以了。

function reverseWords(s: string): string {
    let arr: string[] = s.split(" ");
    let midarr: string[] = [];
    let index: number = 0;
    for(let i = 0; i < arr.length; i++){
        if(arr[i] != ''){
            midarr[index] = arr[i];
            index++;   
        }
    }
    for(let i = 0; i < midarr.length / 2; i++){
        let temp: string;
        temp = midarr[i];
        midarr[i] = midarr[length - i - 1];
        midarr[length - i - 1] = temp;
    }
    // console.log(midarr);
    return midarr.join(" ");
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

第二种方法，先删除多余的空格，再进行翻转

function reverseWords(s: string): string {
    let arr: string[] = s.split("");
    delExtraSpace(arr);
    function delExtraSpace(arr: string[]):void{
        let left: number = 0;
        let right: number = 0;
        while(arr[right] === ' ' && right < arr.length){
            right ++;
        }
        while(right < arr.length){
            if(arr[right] === ' ' && arr[right - 1] === ' '){
                right++;
                continue;
            }
            arr[left++] = arr[right++];
        }
        if(arr[left - 1] === ' ')
            arr.length = left -1;
        else
            arr.length = left;
    }

    let resarr: string[] = arr.join("").split(" ");
    for(let i:number = 0; i < resarr.length / 2; i++){
        let tmpstr: string = resarr[i]; 
        resarr[i] = resarr[resarr.length - 1 - i];
        resarr[resarr.length - 1 - i] = tmpstr;
    }
    return resarr.join(" ");
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

三、找出字符串中第一个匹配项的下标

3.1、题目描述

力扣链接：https://leetcode.cn/problems/find-the-index-of-the-first-occurrence-in-a-string/
给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回 -1 。

3.2、示例

3.3、题解

本题要使用KMP算法，不然会严重超时，KMP的经典思想就是:当出现字符串不匹配时，可以记录一部分之前已经匹配的文本内容，利用这些信息避免从头再去做匹配。KMP的主要是使用空间换时间。没有学过KMP的可以看：数据结构KMP算法配图详解（超详细）

KMP算法的总时间复杂度为O(m+n)，空间复杂度记为O(m)。相比于朴素的模式匹配时间复杂度O(m*n)，KMP算法提速是非常大的，这一点点空间消耗换得极高的时间提速是非常有意义的，这种思想也是很重要的。

首先设计一个函数计算next数组（前缀表统一减一），然后进行匹配：

function strStr(haystack: string, needle: string): number {
    function getNext(str: string): number[] {
        let next: number[] = [];
        let j: number = -1;
        next[0] = j;
        for (let i = 1, length = str.length; i < length; i++) {
            while (j >= 0 && str[i] !== str[j + 1]) {
                j = next[j];
            }
            if (str[i] === str[j + 1]) {
                j++;
            }
            next[i] = j;
        }
        return next;
    }

    if(needle.length === 0)
        return 0;
    let next: number[] = getNext(needle);
    // console.log(next);

    let j: number = -1;
    for(let i: number = 0; i < haystack.length; i++){
        while(j >= 0 && haystack[i] != needle[j + 1]){
            j = next[j];
        }
        if(haystack[i] === needle[j + 1]){
            if(j === needle.length - 2){
                return i - j - 1;
            }
            j++;
        }
    }
    return -1;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

最后