代码随想录 字符串 Java

已于 2023-06-23 08:28:32 修改
阅读量518 收藏
点赞数
分类专栏： 代码随想录 文章标签： java 算法 leetcode
于 2023-05-23 18:32:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guliguliguliguli/article/details/130779516
版权

文章目录

（简单）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--;
        }
    }
}

复杂度分析：

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

（简单）541. 反转字符串||

在这里插入图片描述
我的思路：2k个字符为一组，先将前k个字符（或者不足k个字符）添加到StringBuilder中，然后调用reverse()方法，然后再将后k个字符（或者不足2k个字符）添加到StringBuilder中，最后在将这一组作为一个整体，添加到答案中

class Solution {
    public String reverseStr(String s, int k) {
        int n = s.length();
        int i = 0;
        StringBuilder stringBuilder = new StringBuilder();
        while (i < n) {
            StringBuilder strk = new StringBuilder();
            while (i < n && strk.length() < k) {
                strk.append(s.charAt(i));
                i++;
            }
            strk.reverse();
            while (i < n && strk.length() >= k && strk.length() < 2 * k) {
                strk.append(s.charAt(i));
                i++;
            }
            stringBuilder.append(strk);
        }
        return stringBuilder.toString();
    }
}

在这里插入图片描述
我的另一种思路：将字符串s转换成字符数组，然后在字符数组中找到合适的区间进行交换

import java.util.regex.Pattern;

class Solution {
    public String reverseStr(String s, int k) {
        int n = s.length();
        char[] charArray = s.toCharArray();
        boolean flag = true;
        int i = 0;
        while (i < n) {
            if (flag) {
                int left = i;
                int right = i + k > n ? n - 1 : i + k - 1;
                while (left < right) {
                    char tmp = charArray[left];
                    charArray[left] = charArray[right];
                    charArray[right] = tmp;
                    left++;
                    right--;
                }
                i = i + k;
                flag = false;
            } else {
                if (i + k >= n) {
                    break;
                } else {
                    i += k;
                    flag = true;
                }
            }
        }
        return new String(charArray);
    }
}

在这里插入图片描述
其他写法

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

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

    public void reverse(char[] arr, int left, int right) {
        while (left < right) {
            char tmp = arr[left];
            arr[left] = arr[right];
            arr[right] = tmp;
            left++;
            right--;
        }
    }
}

在这里插入图片描述
复杂度分析：

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

（简单）剑指Offer 05. 替换空格

在这里插入图片描述

方法一

class Solution {
    public String replaceSpace(String s) {
        return s.replaceAll(" ", "%20");
    }
}

在这里插入图片描述
方法二

class Solution {
    public String replaceSpace(String s) {
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c == ' ') {
                stringBuilder.append("%20");
            } else {
                stringBuilder.append(c);
            }
        }
        return stringBuilder.toString();
    }
}

在这里插入图片描述
其他思路

由于每次替换从1个字符变成3个字符，使用字符数组可方便地进行替换。建立字符数组的长度为s的长度的3倍，这样可保证字符数组可以容纳所有替换后的字符。

class Solution {
    public String replaceSpace(String s) {
        int n = s.length();
        char[] array = new char[n * 3];
        int index = 0;
        for (int i = 0; i < n; i++) {
            char c = s.charAt(i);
            if (c == ' ') {
                array[index++] = '%';
                array[index++] = '2';
                array[index++] = '0';
            } else {
                array[index++] = c;
            }
        }
        return new String(array, 0, index);
    }
}

在这里插入图片描述

（中等）151. 反转字符串中的单词

在这里插入图片描述

class Solution {
    public String reverseWords(String s) {
    	//使用trim()去掉首尾的空格，在使用split()按照" "分割
        String[] splits = s.trim().split(" ");
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = splits.length - 1; i >= 0; i--) {
			//但单词间会有多个空格，遇到splits[i].length==0的直接跳过
            if (splits[i].length() == 0) {
                continue;
            }

            stringBuilder.append(splits[i]);

            if (i != 0) {
                stringBuilder.append(" ");
            }
        }
        return stringBuilder.toString();
    }
}

