Day46 反转字符串

I.

---

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

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

时间复杂度：O(n)

空间复杂度：O(1)

II.

---

给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。
如果剩余字符少于 k 个，则将剩余字符全部反转。
如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。

class Solution {
    public String reverseStr(String s, int k) {
        // 将字符串转换为字符数组，以便可以修改字符
        char[] arr = s.toCharArray();
        // 每次处理2k个字符，所以i每次增加2k
        for (int i = 0; i < arr.length; i += 2 * k) {
            // 反转前k个字符
            int left = i;
            int right = Math.min(i + k - 1, arr.length - 1);
            while (left < right) {
                char temp = arr[left];
                arr[left] = arr[right];
                arr[right] = temp;
                left++;
                right--;
            }
        }
        return new String(arr);
    }
}

时间复杂度： O(n)，其中 n 是字符串的长度，因为我们只遍历了一次字符串，并在每次处理时执行常数时间的反转操作。

空间复杂度： O(n)，用于存储字符数组。

III.

---

给定一个字符串 s ，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。

class Solution {
    public String reverseWords(String s) {
        char[] arr = s.toCharArray();
        int left = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == ' ') {
                reverse(arr, left, i - 1);
                left = i + 1;
            }
            if (i == arr.length - 1) {
                reverse(arr, left, i);
            }
        }
        return new String(arr);
    }
    public void reverse(char[] arr, int left, int right) {
        while (left < right) {
            char temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
            left++;
            right--;
        }
    }
}

时间复杂度： O(n)，其中 n 是字符串的长度。我们只遍历了字符数组一次，并在遍历过程中执行了常数时间的反转操作。

空间复杂度： O(n)，用于存储字符数组 arr，以及 new String(arr)。