力扣刷题day07|344反转字符串、541反转字符串II、剑指Offer05替换空格、151反转字符串里的单词、剑指Offer58-II左旋转字符串
文章目录
-
- 344. 反转字符串
-
- 思路
-
- 双指针法
- 难点
- 541. 反转字符串II
-
- 思路
-
- 难点
- 剑指Offer 05.替换空格
-
- 思路
-
- 双指针法
- 难点
- 151. 反转字符串中的单词
-
- 思路
-
- 难点1：空格的去除
-
- 双指针法
- 难点2：反转每个单词
- 剑指Offer58-II.左旋转字符串
-
- 思路
-
- 难点
344. 反转字符串
力扣题目链接
编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
示例1：
输入：s = ["h","e","l","l","o"]
输出：["o","l","l","e","h"]
示例2：
输入：s = ["H","a","n","n","a","h"]
输出：["h","a","n","n","a","H"]
思路
双指针法
- 左指针：指向字符串头，与尾部交换
- 右指针：指向字符串尾，与头部交换
两个指针，一个从字符串前面，一个从字符串后面，两个指针同时向中间移动，并交换元素
难点
关于java中swap的实现
s[i] ^= s[j];
s[j] ^= s[i];
s[i] ^= s[j];
参考资料：算法细节系列（1）：Java swap
- 用
for实现
public void reverseString(char[] s) {
// ij从首位往中间移动
for (int i = 0, j = s.length - 1; i < s.length / 2; i++, j--) {
// swap()操作
s[i] ^= s[j];
s[j] ^= s[i];
s[i] ^= s[j];
}
}
- 用
while实现
public void reverseString1(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--;
}
}
541. 反转字符串II
力扣题目链接
给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。
-
如果剩余字符少于
k个，则将剩余字符全部反转。 -
如果剩余字符小于
2k但大于或等于k个，则反转前k个字符，其余字符保持原样。
示例1：
输入：s = "abcdefg", k = 2
输出："bacdfeg"
示例2：
输入：s = "abcd", k = 2
输出："bacd"
思路
对字符串以2k个字符进行分组遍历，对每个组里面的
难点
遍历字符串时应该每次移动2k个字符，即i=i+2k，不用每次i=i+1只遍历一个字符
public class ReverseStr {
public String reverseStr(String s, int k) {
// 先将字符串存入数组
char[] str = s.toCharArray();
// 每次移动2k
for (int i = 0; i < str.length; i += 2 * k) {
// 判断字符小于2k时，比较尾数是否大于k
if (i + k < str.length) {
reverse(str, i, i + k - 1);
}else {
reverse(str, i, str.length - 1);
}
// int end = Math.min(i + k - 1, str.length - 1);
// reverse(str, i, end);
}
// 最后要转为字符串返回
return new String(str);
}
// 定义字符串反转方法
public void reverse(char[] ch, int left, int right) {
while (left < right) {
ch[left] ^= ch[right];
ch[right] ^= ch[left];
ch[left] ^= ch[right];
left++;
right--;
}
}
}
剑指Offer 05.替换空格
力扣题目链接
请实现一个函数，把字符串 s 中的每个空格替换成"%20"。
示例1：
输入：s = "We are happy."
输出："We%20are%20happy."
思路
双指针法
oldIndex：指向原字符串的末尾newIndex：指向扩充后新字符串的末尾
要从后向前填充，从前向后填充不行么？
从前向后填充就是O(n^2)的算法了，因为每次添加元素都要将添加元素之后的所有元素向后移动。
oldIndex从原字符串末尾开始，newIndex复制每一个字符，oldIndex遇到空格时newIndex继续--填入%20
难点
- 新的数组需要扩充的大小应该是
原空格数量*2，因为原来就有一个空格占位1个字符，现在新替换的%20占位3个字符，相减仅需扩充2个字符
public String replaceSpace(String s) {
if (s == null || s.length() == 0){
return s;
}
// 计算新的数组所需的空间，空格数量*2
StringBuilder str = new StringBuilder();
for (int i = 0; i < s.length(); i++) {
if (s.charAt(i) == ' ') {
// append的必须是String
str.append(" ");
}
}
// 定义原字符串末尾的指针
int oldIndex = s.length() - 1;
// 原字符串加上扩充的书
s += str;
// 定义扩充后新字符串末尾的指针
int newIndex = s.length() - 1;
// 将字符串转为数组
char[] ch = s.toCharArray();
while (newIndex >= 0) {
// 当是字符时
if (ch[oldIndex] != ' ') {
ch[newIndex] = ch[oldIndex];
}else {
ch[newIndex--] = '0';
ch[newIndex--] = '2';
ch[newIndex] = '%';
}
oldIndex--;
newIndex--;
}
//return ch.toString();
return new String(ch);
151. 反转字符串中的单词
力扣题目链接
给你一个字符串 s ，请你反转字符串中 单词 的顺序。
单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。
返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。
**注意：**输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。
示例 1：
输入：s = "the sky is blue"
输出："blue is sky the"
示例 2：
输入：s = " hello world "
输出："world hello"
解释：反转后的字符串中不能存在前导空格和尾随空格。
示例 3：
输入：s = "a good example"
输出："example good a"
解释：如果两个单词间有多余的空格，反转后的字符串需要将单词间的空格减少到仅有一个。
思路
解题步骤如下：
- 移除多余空格
- 将整个字符串反转
- 将每个单词反转
举个例子，源字符串为："the sky is blue "
-
移除多余空格 : “the sky is blue”
-
字符串反转：“eulb si yks eht”
-
单词反转：“blue is sky the”
难点1：空格的去除
双指针法
快指针fast：指向每个单词
慢指针slow：指向新字符串的每个位置
注：我们先全部忽略掉原来字符串里的所有空格，然后直接手动在中间每个单词的前面自己加上一个空格
public String removeExtraSpaces(String s) {
// 因为去空格会改变数组大小，所以要用StringBuilder
StringBuilder tempStr = new StringBuilder();
// 定义快慢指针
int fast = 0;
int slow = 0;
for (; fast < s.length(); fast++) {
// 遇到非空格就处理，即删除了所有空格
if (s.charAt(fast) != ' ') {
//手动控制空格，给单词之间添加空格。slow != 0说明不是第一个单词，需要在单词前添加空格。
if(slow != 0) {
tempStr.append(' ');
}
//补上该单词，遇到空格说明单词结束。
while (fast < s.length() && s.charAt(fast) != ' '){
tempStr.append(s.charAt(fast));
slow = fast;
fast++;
slow++;
}
}
}
return tempStr.toString();
}
fast指针最外层是遍历完字符串，第一个判断s.charAt(fast) != ' '有效的避开了字符串前面中间结尾三个部分的空格，全部不考虑
if(slow != 0) {
tempStr.append(' ');
}
上面的代码slow != 0说明不是第一个单词，需要在单词前添加空格
while (fast < s.length() && s.charAt(fast) != ' ')
上面的代码说明每遇到一个单词，就把单词的每个字符存进字符串，遇到空格的时候单词结束
难点2：反转每个单词
start指针：指向单词开头end指针：指向单词结尾
当去掉空格时，start指针从第一个单词的第一个个字母开始（下标0），记录每个单词的起始位置。
end指针遍历整个字符串，遍历到空格时，与start即为一个单词，最后一个单词后面是没有空格的，因此end要指向字符串结尾坐标的下一位，加上判断条件end == str.length || str[end] == ' ' ，这里不能用str[end] == ' ' || end == str.length因为我们要先判断end最后是否在末尾不然可能引起数组的下标溢出。
public class ReverseWords {
public String reverseWords(String s) {
//去除多余空格，保证单词之间之只有一个空格，且字符串首尾没空格。
String newStr = removeExtraSpaces(s);
char[] str = newStr.toCharArray();
// 反转字符串，每个单词是倒序
reverse(str, 0, str.length - 1);
// 反转每个单词
int start = 0; // 第一个单词的第一个字母
for (int end = 0; end <= str.length; end++) {
// 先判断是否到最后了，不然会超出下标范围
if (end == str.length || str[end] == ' ') {
// 遍历到空格，或者遍历到单词末尾（此时没空格）
reverse(str, start, end - 1);
// 更新下一个单词的开始下标start
start = end + 1;
}
}
return new String(str);
}
// 定义去除空格元素的方法
public String removeExtraSpaces(String s) {
// 因为去空格会改变数组大小，所以要用StringBuilder
StringBuilder tempStr = new StringBuilder();
// 定义快慢指针
int fast = 0;
int slow = 0;
for (; fast < s.length(); fast++) {
// 遇到非空格就处理，即删除了所有空格
if (s.charAt(fast) != ' ') {
//手动控制空格，给单词之间添加空格。slow != 0说明不是第一个单词，需要在单词前添加空格。
if(slow != 0) {
tempStr.append(' ');
}
//补上该单词，遇到空格说明单词结束。
while (fast < s.length() && s.charAt(fast) != ' '){
tempStr.append(s.charAt(fast));
slow = fast;
fast++;
slow++;
}
}
}
return tempStr.toString();
}
// 定义反转字符串的方法
public void reverse(char[] ch,int left,int right) {
while (left < right) {
ch[left] ^= ch[right];
ch[right] ^= ch[left];
ch[left] ^= ch[right];
left++;
right--;
}
}
}
剑指Offer58-II.左旋转字符串
字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。
示例1：
输入: s = "abcdefg", k = 2
输出: "cdefgab"
示例2：
输入: s = "lrloseumgh", k = 6
输出: "umghlrlose"
思路
一开始想法是先反转取出前n个字符，然后加到末尾，但这样就申请了额外的空间，这样就没能做到联系的作用
难点
不能申请额外空间，只能在本串上操作：
假设原字符串"abcdefg"，n=2
具体步骤为：
-
反转区间为前n的子串
b a | c d e f g
-
反转区间为n到末尾的子串
b a | g f e d c
-
反转整个字符串
c d e f g | a b
即可以通过局部反转+整体反转达到左旋转的目的
public class ReverseLeftWords {
public String reverseLeftWords(String s, int n) {
char[] str = s.toCharArray();
// 先反转前n个
reverse(str, 0, n-1);
// 再反转后面剩余的
reverse(str, n, str.length - 1);
// 最后整体反转
reverse(str, 0, str.length - 1);
return new String(str);
}
// 定义字符串反转方法
public void reverse(char[] ch, int left, int right) {
while (left < right) {
ch[left] ^= ch[right];
ch[right] ^= ch[left];
ch[left] ^= ch[right];
left++;
right--;
}
}
}