算法学习|Day8 字符串|Leetcode 344反转字符串 541反转字符串II 剑指offer05.替换空格 151反转字符串里的单词

1. 344 反转字符串 E

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。

不要给另外的数组分配额外的空间，你必须**原地修改输入数组**、使用 O(1) 的额外空间解决这一问题。

1.1 思路分析

• 反转链表中，用了双指针方法，所以，反转字符串仍然是用双指针方法，只不过字符串的反转，要比链表更简单。

  因为字符串也是一种数组，所以元素在内存中是连续分布，这就决定了反转链表和反转字符串方式上还是有所差异的。

• 对于字符串，我们定义两个指针（也可以说是索引下标），两个指针从前后同时向中间移动，并交换元素。

1.2 双指针解题

class Solution {
    public void reverseString(char[] s) {
        int l=0;
        int r=s.length-1;
        while (l < r) {
            char temp=s[l];
            s[l]=s[r];
            s[r]=temp;

            l++;
            r--;
        }
    }
}

• 时间复杂度：O(N)
• 空间复杂度：O(1)

1.3 异或运算解题

class Solution {
    public void reverseString(char[] s) {
        int l = 0;
        int r = s.length - 1;
        while (l < r) {
            s[l] ^= s[r];  //构造 a ^ b 的结果，并放在 a 中
            s[r] ^= s[l];  //将 a ^ b 这一结果再 ^ b ，存入b中，此时 b = a, a = a ^ b
            s[l] ^= s[r];  //a ^ b 的结果再 ^ a ，存入 a 中，此时 b = a, a = b 完成交换
            l++;
            r--;
        }
    }
}

2. 541 反转字符串II E

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

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

2.1 思路分析

• 这道题目其实也是模拟，实现题目中规定的反转规则即可。
• 遍历字符串的过程中，只要让 i += (2 * k)，i 每次移动 2 * k 就可以了，然后判断是否需要有反转的区间。
• 因为要找的也就是每2 * k 区间的点，这样写，程序会高效很多。
• 所以当需要固定规律一段一段去处理字符串的时候，要想想在在for循环的表达式上做做文章。
• 题目的意思其实概括为 每隔2k个反转前k个，尾数不够k个时候全部反转

2.2 解题代码

class Solution {
    public String reverseStr(String s, int k) {
        char[] cs=s.toCharArray();//转换为字符数组
        int n=s.length();
        //l 每次移动 2 * k
        for (int l = 0; l < n; l+=2*k) {
            int r=l+k-1;
            reverse(cs,l,Math.min(r,n-1));
        }
        return String.valueOf(cs);
    }

    void reverse(char[] cs,int l,int r){
        while (l < r) {
            char temp=cs[l];
            cs[l]=cs[r];
            cs[r]=temp;
            l++;
            r--;
        }
    }
}

• 时间复杂度：O(n)
• 空间复杂度：Java 中 String 属于不可变，复杂度为 O(n).要使用 O(n) 的空间将字符串临时转换为可以修改的数据结构

3. 剑指 Offer 05. 替换空格

请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

3.1 思路分析

• 在 Java 语言中，字符串都被设计成==「不可变」==的类型，即无法直接修改字符串的某一位字符，需要新建一个字符串实现。

算法流程：

1. 初始化一个 String Builder，记为 res ；
2. 遍历列表 s 中的每个字符 c ：
3. 当 c 为空格时：向 res 后添加字符串 “%20” ；
4. 当 c 不为空格时：向 res 后添加字符 c ；
5. 将列表 res 转化为字符串并返回。

3.2 解题代码

class Solution {
    public String replaceSpace(String s) {
        StringBuilder res = new StringBuilder();
        for (char c : s.toCharArray()) {
            if (c==' ') {
                res.append("%20");
            }else {
                res.append(c);
            }
        }
        return res.toString();
    }
}

3.3 复杂度分析：

• 时间复杂度 O(N) ：遍历使用 O(N) ，每轮添加（修改）字符操作使用 O(1) ；
• 空间复杂度 O(N) ：新建的 StringBuilder 使用了线性大小的额外空间。

3.4 StringBuilder 解释

StringBuilder 是 Java 中的一个类，用于表示可变的字符串。它可以对字符串进行添加、删除、修改等操作，而不产生新的字符串对象，因此不会带来额外的开销。

StringBuilder 的使用方式类似于 String，可以通过构造函数或静态的 StringBuilder.newInstance() 方法来创建对象。StringBuilder 提供了许多方法，如 append()、insert()、delete()、reverse() 等，这些方法可以用于对字符串进行操作。最后，调用 toString() 方法可以将可变字符串转换为不可变的字符串。

与 StringBuffer 相比，StringBuilder 是线程不安全的，因此多个线程同时修改同一个 StringBuilder 对象可能会产生竞争条件。如果需要在多线程环境下使用可变字符串，应该使用线程安全的 StringBuffer 类。

4. 151 反转字符串里的单词

给你一个字符串 s ，请你反转字符串中 单词 的顺序。

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

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

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