在这里插入图片描述
官方思路，方案一：使用语言特性

很多语言对字符串提供了split拆分、reverse翻转和join连接等方法，因此可以通过调用内置的API完成操作
在这里插入图片描述

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

class Solution {
    public String reverseWords(String s) {
        s = s.trim();
        List<String> wordList = Arrays.asList(s.split("\\s+"));
        Collections.reverse(wordList);
        return String.join(" ", wordList);
    }
}

复杂度分析：

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

官方思路，方法二：自行编写相应的函数

在不同的编程语言中，这些函数是不一样的，主要的差别是有些语言的字符串不可变（如Python、Java），有些语言的字符串可变（如C++）。

对于字符串不可变的语言，首先得把字符串转化成其他可变的数据结构，同时还需要在转化的过程中去除空格。
在这里插入图片描述

对于字符串可变的语言，就不需要额外开辟空间了，直接在字符串上原地实现。在这种情况下，反转字符和去除空格可以一起完成。
在这里插入图片描述

class Solution {
    public String reverseWords(String s) {
        
        //去除首部、尾部、中间多余字符
        StringBuilder sb = trimSpace(s);
        
        //反转整个字符串
        reverse(sb, 0, sb.length() - 1);
        
        //以空格为分割，反转每一个单词
        reverseEachWord(sb);
        return sb.toString();
    }

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

    private void reverse(StringBuilder sb, int left, int right) {
        while (left < right) {
            char tmp = sb.charAt(left);
            sb.setCharAt(left, sb.charAt(right));
            sb.setCharAt(right, tmp);
            left++;
            right--;
        }
    }

    private StringBuilder trimSpace(String s) {
        int left = 0;
        int right = s.length() - 1;
        while (left <= right) {

            //去除字符串开头的空白字符串
            while (left <= right && s.charAt(left) == ' ') {
                left++;
            }

            //去除字符串末尾的空白字符串
            while (left <= right && s.charAt(right) == ' ') {
                right--;
            }

            StringBuilder stringBuilder = new StringBuilder();
            while (left <= right) {
                char c = s.charAt(left);
                if (c != ' ') {
                    stringBuilder.append(c);
                } else if (stringBuilder.charAt(stringBuilder.length() - 1) != ' ') {
                    stringBuilder.append(c);
                }
                left++;
            }
            return stringBuilder;
        }
        return null;
    }
}

在这里插入图片描述
复杂度分析：

  • 时间复杂度：O(n)，其中n为输入字符串的长度，因为需要完整遍历字符串
  • 空间复杂度：Java和Python的方法需要O(n)的空间来存储字符出，而C++方法只需要O(1)的额外空间来存放若干变量

官方思路，方法三：双端队列

由于双端队列支持从队列头部插入的方法，因此我们可以沿着字符串一个一个单词处理，然后将单词压入队列头部，再将队列转成字符串即可

在这里插入图片描述

import java.util.ArrayDeque;
import java.util.Deque;

class Solution {
    public String reverseWords(String s) {
        int n = s.length();
        int left = 0;
        int right = s.length() - 1;

        //去除字符串开头的空白字符串
        while (left <= right && s.charAt(left) == ' ') {
            ++left;
        }

        //去除字符串末尾的空白字符串
        while (left <= right && s.charAt(right) == ' ') {
            --right;
        }

        Deque<String> deque = new ArrayDeque<>();
        StringBuilder word = new StringBuilder();

        while (left <= right) {
            char c = s.charAt(left);
            if (word.length() != 0 && c == ' ') {
                deque.offerFirst(word.toString());
                word.setLength(0);
            } else if (c != ' ') {
                word.append(c);
            }
            ++left;
        }
        deque.offerFirst(word.toString());

        return String.join(" ", deque);
    }
}

