代码随想录-4 字符串 刷题记录

最新推荐文章于 2024-09-14 18:46:05 发布
最新推荐文章于 2024-09-14 18:46:05 发布
阅读量1.5k 收藏 32
点赞数 35
文章标签： java 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Renas_TJOvO/article/details/141059244
版权

1.反转字符串

344反转字符串

class Solution {
    public void reverseString(char[] s) {
        int left = 0;
        int right = s.length -1;
        while(left < right){
            char tmp = s[left];
            s[left] = s[right];
            s[right] = tmp;
            left++;
            right--;
        }
    }
}

2.541.反转字符串II

使用模拟的方法

class Solution {
    public String reverseStr(String s, int k) {
        char[] ch = s.toCharArray();
        for(int i=0; i<ch.length;i += 2*k){
            int left = i;
            int right = Math.min(left + k - 1, ch.length - 1);
            while(left < right){
                char tmp = ch[left];
                ch[left]=ch[right];
                ch[right]=tmp;
                left++;
                right--;
            }
        }
        return new String(ch);
    }
}

3.54替换数字

本题如果使用C++，可以使用预先扩充数组的方法

很多数组填充类的问题，其做法都是先预先给数组扩容带填充后的大小，然后在从后向前进行操作。

这么做有两个好处：

  1. 不用申请新数组。
  2. 从后向前填充元素，避免了从前向后填充元素时，每次添加元素都要将添加元素之后的所有元素向后移动的问题。

#include <iostream>
using namespace std;
int main() {
    string s;
    while (cin >> s) {
        int sOldIndex = s.size() - 1;
        int count = 0; // 统计数字的个数
        for (int i = 0; i < s.size(); i++) {
            if (s[i] >= '0' && s[i] <= '9') {
                count++;
            }
        }
        // 扩充字符串s的大小，也就是将每个数字替换成"number"之后的大小
        s.resize(s.size() + count * 5);
        int sNewIndex = s.size() - 1;
        // 从后往前将数字替换为"number"
        while (sOldIndex >= 0) {
            if (s[sOldIndex] >= '0' && s[sOldIndex] <= '9') {
                s[sNewIndex--] = 'r';
                s[sNewIndex--] = 'e';
                s[sNewIndex--] = 'b';
                s[sNewIndex--] = 'm';
                s[sNewIndex--] = 'u';
                s[sNewIndex--] = 'n';
            } else {
                s[sNewIndex--] = s[sOldIndex];
            }
            sOldIndex--;
        }
        cout << s << endl;       
    }
}

4.151.反转字符串里的单词

方法一：

（1）使用trim 去掉多余的空白符

（2）使用split结合正则表达式拆分字符串，得到字符串数组

（3）倒序相加

class Solution {
    public String reverseWords(String s) {
        String[] words= s.trim().split("\\s+");
        StringBuffer res = new StringBuffer();
        for(int i=words.length-1; i>=0; i--){
            res.append(words[i]);
            if(i>0) res.append(" ");
        }
        return res.toString();
    }
}

方法二：尝试使用 O(1) 额外空间复杂度的 原地 解法。

解题思路如下：

  • 移除多余空格
  • 将整个字符串反转
  • 将每个单词反转
class Solution {
   /**
     * 不使用Java内置方法实现
     * <p>
     * 1.去除首尾以及中间多余空格
     * 2.反转整个字符串
     * 3.反转各个单词
     */
    public String reverseWords(String s) {
        // System.out.println("ReverseWords.reverseWords2() called with: s = [" + s + "]");
        // 1.去除首尾以及中间多余空格
        StringBuilder sb = removeSpace(s);
        // 2.反转整个字符串
        reverseString(sb, 0, sb.length() - 1);
        // 3.反转各个单词
        reverseEachWord(sb);
        return sb.toString();
    }

    private StringBuilder removeSpace(String s) {
        // System.out.println("ReverseWords.removeSpace() called with: s = [" + s + "]");
        int start = 0;
        int end = s.length() - 1;
        while (s.charAt(start) == ' ') start++;
        while (s.charAt(end) == ' ') end--;
        StringBuilder sb = new StringBuilder();
        while (start <= end) {
            char c = s.charAt(start);
            if (c != ' ' || sb.charAt(sb.length() - 1) != ' ') {
                sb.append(c);
            }
            start++;
        }
        // System.out.println("ReverseWords.removeSpace returned: sb = [" + sb + "]");
        return sb;
    }

