第四章字符串 part01 344.反转字符串

旧日ζั͡ޓއއއ昔年

已于 2023-08-24 20:53:31 修改

阅读量173

点赞数

文章标签： leetcode 算法

于 2023-08-16 22:42:13 首次发布

本文链接：https://blog.csdn.net/qq_45498567/article/details/132330631

版权

第八天| 第四章字符串part01 344.反转字符串

反转字符串II 剑指Offer 05.替换空格 151.翻转字符串里的单词剑指Offer58-II.左旋转字符串

本章的题目尽量不要使用库函数，如果在现场面试中，我们什么时候使用库函数，什么时候不要用库函数呢？

答：如果题目关键的部分直接用库函数就可以解决，建议不要使用库函数。如果库函数仅仅是解题过程中的一小部分，并且你已经很清楚这个库函数的内部实现原理的话，可以考虑使用库函数。

344.反转字符串

题目链接：https://leetcode.cn/problems/reverse-string/
文章讲解：https://programmercarl.com/0344.%E5%8F%8D%E8%BD%AC%E5%AD%97%E7%AC%A6%E4%B8%B2.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE
题目介绍：编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

解法：

思路：反转字符串，可以看作是字符串的首尾交换，自然想到的解法就是**双指针**，从两头开始遍历，往中间靠拢。

代码：

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

541.反转字符串II

题目链接：https://leetcode.cn/problems/reverse-string/
文章讲解：https://programmercarl.com/0344.%E5%8F%8D%E8%BD%AC%E5%AD%97%E7%AC%A6%E4%B8%B2.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE
题目介绍：给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。
- 如果剩余字符少于 k 个，则将剩余字符全部反转。
- 如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。

解法：

思路：和上面反转字符串的题一脉相承，因为这里是2k为一组，所以循环的时候应该把2k作为一个循环的最小单位。

代码：

class Solution {
    public String reverseStr(String s, int k) {
        char[] ch = s.toCharArray();
        for (int i = 0; i < ch.length; i += 2 * k) {
            if (i + k - 1 < ch.length) {
                reverse(ch, i , i + k -1);
                continue;
            }
            // 直到最后一组元素剩余个数小于k个
            reverse(ch, i, ch.length - 1);
        }
        return new String(ch);
    }
    public void reverse(char[] ch, int left, int right) {
        while (left < right) {
            char temp = ch[right];
            ch[right] = ch[left];
            ch[left] = temp;
            left++;
            right--;
        }
    }
}

注意：
- （1）定义一个reverse方法用来做String底层char数组的反转操作；
- （2）以2k为一组进行循环，因为我们要反转前k个，所以反转的末尾是索引是i + k - 1。如果i + k - 1比数组的长度还长，那么就会报空指针异常。所以想要反转前k个的条件是i + k - 1 < ch.length;，因为对于每组来说只进行一次反转操作，所以直接continue。
- （3）如果剩余的元素个数小于k个，那么left就等于当前i，right就等于数组的长度减一。

剑指Offer 05.替换空格

题目链接：https://leetcode.cn/problems/ti-huan-kong-ge-lcof/
文章讲解：https://programmercarl.com/%E5%89%91%E6%8C%87Offer05.%E6%9B%BF%E6%8D%A2%E7%A9%BA%E6%A0%BC.html#%E6%80%9D%E8%B7%AF
题目介绍：请实现一个函数，把字符串 s 中的每个空格替换成"%20"。
解法：
- 思路：题解把这道题也纳入了”双指针“类型，但是由于java中的字符串String，底层是一个char[]数组，一旦给这个二数组申请了内存空间，它的大小就是确定的，无法再改变，因此还是需要申请新的字符串，所以，我认为这里的双指针不是一个好的解法。
- 所以，这里的代码给出的就是一般解法：
  - ```
  class Solution {
      public String replaceSpace(String s) {
          StringBuilder sb = new StringBuilder();
          for (int i = 0; i < s.length(); i++) {
              if (s.charAt(i) == ' ') {
                  sb.append("%20");
              }else {
                  sb.append(s.charAt(i));
              }
          }
          return sb.toString();
      }
  }
```
- 注意：这里使用StringBuilder即可，因为只有一个线程，不用考虑线程安全问题，效率也高。StringBuilder的append方法可以append一个字符串，也可以append一个char字符或char型数组。