在这里插入图片描述
复杂度分析：

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

其实这个地方的双端队列和栈是一个意思啊

（简单）剑指 Offer 58 - II. 左旋转字符串

在这里插入图片描述
简单来说，就是把字符串截成两段，把这两段交换一下位置，拼接成一个新的字符串返回

class Solution {
    public String reverseLeftWords(String s, int n) {
        int len = s.length();
        char[] chars = new char[len];
        int index = 0;
        for (int i = n; i < len; i++) {
            chars[index++] = s.charAt(i);
        }
        for (int i = 0; i < n; i++) {
            chars[index++] = s.charAt(i);
        }
        return new String(chars);

    }
}

在这里插入图片描述

class Solution {
    public String reverseLeftWords(String s, int n) {

        int len = s.length();

        StringBuilder stringBuilder = new StringBuilder(len);

        for (int i = n; i < len; i++) {
            stringBuilder.append(s.charAt(i));
        }
        for (int i = 0; i < n; i++) {
            stringBuilder.append(s.charAt(i));
        }

        return stringBuilder.toString();

    }
}

在这里插入图片描述

（*中等 - KMP算法）28. 找出字符串中第一个匹配项的下标

在这里插入图片描述

最最最传统的字符串匹配问题，脑海中第一反应是KMP算法，但是不记得思路是啥了，所以写了暴力匹配法

class Solution {
    public int strStr(String haystack, String needle) {

        int n = needle.length();
        int h = haystack.length();

        if (n > h) {
            return -1;
        }

        int i = 0;
        int j;
        while (i < h) {
            if (haystack.charAt(i) != needle.charAt(0)) {
                i++;
            } else {
                int k = i + 1;
                j = 1;
                while (k < h && k < i + n && haystack.charAt(k) == needle.charAt(j)) {
                    k++;
                    j++;
                }
                if (k == i + n) {
                    return i;
                } else {
                    i++;
                }
            }
        }
        return -1;
    }
}

在这里插入图片描述

暴力法，就是让字符串needle与字符串haystack的所有长度为m的子串均匹配一次。

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

class Solution {
    public int strStr(String haystack, String needle) {

        int m = needle.length();//短的
        int n = haystack.length();//长的

        for (int i = 0; i + m <= n; i++) {
            boolean flag = true;
            for (int j = 0; j < m; j++) {
                if (haystack.charAt(i + j) != needle.charAt(j)) {
                    flag = false;
                    break;
                }
            }
            if (flag) {
                return i;
            }
        }
        return -1;
    }
}

在这里插入图片描述
复杂度分析：

  • 时间复杂度：O(nm)，其中n是字符串haystack的长度，m是字符串needle的长度。最坏情况下需要将字符串needle与字符串haystack的所有长度为m的子串均匹配一次。
  • 空间复杂度：O(1)，只需要常数的空间保存若干变量。

KMP算法

暴力法的时间复杂度是O(mn)，而KMP的时间复杂度是O(m+n)，是因为其能在非完全匹配的过程中提取到有效信息进行复用，以减少重复匹配的消耗

暴力法匹配字符串，当出现不同位置时，将原字符串的指针移动至本次起始点的下一个位置，匹配串的指针移动至起始位置。继续尝试匹配，发现对不上，原串的指针会一直往后移动，知道能够与匹配串对上位置。

import java.util.Arrays;

class Solution {
    public int strStr(String haystack, String needle) {

        int haystackLength = haystack.length();
        int needleLen = needle.length();

        if(needleLen > haystackLength){
            return -1;
        }

        char[] haystackArr = haystack.toCharArray();
        char[] needleArr = needle.toCharArray();
        int[] next = new int[needleLen];
        getNext(next, needle.toCharArray());
        int i = 0;
        int j = 0;
        while (i < haystackLength) {
            if (haystackArr[i] != needleArr[j]) {
                while (j != 0 && haystackArr[i] != needleArr[j]) {
                    j = next[j - 1];
                }
                if (j == 0 && haystackArr[i] != needleArr[j]) {
                    i++;
                }
            } else {
                i++;
                j++;
            }

            if (j == needleLen) {
                return i - j;
            }
        }
        return -1;
    }