    /**
     * 反转字符串指定区间[start, end]的字符
     */
    public void reverseString(StringBuilder sb, int start, int end) {
        // System.out.println("ReverseWords.reverseString() called with: sb = [" + sb + "], start = [" + start + "], end = [" + end + "]");
        while (start < end) {
            char temp = sb.charAt(start);
            sb.setCharAt(start, sb.charAt(end));
            sb.setCharAt(end, temp);
            start++;
            end--;
        }
        // System.out.println("ReverseWords.reverseString returned: sb = [" + sb + "]");
    }

    private void reverseEachWord(StringBuilder sb) {
        int start = 0;
        int end = 1;
        int n = sb.length();
        while (start < n) {
            while (end < n && sb.charAt(end) != ' ') {
                end++;
            }
            reverseString(sb, start, end - 1);
            start = end + 1;
            end = start + 1;
        }
    }
}

5.右旋字符串

为了让本题更有意义，提升一下本题难度：不能申请额外空间，只能在本串上操作。 （Java不能在字符串上修改，所以使用java一定要开辟新空间）

// 版本一
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = Integer.parseInt(in.nextLine());
        String s = in.nextLine();

        int len = s.length();  //获取字符串长度
        char[] chars = s.toCharArray();
        reverseString(chars, 0, len - 1);  //反转整个字符串
        reverseString(chars, 0, n - 1);  //反转前一段字符串，此时的字符串首尾尾是0,n - 1
        reverseString(chars, n, len - 1);  //反转后一段字符串，此时的字符串首尾尾是n,len - 1
        
        System.out.println(chars);

    }

    public static void reverseString(char[] ch, int start, int end) {
        //异或法反转字符串，参照题目 344.反转字符串的解释
        while (start < end) {
            ch[start] ^= ch[end];
            ch[end] ^= ch[start];
            ch[start] ^= ch[end];
            start++;
            end--;
        }
    }
}


// 版本二
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = Integer.parseInt(in.nextLine());
        String s = in.nextLine();

        int len = s.length();  //获取字符串长度
        char[] chars = s.toCharArray();
        reverseString(chars, 0, len - n - 1);  //反转前一段字符串，此时的字符串首尾是0,len - n - 1
        reverseString(chars, len - n, len - 1);  //反转后一段字符串，此时的字符串首尾是len - n,len - 1
        reverseString(chars, 0, len - 1);  //反转整个字符串

        System.out.println(chars);

    }

    public static void reverseString(char[] ch, int start, int end) {
        //异或法反转字符串，参照题目 344.反转字符串的解释
        while (start < end) {
            ch[start] ^= ch[end];
            ch[end] ^= ch[start];
            ch[start] ^= ch[end];
            start++;
            end--;
        }
    }
}

6.KMP

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

KMP有什么用

KMP主要应用在字符串匹配上。

KMP的主要思想是当出现字符串不匹配时，可以知道一部分之前已经匹配的文本内容，可以利用这些信息避免从头再去做匹配了。

什么是前缀表

next数组就是一个前缀表（prefix table）。

前缀表有什么作用呢？

前缀表是用来回退的，它记录了模式串与主串(文本串)不匹配的时候，模式串应该从哪里开始重新匹配。

