概述
字符串和数组一样算是比较简单的题目，正适合打算法基础，一定要认真对待！！！
字符串类型的算法问题可以分为简单、中等和困难的难度级别，基础类型一些基本的字符串处理问题，如字符串的拼接、反转、查找子串等，通常比较容易。更复杂的问题，如字符串匹配、编辑距离、回文检测、子序列问题等，难度可能会增加。
一些字符串算法问题可能涉及到高级的数据结构和算法，如动态规划、字符串匹配算法（KMP、Boyer-Moore 等）、后缀数组、正则表达式等。这些问题可能对算法和数据结构的理解要求较高，可能会更具挑战性，所以，要先打好字符串基础。
典型题目
反转字符串
//送分题，不说了
class 字符串反转344{
public void reverseString(char[] s) {
char temp=' ';
for (int i = 0; i <s.length/2 ; i++) {
temp=s[i];
s[i]=s[s.length-1-i];
s[s.length-1-i]=temp;
}
System.out.println(s);
}
}
反转字符串II
给定一个字符串 s 和一个整数 k，从字符串开头算起, 每计数至 2k 个字符，就反转这 2k 个字符中的前 k 个字符。
如果剩余字符少于 k 个，则将剩余字符全部反转。
如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。
示例:
输入: s = “abcdefg”, k = 2
输出: “bacdfeg”
思路：
- 将字符串转换为字符数组，因为字符串是不可变的，而字符数组可以修改。
- 遍历字符数组，每次处理 2k 长度的子字符串。
- 对每个 2k 长度的子字符串，反转前 k 个字符，如果剩余字符不足 k 个，则将其全部反转。
- 返回最终的字符数组作为结果。
先把按顺序反转每2k个字符的前k个，并判断此时剩余的是否大于k个
题目重点：判断此时剩余字符大于2k还是小于2k大于k，还是小于k；
精华：int right = Math.min(i + k - 1, n - 1);
解释：i每次加2k，加完判断此时右侧是2k为边界还是以字符串最终长度n为边界，n为总长度
class 反转字符串II {
public String reverseStr(String s, int k) {
char[] charArray = s.toCharArray();//把字符串转换成字符数组存起来
int n = s.length();
for (int i = 0; i < n; i += 2 * k) {//每次加2k个
int left = i;
int right = Math.min(i + k - 1, n - 1); // 反转的前 k 个字符
// i每次加2k，加完判断此时右侧是2k为边界还是以字符串最终长度n为边界，
// 这样写可以直接包含最后剩的数k<x<2k,和0<x<k这两种情况，即
// 1.当k<x<2k时，边界不变，正常运行，i会再次加2k，发现大于n，直接退出；
// 2.当0<x<k时，右边界直接是n-1，反转剩余所有字符串，之后加2k大于n，退出
while (left < right) {
//左侧大于右侧才反转操作，设定左右双指针
char temp = charArray[left];
charArray[left] = charArray[right];
charArray[right] = temp;
left++;
right--;
}
}
return new String(charArray);
}
}
替换空格
请实现一个函数，把字符串 s 中的每个空格替换成"%20"。
示例 1： 输入：s = “We are happy.”
输出：“We%20are%20happy.”
思路：
1.肯定是要先搞一个字符数组储存字符串，
注意点！！！选用扩容而不是建新数组的方式
就是先遍历判断空格，遇到空格，就在字符串后边新添加两个空格。
之后用用双指针最简单，左右指针指向原字符串和新字符串结尾，并向左遍历，直到left=righ时，退出。
代码示例不一定对（原题被更改了，无法判断对错哦）
public class 替换空格II {
//双指针！！一定要记得熟练使用哦！
public String pathEncryption(String path) {
int a=0;
char []b = path.toCharArray();
for (int i = 0; i <b.length; i++) {
if(b[i] ==' ')
a=a+2;
}
a=a+b.length;
char[] c =new char[a];
int left=b.length-1;
int right=c.length-1;
while (left!=right) {
for ( left =b.length-1; left >=0 ; left--,right--) {
if(b[left]!=' ')c[right]=b[left];
if(b[left]==' ')
{c[right]='0';
c[right--]='2';
c[right--]='%';
}
}
}
return new String(c);
}
}
翻转字符串里的单词
给定一个字符串，逐个翻转字符串中的每个单词。
示例 1：
输入: “the sky is blue”
输出: “blue is sky the”
思路：使用 trim 方法去除前导和尾随空格，然后使用正则表达式 \\s+ 将单词间的多个空格替换为单个空格。接下来，将字符串按照空格分割成单词数组，然后构建新的字符串，逆序连接单词，并使用单个空格分隔。最后返回转换后的字符串。
这居然是简单题…不知道调方法的不得难受死。。
public class 翻转字符串里的单词 {
//高级做法
public String reverseMessage(String message) {
// 去除前导空格和尾随空格，以及单词间的多个空格
String a = message.trim().replaceAll("\\s+", " "); //重要
// 将字符串按空格分割成单词数组
String[] words = a.split(" ");
// 构建新的字符串，逆序连接单词，并使用单个空格分隔
StringBuilder b = new StringBuilder();
for (int i = words.length - 1; i >= 0; i--) {
b.append(words[i]);
if (i > 0) {
b.append(" ");
}
}
return b.toString();
}
}
右旋字符串
字符串的右旋转操作是把字符串尾部的若干个字符转移到字符串的前面。给定一个字符串 s 和一个正整数 k，请编写一个函数，将字符串中的后面 k 个字符移到字符串的前面，实现字符串的右旋转操作。
例如，对于输入字符串 “abcdefg” 和整数 2，函数应该将其转换为 “fgabcde”。
输入：输入共包含两行，第一行为一个正整数 k，代表右旋转的位数。第二行为字符串 s，代表需要旋转的字符串。
输出：输出共一行，为进行了右旋转操作后的字符串。
立扣上没有，。
public class 右旋字符串 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int k = scanner.nextInt();
String s = scanner.next();
// 检查输入的合法性
if (s == null || s.isEmpty()) {
System.out.println("Invalid input: String cannot be null or empty.");
return;
}
// 计算右旋转后的字符串
String result = rightRotateString(s, k);
// 输出结果
System.out.println(result);
}
private static String rightRotateString(String s, int k) {
int n = s.length();
// 如果 k 大于字符串长度，取余确保在合理范围内
k = k % n;
// 将字符串分为两部分，并交换它们的顺序
String part1 = s.substring(n - k);
String part2 = s.substring(0, n - k);
// 拼接两部分得到结果
return part1 + part2;
}
}
strStr
给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回 -1 。
//菜鸡写法。。。。。
public class strStr找出字符串中第一个匹配项的下标 {
public int strStr(String haystack, String needle) {
if (needle == null) return 0;
if (needle.length() > haystack.length()) return -1;
int a = needle.length();
String b;
for (int i = 0; i <= haystack.length() - needle.length(); i++) {
if (haystack.charAt(i) == needle.charAt(0)) {
b = "";
for (int j = 0; j < needle.length(); j++) {
if (haystack.charAt(i + j) == needle.charAt(j)) {
b = b + needle.charAt(j);
} else break;
}
if (b.equals(needle))
return i;
}
}
return -1;
}
}
//滑动窗口写法
public class StrStrExample {
public static int strStr(String haystack, String needle) {
int n = haystack.length();
int m = needle.length();
// 边界情况处理
if (m == 0) {
return 0;
}
if (n < m) {
return -1;
}
// 使用滑动窗口进行匹配
for (int i = 0; i <= n - m; i++) {
int j;
// 在窗口内逐个比较字符
for (j = 0; j < m; j++) {
if (haystack.charAt(i + j) != needle.charAt(j)) {
break;
}
}
// 如果循环正常结束，说明找到了匹配
if (j == m) {
return i;
}
}
// 没有找到匹配
return -1;
}
}
两种方法的时间复杂度差了很多，原因可能是第一种多次使用了
b = b + needle.charAt(j);
在Java中，字符串是不可变的，每次进行字符串拼接实际上都会创建一个新的字符串对象
重复的子字符串
给定一个非空的字符串，判断它是否可以由它的一个子串重复多次构成。给定的字符串只含有小写英文字母，并且长度不超过10000。
示例 1:
- 输入: “abab”
- 输出: True
- 解释: 可由子字符串 “ab” 重复两次构成。
示例 2:
- 输入: “aba”
- 输出: False
思路：刚看到的时候肯定很懵逼，无从下手，没有经验的话，想了之后也只能想到，从第一个字符开始当子串遍历，不断增加子串的长度，直到遍历一半才结束，时间复杂度很高。
特定做法：kmp或移动匹配，kmp太难，先不讲了，说移动匹配，
意思是将整串s*2，接在s的后边，并去除新接字符串的第一个和最后一个字符，如果新串中还存在s那么说明s肯定是由重复子字符串构成的。
自己仔细想想
菜鸡写法
public boolean repeatedSubstringPattern(String s) {
String a= (s+s).substring(1,2*s.length()-1);
// String b= "";
// int j=0;
// for (int i = 0; i <=a.length()-s.length(); i++) {
// if(a.charAt(i)==s.charAt(0))
// for ( j = 0; j <s.length() ; j++) {
// if(a.charAt(i+j)!=s.charAt(j))
// break;
// }
// if(j==s.length())
// return true;
// }
正常写法：
public boolean repeatedSubstringPattern(String s) {
String a= (s+s).substring(1,2*s.length()-1);
return a.contains(s);
}
1056
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