    private void getNext(int[] next, char[] arr) {
        int len = arr.length;
        int j = 0;
        int i = 1;
        while (i < len) {
            if (arr[i] == arr[j]) {
                next[i] = j + 1;
                i++;
                j++;
            } else {
                while (j > 0 && arr[i] != arr[j]) {
                    j = next[j - 1];
                }
                if (j == 0 && arr[i] != arr[j]) {
                    next[i] = 0;
                    i++;
                }
            }
        }
    }
}

在这里插入图片描述

（*简单 - KMP算法）459. 重复的子字符串

在这里插入图片描述

假设原字符串S是由子串s重复N次而成的，则S+S则有子串s重复2N次，那么现在有S=Ns，S+S=2Ns，其中N>=2。如果条件成立，掐头去尾破坏两个s，S+S中至少还有2(N-1)s，又因为N>=2，因此在S+S的索引从[0,length-2]中必出现一次以上

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

在这里插入图片描述

努力努力再努力@_@
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
代码随想录-八股文 pdf
04-25
代码随想录-八股文 pdf
代码随想录-大厂八股文稀有资源好几百页
04-19
付费渠道买的，请珍惜
【代码随想录】数组专栏（Java）
一舟的博客
11-04 450
由于是非递减的顺序，可以考虑二分法。在第一次找到target时，向左右探测。在左边和右边分别执行二分法找到target后返回下标。//左边 arr [ 1 ] = search2(nums , target , 1);//右边 return arr;//探测左边 right = middle - 1;} else {//探测右边 left = middle + 1;} else {}
《代码随想录》刷题笔记——字符串篇【java实现】
记录一名在读研究生的学习笔记、感悟、开发产物
10-22 239
录友刷《代码随想录》的做题记录，这一章节真的让我脑子瓦特了/(ㄒoㄒ)/~~
JAVA字符串基础——代码随想录 字符串
weixin_44023809的博客
02-24 69
本文编辑于2023年2月。
代码随想录 栈与队列 Java
guliguliguliguli的博客
05-30 606
对于一个有效的逆波兰表达式，其长度n一定是奇数，且操作数的个数一定比运算符的个数多1个。
代码随想录二叉树 Java（三）
guliguliguliguli的博客
06-15 726
显然，p和q的最近公共祖先就是从根节点到它们路径上的【分岔点】，也就是最后一个相同的节点。一个一个删除太繁琐了。表示，x节点的左孩子和右孩子均包含p节点或q节点，如果左子树包含的是p节点，那么右子树只能包含q节点，反之亦然，因为p和q节点都是不同且唯一的节点，因此，如果满足这个条件，就可以说x是最近的公共祖先。如果根节点不为空，则将val从根节点开始比较，如果val的值大于根节点的值，则移动到该二叉树的右节点，如果val的值小于根节点，则移动到该二叉树的左节点，并使用一个变量pre记录当前节点的父节点。
【代码随想录】回溯算法专栏（java版本）
码农研究僧的博客
04-08 2944
总结回溯算法的题型 按照规模将其题型都熟练掌握 学习的链接大框架为： 回溯算法理论基础 LinkedList sonlist=new LinkedList(); 双向链表可以删除最前或者添加最前的节点，删除的时候通过removeLast(); List sonlist=new ArrayList(); 单链表只能添加，或者删除，删除的时候通过remove（下标值）
代码随想录 回溯算法 Java
guliguliguliguli的博客
06-22 431
文章目录组合（*中等）77. 组合（*中等）17. 电话号码的字母组合（中等）39. 组合总和（中等）40. 组合总和II（中等）216. 组合总和|||分割（*中等）131. 分割回文串（*中等）93. 复制IP地址子集（中等）78. 子集（中等）90. 子集II排列（中等）46. 全排列（中等）47. 全排列II棋盘问题HDU - 2553 N皇后问题（困难）51. N皇后（困难）37. 解数独其他（中等）491. 递增子序列（*困难）332. 重新安排行程 欧拉回路/欧拉通路 组合 （*中等
代码随想录 二叉树 Java （一）
guliguliguliguli的博客
06-04 664
文章目录（简单）144. 二叉树的前序遍历（简单）94. 二叉树的中序遍历（简单）145. 二叉树的后序遍历二叉树的统一遍历方法（参考代码随想录）（中等）102. 二叉树的层序遍历（中等）107. 二叉树的层序遍历II（中等）199. 二叉树的右视图（简单）637. 二叉树的层平均值（中等）429. N叉树的层序遍历（中等）在每个树行中找最大值（中等）116. 填充每个节点的下一个右侧节点指针（中等）117. 填充每个节点的下一个右侧节点指针II（简单）104. 二叉树的最大深度（简单）111. 二叉树的最
代码随想录 二叉树 Java（二）
guliguliguliguli的博客
06-13 637
文章目录（*中等）222. 完全二叉树的节点个数（*简单）110. 平衡二叉树（*简单）257. 二叉树的所有路径（简单）404. 左叶子之和（简单）513. 找树左下角的值（简单）112. 路径总和由第112题 二叉树 递归 小结（中等）113. 路径总和II（*中等）106. 从中序与后序遍历序列构造二叉树（中等）105. 从前序与中序遍历序列构造二叉树（中等）654. 最大二叉树（简单）617. 合并二叉树（简单）700. 二叉搜索树中的搜索（中等）98. 验证二叉搜索树（简单）530. 二叉搜索树的
代码随想录知识星球精华 最强⼋股⽂
04-28
代码随想录知识星球精华（最强⼋股⽂） 这份PDF总结了 代码随想录知识星球 的全部精华内容，覆盖了⼏乎程序员学习必备的内容。 知识星球⾥很多录友拿到了⼤⼚offer，包括科班 和 ⾮科班的，⽽他们的每⽇学习总结都是...
代码随想录知识算法讲解PDF
10-26
代码随想录贪心算法知识，非常管用
代码随想录 面试大厂必备八股文
07-03
代码随想录 面试大厂八股文 手撕代码必备神器
代码随想录算法PDF.zip
05-29
代码随想录算法PDF.zip
代码随想录 LeetCode链表篇 Java
guliguliguliguli的博客
05-15 394
用head表示原始链表的头节点，新的链表的第二个节点，用newHead表示新的链表的头节点，原始链表的第二个节点，则原始链表中的其余节点的头节点是newHead.next。如果temp的后面没有节点或者只有一个节点，则没有更多的节点需要交换，因此结束交换。根据栈【先进后出】的原则，弹出栈的第n个节点就是需要删除的节点，并且，目前栈顶的节点就是待删除节点的前驱节点。如果链表中至少有两个节点，则在两两交换链表中的节点之后，原始链表的头节点编程新的链表的第二个节点，原始链表的第二个节点变成新的链表的头节点。
代码随想录-贪心算法【1】（Java）
weixin_45685902的博客
04-01 173
贪心算法
代码随想录——数组（Java）
weixin_52150845的博客
03-25 161
记录一下自己刷代码随想录的过程，希望能坚持下去，思路、代码均来自于代码随想录。二分法-双指针法-滑动窗口-循环不变量重点学会双指针的思想！
JAVA数组基础——代码随想录 数组
weixin_44023809的博客
11-21 360
本文档创作于代码随想录算法训练营四期。
代码随想录python
最新发布
02-17
代码随想录是一个由CSDN开发的Python学习教程，它提供了丰富的Python编程知识和实例代码。以下是关于代码随想录Python的介绍： 1. 代码随想录Python是一个面向初学者的Python教程，它从基础知识开始，逐步介绍...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值