(如果不使用前缀表，则是暴力解法，当模式串中间的某个字母不匹配时，模式串回退到开头，主串回退对应个数字母，主串向后挪一个继续尝试匹配。但是使用前缀表，就可以让主串在不回退的情况下找到模式串应当回退的位置，即最长公共前后缀）

前缀表是如何记录的呢？

首先要知道前缀表的任务是当前位置匹配失败，找到之前已经匹配上的位置，再重新匹配，此也意味着在某个字符失配时，前缀表会告诉你下一步匹配中，模式串应该跳到哪个位置。

那么什么是前缀表：记录下标i之前（包括i）的字符串中，有多大长度的相同前缀后缀。

最长公共前后缀

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

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

正确理解什么是前缀什么是后缀很重要!

那么网上清一色都说 “kmp 最长公共前后缀” 又是什么回事呢？

我查了一遍 算法导论 和 算法4里KMP的章节，都没有提到 “最长公共前后缀”这个词，也不知道从哪里来了，我理解是用“最长相等前后缀” 更准确一些。

因为前缀表要求的就是相同前后缀的长度。

而最长公共前后缀里面的“公共”，更像是说前缀和后缀公共的长度。这其实并不是前缀表所需要的。

所以字符串a的最长相等前后缀为0。 字符串aa的最长相等前后缀为1。 字符串aaa的最长相等前后缀为2。 等等.....。

为什么一定要用前缀表

为啥前缀表就能告诉我们 上次匹配的位置，并跳过去呢？

回顾一下，刚刚匹配的过程在下标5的地方遇到不匹配，模式串是指向f，如图： 

KMP精讲1

然后就找到了下标2，指向b，继续匹配：如图： 

KMP精讲2

以下这句话，对于理解为什么使用前缀表可以告诉我们匹配失败之后跳到哪里重新匹配 非常重要！

下标5之前这部分的字符串（也就是字符串aabaa）的最长相等的前缀 和 后缀字符串是 子字符串aa ，因为找到了最长相等的前缀和后缀，匹配失败的位置是后缀子串的后面，那么我们找到与其相同的前缀的后面重新匹配就可以了。

如何计算前缀表

模式串与前缀表对应位置的数字表示的就是：下标i之前（包括i）的字符串中，有多大长度的相同前缀后缀。

前缀表与next数组

很多KMP算法的实现都是使用next数组来做回退操作，那么next数组与前缀表有什么关系呢？

next数组就可以是前缀表，但是很多实现都是把前缀表统一减一（右移一位，初始位置为-1）之后作为next数组。

为什么这么做呢，其实也是很多文章视频没有解释清楚的地方。

其实这并不涉及到KMP的原理，而是具体实现，next数组既可以就是前缀表，也可以是前缀表统一减一（右移一位，初始位置为-1）。

后面我会提供两种不同的实现代码

时间复杂度分析

其中n为文本串长度，m为模式串长度，因为在匹配的过程中，根据前缀表不断调整匹配的位置，可以看出匹配的过程是O(n)，之前还要单独生成next数组，时间复杂度是O(m)。所以整个KMP算法的时间复杂度是O(n+m)的。

暴力的解法显而易见是O(n × m)，所以KMP在字符串匹配中极大地提高了搜索的效率。

构造next数组

我们定义一个函数getNext来构建next数组，函数参数为指向next数组的指针，和一个字符串。 代码如下：

void getNext(int* next, const string& s)

构造next数组其实就是计算模式串s，前缀表的过程。 主要有如下三步：

  1. 初始化
  2. 处理前后缀不相同的情况
  3. 处理前后缀相同的情况

接下来我们详解一下。

  1. 初始化：

定义两个指针i和j，j指向前缀末尾位置，i指向后缀末尾位置。

然后还要对next数组进行初始化赋值，如下：

int j = -1;
next[0] = j;

j 为什么要初始化为 -1呢，因为之前说过 前缀表要统一减一的操作仅仅是其中的一种实现，我们这里选择j初始化为-1，下文我还会给出j不初始化为-1的实现代码。

next[i] 表示 i（包括i）之前最长相等的前后缀长度（其实就是j）

所以初始化next[0] = j 。

        2.处理前后缀不相同的情况

因为j初始化为-1，那么i就从1开始，进行s[i] 与 s[j+1]的比较。

所以遍历模式串s的循环下标i 要从 1开始，代码如下：

for (int i = 1; i < s.size(); i++) {

如果 s[i] 与 s[j+1]不相同，也就是遇到 前后缀末尾不相同的情况，就要向前回退。

怎么回退呢？

next[j]就是记录着j（包括j）之前的子串的相同前后缀的长度。

那么 s[i] 与 s[j+1] 不相同，就要找 j+1前一个元素在next数组里的值（就是next[j]）。

所以，处理前后缀不相同的情况代码如下：

while (j >= 0 && s[i] != s[j + 1]) { // 前后缀不相同了
    j = next[j]; // 向前回退
}

        3.处理前后缀相同的情况

如果 s[i] 与 s[j + 1] 相同，那么就同时向后移动i 和j 说明找到了相同的前后缀，同时还要将j（前缀的长度）赋给next[i], 因为next[i]要记录相同前后缀的长度。

代码如下：

if (s[i] == s[j + 1]) { // 找到相同的前后缀
    j++;
}
next[i] = j;

最后整体构建next数组的函数代码如下：

void getNext(int* next, const string& s){
    int j = -1;
    next[0] = j;
    for(int i = 1; i < s.size(); i++) { // 注意i从1开始
        while (j >= 0 && s[i] != s[j + 1]) { // 前后缀不相同了
            j = next[j]; // 向前回退
        }
        if (s[i] == s[j + 1]) { // 找到相同的前后缀
            j++;
        }
        next[i] = j; // 将j（前缀的长度）赋给next[i]
    }
}
class Solution {
    public int strStr(String haystack, String needle) {
        int nlen = needle.length();
        int hlen = haystack.length();
        if(nlen==0) return -1;

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

       
    }

    public int[] getNext(String s){
        int len = s.length();
        int[] next = new int[len];

        int j=-1;
        next[0]=j;

        for(int i=1; i<len ; i++){
            while(j>=0 && s.charAt(i)!=s.charAt(j+1)){
                j=next[j];
            }
            if(s.charAt(i)==s.charAt(j+1)){
                j++;
            }
            next[i]=j;
        }
        return next;
    }
}

7.459.重复的子字符串

方法一：

如果一个字符串能够由重复子字符串组成，那么两个它之间一定能找到它（循环移位若干次后还是它）

结合库函数

class Solution {
    public boolean repeatedSubstringPattern(String s) {
        String str = s+s;
        if(str.substring(1,str.length()-1).contains(s)) return true;
        return false;
    }
}

方法二：KMP

在由重复子串组成的字符串中，最长相等前后缀不包含的子串就是最小重复子串

class Solution {
    public boolean repeatedSubstringPattern(String s) {
        if (s.equals("")) return false;

        int len = s.length();
        // 原串加个空格(哨兵)，使下标从1开始，这样j从0开始，也不用初始化了
        s = " " + s;
        char[] chars = s.toCharArray();
        int[] next = new int[len + 1];

        // 构造 next 数组过程，j从0开始(空格)，i从2开始
        for (int i = 2, j = 0; i <= len; i++) {
            // 匹配不成功，j回到前一位置 next 数组所对应的值
            while (j > 0 && chars[i] != chars[j + 1]) j = next[j];
            // 匹配成功，j往后移
            if (chars[i] == chars[j + 1]) j++;
            // 更新 next 数组的值
            next[i] = j;
        }

        // 最后判断是否是重复的子字符串，这里 next[len] 即代表next数组末尾的值
        if (next[len] > 0 && len % (len - next[len]) == 0) {
            return true;
        }
        return false;
    }
}

总结

字符串类类型的题目，往往想法比较简单，但是实现起来并不容易，复杂的字符串题目非常考验对代码的掌控能力。

双指针法是字符串处理的常客。

KMP算法是字符串查找最重要的算法。

Renas_TJOvO
关注
代码随想录-5 双指针法 刷题记录
Renas_TJOvO的博客
08-11 1131
双指针法并不隶属于某一种数据结构，我们在讲解数组，链表，字符串都用到了双指针法，所有有必要针对双指针法做一个总结。本文中一共介绍了leetcode上九道使用双指针解决问题的经典题目，除了链表一些题目一定要使用双指针，其他题目都是使用双指针来提高效率，一般是将O(n^2)的时间复杂度，降为 $O(n)$
代码随想录刷题4--字符串
m0_46254725的博客
03-29 957
第四部分字符串
代码随想录——字符串 刷题记录
qq_43541423的博客
01-11 446
交换，没有难点注意题干是“每2k”次，所以要有循环在对剩余的处理中，要先检查每次的剩余数量，包括第一次，所以应该先计算剩余多少决定怎么交换，如果剩余多余2k再进行前k的交换。
回溯算法-代码随想录-组合问题-刷题笔记
Coderwind的博客
05-09 403
回溯算法-代码随想录-组合问题-刷题笔记
代码随想录刷题记录 4 - 字符串
Neromy
09-08 237
leetcode 字符串题目刷题记录，KMP板子。
代码随想录-6 刷题记录 栈与队列
Renas_TJOvO的博客
08-12 1212
如果使用大顶堆，则需要维护所有元素到堆中。
代码随想录-八股刷题（随时更新）
weixin_48485132的博客
07-23 536
GET请求和POST请求的区别HTTP请求中常见的状态码什么是强缓存和协商缓存HTTP1.0和HTTP1.1的区别HTTP2.0与HTTP1.1的区别?Java的集合类有哪些，那些是线程安全的，那些是线程不安全的 ArrayList和Array有什么区别?ArrayList 和LinkedList的区别是什么?HashMap的底层实现是什么?如何查看某个端口有没有被占用 说- -下select、poll、 epoll 一条SQL查询语句 是如何执行的?Redis是单线程的还是多线程的，为什么?
代码随想录刷题记录：字符串篇
qq_53324833的博客
01-24 512
前言 字符串篇啦！ 344. 反转字符串 题目描述： 思路描述： 之前其实说过，一般情况下对于数据的线性操作我们都可以采用多指针法来做（一般双指针即可），本题一样，我们使用一个left指向最左边，一个right指向最右边，然后我们从两边往中间进行遍历，每遍历一个就进行一次交换即可。 代码如下： class Solution { public void reverseString(char[] s) { //双指针法 int left = 0; int
代码随想录+力扣刷题记录+华为机考准备记录
LiangManqi0320的博客
05-16 1192
为了准备华为机考的刷题记录（不全）（已挂，春招再战）为了准备华为机考的刷题记录（不全）（已挂，春招再战）
代码随想录刷题——组合问题专题篇
qq_35754976的博客
04-09 919
博主个人博客网站：文客 这个系列主要记录着对于代码随想录上面题目的题解和理解 如果你想每天和我一起刷题，可以关注一下我的个人博客网站：文客，我会每天在这里更新技术文章和面试题，也会及时收到大家的评论与留言，欢迎各位大佬来交流！ 77.组合 给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。 你可以按 任何顺序 返回答案。 示例 1： 输入：n = 4, k = 2 输出： [ [2,4], [3,4], [2,3], [1,2], [1,3], [1,4
LeetCode刷题记录---二叉树专题
weixin_43646592的博客
10-12 334
每次刷到二叉树算法题将在此博文更新~~~ 起个模版即将开刷二叉树专题???? ????题目： 难度 题目 中等 哈哈 ⭐哈哈：
LeetCode刷题记录---动态规划（DP）算法
weixin_43646592的博客
08-10 804
 动态规划算法把待求解问题分成若干子问题，然后从这些子问题的可行解一步步递推到最优解。通常用于求解具有某种最优性质的问题。 按照网上大佬总结的，通常有如下5步：  1.确定dp数组以及下标的含义。  2.确定递推公式。  3.dp数组如何初始化。（有时候初始化非常关键）  4.确定遍历顺序。（即for循环的顺序，这个也是蛮讲究的）  5.举例推导dp数组。（也就是程序不对的时候，自己推导看看和代码打印的dp数组有啥不同） ⭐直接看下面题目的简单难度的几道，就能大概的了解DP的思想。 ⭐⭐⭐看背包变种题目之前
2021.5.21开始的兔系刷题之路 根据LeetCode分类进行逐个击破 培养出自己的套路~
一碗菜粥的博客
05-19 2034
从前辈们的学习经验中获得建议 并开始一点点地实践 争取一天可以刷一道题 慢慢地把这些专题都刷过来！
力扣数组专题-4 6道题掌握两种超实用的双指针技巧-反向指针leetcode344 561 167 与快慢指针leetcode27 485 209 java刷题笔记
一碗菜粥的博客
08-03 559
双指针专题 暂时结束数组专题吧 做了足够久了 之后的前缀和专题&二分查找专题回头再补上！
Java-网络
最新发布
2301_81543552的博客
09-14 352
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
Android Studio 2024与2022 解决Read timed out和connect timed out的问题
2301_80035882的博客
09-14 349
如果在新建Android项目时报错：Read timed out或者connect timed out。
上传文件到钉盘流程详解
jspyth的博客
09-14 436
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
Java集合：Stack详解
yang_brother的博客
09-10 596
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
牛客上代码随想录怎么看题刷题
04-12
牛客网上的代码随想录是一个非常好的刷题平台，它提供了大量的编程题目和解题思路。在牛客网上刷题，可以按照以下步骤进行： 1. 注册并登录牛客网账号。 2. 在主页上找到“代码随想录”板块，点击进入。 3. 在代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值