151.翻转字符串里的单词

题目链接：https://leetcode.cn/problems/reverse-words-in-a-string/
文章讲解：https://programmercarl.com/0151.%E7%BF%BB%E8%BD%AC%E5%AD%97%E7%AC%A6%E4%B8%B2%E9%87%8C%E7%9A%84%E5%8D%95%E8%AF%8D.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE
题目介绍：给你一个字符串 s ，请你反转字符串中单词的顺序。单词是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的单词分隔开。

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

注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。
- 示例 1：
```
输入：s = "the sky is blue"
输出："blue is sky the"
```
解法：
- 思路：分为下面这三步：
  - 移除多余空格
  - 将整个字符串反转
  - 将每个单词反转
- 首先，移除多余的空格。什么是多余的空格呢？我们最终在char的数组中希望保留的只有两两单词之间的空格，其余空格都是多余的，并且这个空格也是只有一个。
  - 这里的处理思路类似于我们在数组章节中接触的“移除数组元素”，同样也要使用快慢指针，其中快指针是找到新数组中的元素，慢指针是定位新数组的下标。具体代码如下：
  - ```
  private char[] removeExtraSpaces(char[] chars) {
      int slow = 0;
      for (int fast = 0; fast < chars.length; fast++) {
          if (chars[fast] != ' ') {
              if (slow != 0) {
                  // 给除首位单词，其余中间单词的前一位加上空格
                  chars[slow++] = ' ';
              }
              // fast 遇到空格或遍历到字符串末尾，就证明遍历完一个单词了
              // 注意这里要使用&&
              while (fast < chars.length && chars[fast] != ' ') {
                  chars[slow++] = chars[fast++];
              }
          }
      }
      //相当于 c++ 里的 resize()
      char[] newChars = new char[slow];
      System.arraycopy(chars, 0, newChars, 0, slow);
      return newChars;
  } 
```
- 注意：
  - （1）外层循环的fast++，是用来控制整个fast遍历数组的；内层循环的fast++，是用来控制fast遍历一个单词内部的。
  - （2）在一个单词内部中，循环结束的条件就是要么到字符串末尾了，要么遇到空格了，所以要想循环进行下去必须满足：fast < ch.length && ch[fast] != ’ ’
  - （3）这里提到了一个新的函数：System.arraycopy(int[] arr, int star,int[] arr2, int start2, length); 用于数组复制。
    - 第一个参数是要被复制的数组
    - 第二个参数是被复制的数字开始复制的下标
    - 第三个参数是目标数组，也就是要把数据放进来的数组
    - 第四个参数是从目标数据第几个下标开始放入数据
    - 第五个参数表示从被复制的数组中拿几个数值放到目标数组中
- 其次，将整个字符串反转。使用双指针法
  - 代码：
    - ```
    private void reverse(char[] chars, int left, int right) {
        while (left < right) {
            char temp = chars[left];
            chars[left] = chars[right];
            chars[right] = temp;
            left++;
            right--;
        }
    }
```
- 最后，将每个单词内部进行反转。使用双指针法，定义一个开始指针start，一个结束指针end，他们都指向数组的开始。然后，让end开始遍历，只要end遇见了空格，或者end遇到了数组的结尾，那么就可以执行单词的反转操作了。
  - 代码：
    - ```
    private void reverseEachWord(char[] chars) {
        int start = 0;
        for (int end = 0; end <= chars.length; end++) {
             // end 每次到单词末尾后的空格或串尾,开始反转单词
            if (end == chars.length || chars[end] == ' ') {
                reverse(chars, start, end-1);
                start = end + 1;
            }
        }
    }
```
- 注意：这里使用的是<=，因为这样可以方便给end赋值，更容易地表示单词的开始和结尾，这里要说明的是，边界问题自洽即可

