TypeScript算法题实战——字符串篇(字符串的反转、旋转、查询、KMP算法)

字符串的操作是算法题当中经常碰见的一类题目,主要考察对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");
};

一、反转字符串 II

1.1、题目描述

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

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

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

1.2、示例

TypeScript算法题实战——字符串篇(字符串的反转、旋转、查询、KMP算法)_第1张图片

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("");
};

二、反转字符串中的单词

2.1、题目描述

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

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

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

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

2.2、示例

TypeScript算法题实战——字符串篇(字符串的反转、旋转、查询、KMP算法)_第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(" ");
};

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

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(" ");
};

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

3.1、题目描述

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

3.2、示例

TypeScript算法题实战——字符串篇(字符串的反转、旋转、查询、KMP算法)_第3张图片

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

最后

个人简介:人工智能领域研究生,目前主攻文本生成图像(text to image)方向

关注我:中杯可乐多加冰

免费订阅:TypeScript实战

支持我:点赞+收藏⭐️+留言

你可能感兴趣的:(TypeScript实战,算法,typescript,leetcode,前端)