bash
第四章 字符串part01
今日任务
● 344.反转字符串
● 541. 反转字符串II
● 卡码网：54.替换数字
● 151.翻转字符串里的单词
● 卡码网：55.右旋转字符串
详细布置
344.反转字符串
建议： 本题是字符串基础题目，就是考察 reverse 函数的实现，同时也明确一下 平时刷题什么时候用 库函数，什么时候 不用库函数
题目链接/文章讲解/视频讲解：https://programmercarl.com/0344.%E5%8F%8D%E8%BD%AC%E5%AD%97%E7%AC%A6%E4%B8%B2.html
541. 反转字符串II
建议：本题又进阶了，自己先去独立做一做，然后在看题解，对代码技巧会有很深的体会。
题目链接/文章讲解/视频讲解：https://programmercarl.com/0541.%E5%8F%8D%E8%BD%AC%E5%AD%97%E7%AC%A6%E4%B8%B2II.html
卡码网：54.替换数字
建议：对于线性数据结构，填充或者删除，后序处理会高效的多。好好体会一下。
题目链接/文章讲解：https://programmercarl.com/kama54.%E6%9B%BF%E6%8D%A2%E6%95%B0%E5%AD%97.html
151.翻转字符串里的单词
建议：这道题目基本把 刚刚做过的字符串操作 都覆盖了，不过就算知道解题思路，本题代码并不容易写，要多练一练。
题目链接/文章讲解/视频讲解：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
卡码网：55.右旋转字符串
建议：题解中的解法如果没接触过的话，应该会想不到
题目链接/文章讲解：
https://programmercarl.com/kama55.%E5%8F%B3%E6%97%8B%E5%AD%97%E7%AC%A6%E4%B8%B2.html目录
0344_反转字符串
java
public class _0344_反转字符串 {
public static void main(String[] args) {
char[] s = {'h', 'e', 'l', 'l', 'o'};
StringBuilder sb = new StringBuilder(new String(s));
s = sb.reverse().toString().toCharArray();
for (char x : s) {
System.out.println(x);
}
}
}
class Solution0344 {
public void reverseString(char[] s) {
// StringBuilder sb = new StringBuilder(new String(s));
// s = sb.reverse().toString().toCharArray();
char[] ss = new StringBuilder(new String(s)).reverse().toString().toCharArray();
for (int i = 0; i < s.length; i++) {
s[i] = ss[i];
}
}
public void reverseString2(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--;
}
}
public void reverseString3(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--;
}
}
public void reverseString4(char[] s) {
for (int i = 0, j = s.length - 1; i < s.length / 2; i++, j--) {
char temp = s[i];
s[i] = s[j];
s[j] = temp;
}
}
}0541_反转字符串II
其实在遍历字符串的过程中，只要让 i += (2 * k)，i 每次移动 2 * k 就可以了，然后判断是否需要有反转的区间。
因为要找的也就是每2 * k 区间的起点，这样写，程序会高效很多。
java
class Solution0541 {
public String reverseStr(String s, int k) {
char ss[] = s.toCharArray();
for (int i = 0; i < s.length(); i += (2 * k)) {
//【1】每隔2k个字符，对前k个字符进行反转
//【2】剩余字符小于2k，但大于或等于 k 个，则反转前 k 个字符
if (i + k <= s.length()) {
reverse(ss, i, i + k - 1);
continue;
}
//【3】剩余字符少于k个，则将剩余字符全部反转。
reverse(ss, i, s.length() - 1);
}
return new String(ss);
}
private void reverse(char[] s, int start, int end) {
for (int i = start, j = end; i < j; i++, j--) {
char temp = s[i];
s[i] = s[j];
s[j] = temp;
}
}
}
//解法一
class Solution0541_2 {
public String reverseStr(String s, int k) {
StringBuffer res = new StringBuffer();
int length = s.length();
int start = 0;
while (start < length) {
// 找到k处和2k处
StringBuffer temp = new StringBuffer();
// 与length进行判断，如果大于length了，那就将其置为length
int firstK = (start + k > length) ? length : start + k;
int secondK = (start + (2 * k) > length) ? length : start + (2 * k);
//无论start所处位置，至少会反转一次
temp.append(s.substring(start, firstK));
res.append(temp.reverse());
// 如果firstK到secondK之间有元素，这些元素直接放入res里即可。
if (firstK < secondK) { //此时剩余长度一定大于k。
res.append(s.substring(firstK, secondK));
}
start += (2 * k);
}
return res.toString();
}
}
//解法二（似乎更容易理解点）
//题目的意思其实概括为：每隔2k个反转前k个，尾数不够k个时候全部反转
class Solution0541_3 {
public String reverseStr(String s, int k) {
char[] ch = s.toCharArray();
for (int i = 0; i < ch.length; i += 2 * k) {
int start = i;
//这里是判断尾数够不够k个来取决end指针的位置
int end = Math.min(ch.length - 1, start + k - 1);
//用异或运算反转
while (start < end) {
ch[start] ^= ch[end];
ch[end] ^= ch[start];
ch[start] ^= ch[end];
start++;
end--;
}
}
return new String(ch);
}
}
//解法二还可以用temp来交换数值，会的人更多些
class Solution0541_4 {
public String reverseStr(String s, int k) {
char[] ch = s.toCharArray();
for (int i = 0; i < ch.length; i += 2 * k) {
int start = i;
//判断尾数够不够k个来取决end指针的位置
int end = Math.min(ch.length - 1, start + k - 1);
while (start < end) {
char temp = ch[start];
ch[start] = ch[end];
ch[end] = temp;
start++;
end--;
}
}
return new String(ch);
}
}
class Solution0541_5 {
public String reverseStr(String s, int k) {
char[] chars = s.toCharArray();
int n = s.length(), pos = 0;
while (pos < n) {
// 剩余字符串大于等于k的情况
if (pos + k < n) {
reverse(chars, pos, pos + k - 1);
} else {// 剩余字符串不足k的情况
reverse(chars, pos, n - 1);
}
pos += 2 * k;
}
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--;
}
}
}卡码网：0054.替换数字
java
import java.util.Scanner;
public class _0054_替换数字 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String s = scanner.next();
s = s.replaceAll("0", "number");
s = s.replaceAll("1", "number");
s = s.replaceAll("2", "number");
s = s.replaceAll("3", "number");
s = s.replaceAll("4", "number");
s = s.replaceAll("5", "number");
s = s.replaceAll("6", "number");
s = s.replaceAll("7", "number");
s = s.replaceAll("8", "number");
s = s.replaceAll("9", "number");
System.out.println(s);
}
public static void main2(String[] args) {
Scanner in = new Scanner(System.in);
String s = in.nextLine();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < s.length(); i++) {
if (Character.isDigit(s.charAt(i))) {
sb.append("number");
} else sb.append(s.charAt(i));
}
System.out.println(sb);
}
//为了还原题目本意，先把原数组复制到扩展长度后的新数组，然后不再使用原数组，原地对新数组进行操作。
public static void main3(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.next();
int len = s.length();
for (int i = 0; i < s.length(); i++) {
if (s.charAt(i) >= 0 && s.charAt(i) <= '9') {
len += 5;
}
}
char[] ret = new char[len];
for (int i = 0; i < s.length(); i++) {
ret[i] = s.charAt(i);
}
for (int i = s.length() - 1, j = len - 1; i >= 0; i--) {
if ('0' <= ret[i] && ret[i] <= '9') {
ret[j--] = 'r';
ret[j--] = 'e';
ret[j--] = 'b';
ret[j--] = 'm';
ret[j--] = 'u';
ret[j--] = 'n';
} else {
ret[j--] = ret[i];
}
}
System.out.println(ret);
}
}0151_翻转字符串里的单词
String ss[] = s.replaceAll**("\\s+", " ")****.trim().split(" ");**
//步骤1：字符串整体反转（此时其中的单词也都反转了）char[] initialArr = s.toCharArray();
reverse(initialArr, 0, s.length() - 1);
java
package com.question.solve.leetcode.programmerCarl2._04_strings;
public class _0151_翻转字符串里的单词 {
}
class Solution0151 {
public String reverseWords(String s) {
String ss[] = s.replaceAll("\\s+", " ").trim().split(" ");
StringBuilder sb = new StringBuilder();
for (int i = ss.length - 1; i >= 0; i--) {
if (i != 0) {
sb.append(new StringBuilder(ss[i])).append(" ");
continue;
}
sb.append(new StringBuilder(ss[i]));
}
return sb.toString();
}
public String reverseWords2(String s) {
s = s.replaceAll("\\s+", " ");
String str[] = s.trim().split(" ");
for (int i = 0, j = str.length - 1; i < str.length / 2; i++, j--) {
String temp = str[i];
str[i] = str[j];
str[j] = temp;
}
String result = "";
for (String x : str) {
result += x + " ";
}
result = result.trim();
return result;
}
}
class Solution0151_2 {
/**
* 不使用Java内置方法实现
* <p>
* 1.去除首尾以及中间多余空格
* 2.反转整个字符串
* 3.反转各个单词
*/
public String reverseWords(String s) {
// System.out.println("ReverseWords.reverseWords2() called with: s = [" + s + "]");
// 1.去除首尾以及中间多余空格
StringBuilder sb = removeSpace(s);
// 2.反转整个字符串
reverseString(sb, 0, sb.length() - 1);
// 3.反转各个单词
reverseEachWord(sb);
return sb.toString();
}
private StringBuilder removeSpace(String s) {
// System.out.println("ReverseWords.removeSpace() called with: s = [" + s + "]");
int start = 0;
int end = s.length() - 1;
while (s.charAt(start) == ' ') start++;
while (s.charAt(end) == ' ') end--;
StringBuilder sb = new StringBuilder();
while (start <= end) {
char c = s.charAt(start);
if (c != ' ' || sb.charAt(sb.length() - 1) != ' ') {
sb.append(c);
}
start++;
}
// System.out.println("ReverseWords.removeSpace returned: sb = [" + sb + "]");
return sb;
}
/**
* 反转字符串指定区间[start, end]的字符
*/
public void reverseString(StringBuilder sb, int start, int end) {
// System.out.println("ReverseWords.reverseString() called with: sb = [" + sb + "], start = [" + start + "], end = [" + end + "]");
while (start < end) {
char temp = sb.charAt(start);
sb.setCharAt(start, sb.charAt(end));
sb.setCharAt(end, temp);
start++;
end--;
}
// System.out.println("ReverseWords.reverseString returned: sb = [" + sb + "]");
}
private void reverseEachWord(StringBuilder sb) {
int start = 0;
int end = 1;
int n = sb.length();
while (start < n) {
while (end < n && sb.charAt(end) != ' ') {
end++;
}
reverseString(sb, start, end - 1);
start = end + 1;
end = start + 1;
}
}
}
//解法二：创建新字符数组填充。时间复杂度O(n)
class Solution0151_3 {
public String reverseWords(String s) {
//源字符数组
char[] initialArr = s.toCharArray();
//新字符数组
char[] newArr = new char[initialArr.length + 1];//下面循环添加"单词 "，最终末尾的空格不会返回
int newArrPos = 0;
//i来进行整体对源字符数组从后往前遍历
int i = initialArr.length - 1;
while (i >= 0) {
while (i >= 0 && initialArr[i] == ' ') {
i--;
} //跳过空格
//此时i位置是边界或!=空格，先记录当前索引，之后的while用来确定单词的首字母的位置
int right = i;
while (i >= 0 && initialArr[i] != ' ') {
i--;
}
//指定区间单词取出(由于i为首字母的前一位，所以这里+1,)，取出的每组末尾都带有一个空格
for (int j = i + 1; j <= right; j++) {
newArr[newArrPos++] = initialArr[j];
if (j == right) {
newArr[newArrPos++] = ' ';//空格
}
}
}
//若是原始字符串没有单词，直接返回空字符串；若是有单词，返回0-末尾空格索引前范围的字符数组(转成String返回)
if (newArrPos == 0) {
return "";
} else {
return new String(newArr, 0, newArrPos - 1);
}
}
}
//解法三：双反转+移位，String 的 toCharArray() 方法底层会 new 一个和原字符串相同大小的 char 数组，空间复杂度：O(n)
class Solution0151_4 {
/**
* 思路：
* ①反转字符串 "the sky is blue " => " eulb si yks eht"
* ②遍历 " eulb si yks eht"，每次先对某个单词进行反转再移位
* 这里以第一个单词进行为演示：" eulb si yks eht" ==反转=> " blue si yks eht" ==移位=> "blue si yks eht"
*/
public String reverseWords(String s) {
//步骤1：字符串整体反转（此时其中的单词也都反转了）
char[] initialArr = s.toCharArray();
reverse(initialArr, 0, s.length() - 1);
int k = 0;
for (int i = 0; i < initialArr.length; i++) {
if (initialArr[i] == ' ') {
continue;
}
int tempCur = i;
while (i < initialArr.length && initialArr[i] != ' ') {
i++;
}
for (int j = tempCur; j < i; j++) {
if (j == tempCur) { //步骤二：二次反转
reverse(initialArr, tempCur, i - 1);//对指定范围字符串进行反转，不反转从后往前遍历一个个填充有问题
}
//步骤三：移动操作
initialArr[k++] = initialArr[j];
if (j == i - 1) { //遍历结束
//避免越界情况，例如=> "asdasd df f"，不加判断最后就会数组越界
if (k < initialArr.length) {
initialArr[k++] = ' ';
}
}
}
}
if (k == 0) {
return "";
} else {
//参数三：以防出现如"asdasd df f"=>"f df asdasd"正好凑满不需要省略空格情况
return new String(initialArr, 0, (k == initialArr.length) && (initialArr[k - 1] != ' ') ? k : k - 1);
}
}
public void reverse(char[] chars, int begin, int end) {
for (int i = begin, j = end; i < j; i++, j--) {
chars[i] ^= chars[j];
chars[j] ^= chars[i];
chars[i] ^= chars[j];
}
}
}
/*
* 解法四：时间复杂度 O(n)
* 参考卡哥 c++ 代码的三步骤：先移除多余空格，再将整个字符串反转，最后把单词逐个反转
* 有别于解法一 ：没有用 StringBuilder 实现，而是对 String 的 char[] 数组操作来实现以上三个步骤
*/
class Solution0151_5 {
//用 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.用 快慢指针 去除首尾以及中间多余空格，可参考数组元素移除的题解
public char[] removeExtraSpaces(char[] chars) {
int slow = 0;
for (int fast = 0; fast < chars.length; fast++) {
//先用 fast 移除所有空格
if (chars[fast] != ' ') {
//在用 slow 加空格。 除第一个单词外，单词末尾要加空格
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;
}
//双指针实现指定范围内字符串反转，可参考字符串反转题解
public void reverse(char[] chars, int left, int right) {
if (right >= chars.length) {
System.out.println("set a wrong right");
return;
}
while (left < right) {
chars[left] ^= chars[right];
chars[right] ^= chars[left];
chars[left] ^= chars[right];
left++;
right--;
}
}
//3.单词反转
public void reverseEachWord(char[] chars) {
int start = 0;
//end <= s.length() 这里的 = ，是为了让 end 永远指向单词末尾后一个位置，这样 reverse 的实参更好设置
for (int end = 0; end <= chars.length; end++) {
// end 每次到单词末尾后的空格或串尾,开始反转单词
if (end == chars.length || chars[end] == ' ') {
reverse(chars, start, end - 1);
start = end + 1;
}
}
}
}卡码网：0055.右旋转字符串
java
package com.question.solve.leetcode.programmerCarl2._00_carlCode_kamaCoder;
import java.util.Scanner;
public class _0055_右旋转字符串 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();//2
String s = sc.next();//abcdefg->fgabcde
// char[] ss = s.toCharArray();
// char[] sss = s.toCharArray();
// for (int i = s.length() - 1; i >= 0; i--) {
// }
String s1 = s.substring(0, s.length() - num);
// System.out.println(s1);
String s2 = s.substring(s.length() - num, s.length());
// System.out.println(s2);
System.out.println(s2 + s1);
}
}
class Main1 {//版本一
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = Integer.parseInt(in.nextLine());
String s = in.nextLine();
int len = s.length();//获取字符串长度
char[] chars = s.toCharArray();
reverseString(chars, 0, len - 1); //反转整个字符串
reverseString(chars, 0, n - 1); //反转前一段字符串，此时的字符串首尾尾是0,n - 1
reverseString(chars, n, len - 1); //反转后一段字符串，此时的字符串首尾尾是n,len - 1
System.out.println(chars);
}
public static void reverseString(char[] ch, int start, int end) {
//异或法反转字符串，参照题目 344.反转字符串的解释
while (start < end) {
ch[start] ^= ch[end];
ch[end] ^= ch[start];
ch[start] ^= ch[end];
start++;
end--;
}
}
}
class Main2 {//版本二
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = Integer.parseInt(in.nextLine());
String s = in.nextLine();
int len = s.length();//获取字符串长度
char[] chars = s.toCharArray();
reverseString(chars, 0, len - n - 1); //反转前一段字符串，此时的字符串首尾是0,len - n - 1
reverseString(chars, len - n, len - 1); //反转后一段字符串，此时的字符串首尾是len - n,len - 1
reverseString(chars, 0, len - 1); //反转整个字符串
System.out.println(chars);
}
public static void reverseString(char[] ch, int start, int end) {
//异或法反转字符串，参照题目 344.反转字符串的解释
while (start < end) {
ch[start] ^= ch[end];
ch[end] ^= ch[start];
ch[start] ^= ch[end];
start++;
end--;
}
}
}ヾ(◍°∇°◍)ﾉﾞ❤加油~