编写整个的代码：

class Solution {
    //用 char[] 来实现 String 的 removeExtraSpaces，reverse 操作
    public String reverseWords(String s) {
        char[] chars = s.toCharArray();
        // 1. 去除多余的空格
        chars = removeExtraSpaces(chars);
        // 2. 反转整个字符串
        reverse(chars, 0, chars.length - 1);
        // 3. 反转每个单词
        reverseEachWord(chars);
        return new String(chars);
    }
    
    // 1. 去除多余的空格
    private char[] removeExtraSpaces(char[] chars) {
    int slow = 0;
    for (int fast = 0; fast < chars.length; fast++) {
        if (chars[fast] != ' ') {
            if (slow != 0) {
                // 给除首位单词，其余中间单词的前一位加上空格
                chars[slow++] = ' ';
            }
            // fast 遇到空格或遍历到字符串末尾，就证明遍历完一个单词了
            // 注意这里要使用&&
            while (fast < chars.length && chars[fast] != ' ') {
                chars[slow++] = chars[fast++];
            }
        }
    }
    //相当于 c++ 里的 resize()
    char[] newChars = new char[slow];
    System.arraycopy(chars, 0, newChars, 0, slow);
    return newChars;
    } 
    
    // 2. 反转整个字符串
    private void reverse(char[] chars, int left, int right) {
        while (left < right) {
            char temp = chars[left];
            chars[left] = chars[right];
            chars[right] = temp;
            left++;
            right--;
        }
    }
    
    // 3. 反转每个单词
    private void reverseEachWord(char[] chars) {
        int start = 0;
        for (int end = 0; end <= chars.length; end++) {
             // end 每次到单词末尾后的空格或串尾,开始反转单词
            if (end == chars.length || chars[end] == ' ') {
                reverse(chars, start, end-1);
                start = end + 1;
            }
        }
    }
}

剑指Offer58-II.左旋转字符串

题目链接：https://leetcode.cn/problems/zuo-xuan-zhuan-zi-fu-chuan-lcof/
文章讲解：https://programmercarl.com/%E5%89%91%E6%8C%87Offer58-II.%E5%B7%A6%E6%97%8B%E8%BD%AC%E5%AD%97%E7%AC%A6%E4%B8%B2.html#%E6%80%9D%E8%B7%AF
题目介绍：字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。
- 示例 1：
```
输入: s = "abcdefg", k = 2
输出: "cdefgab"
```

解法：

思路：与上一题类似，通过局部反转+整体反转的方法。
具体步骤为：
- （1）反转区间为前n的子串；
- （2）反转区间为n到末尾的子串；
- （3）反转整个字符串。
如图：
- [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eN7iOQps-1692196912434)(E:.STU\【JAVA】\LeetCode\第八天\左旋字符串.png)]

代码：

class Solution {
    public String reverseLeftWords(String s, int n) {
        char[] chars = s.toCharArray();
        reverse(chars, 0, n-1);
        reverse(chars, n, chars.length - 1);
        reverse(chars, 0, chars.length - 1);
        return new String(chars);
    }
    
    private void reverse(char[] chars, int left, int right) {
        while (left < right) {
            char temp = chars[left];
            chars[left] = chars[right];
            chars[right] = temp;
            left++;
            right--;
        }
    }
}

旧日ζั͡ޓއއއ昔年

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
第四章字符串 part01 344.反转字符串

思路：题解把这道题也纳入了”双指针“类型，但是由于java中的字符串String，底层是一个char[]数组，一旦给这个二数组申请了内存空间，它的大小就是确定的，无法再改变，因此还是需要申请新的字符串，所以，我认为这里的双指针不是一个好的解法。这里的处理思路类似于我们在数组章节中接触的“移除数组元素”，同样也要使用快慢指针，其中快指针是找到新数组中的元素，慢指针是定位新数组的下标。什么是多余的空格呢？我们最终在char的数组中希望保留的只有两两单词之间的空格，其余空格都是多余的，并且这个空格也是只有一个。
复制链接

扫一扫