class Solution {
public void reverseString ( char [ ] s) {
char tmp;
for ( int i = 0 , j = s. length - 1 ; i < s. length && j > 0 && i <= j; i++ , j-- ) {
tmp = s[ i] ;
s[ i] = s[ j] ;
s[ j] = tmp;
}
}
}
思路
还是要注意读懂题目，找到解题的窍门；
看起来有k和2k左右两个判断条件，其实只有一个k的判断条件，因为不论最后一次循环有多少个元素，始终只要反转0-k个元素。
class Solution {
public String reverseStr ( String s, int k) {
char [ ] chars = s. toCharArray ( ) ;
for ( int i = 0 ; i < chars. length; i += 2 * k) {
int start = i;
int end = Math . min ( chars. length - 1 , start + k - 1 ) ;
while ( start < end) {
char tmpChar = chars[ start] ;
chars[ start] = chars[ end] ;
chars[ end] = tmpChar;
start++ ;
end-- ;
}
}
return new String ( chars) ;
}
}
思路
题目完成很简单，但为了锻炼双指针还是有点难度的；
学习了一下关于StringBulider的相关知识：
StringBuilder 是 Java 中的一个类，位于 java.lang 包下，用于处理字符串的可变对象。与 String 类不同，StringBuilder 允许在不创建新对象的情况下修改字符串内容。这种可变性使得在处理大量字符串拼接或修改的情况下，StringBuilder 比直接使用 String 更加高效，因为避免了不断创建新的字符串对象。
以下是 StringBuilder 的一些主要特点和用法：
可变性： StringBuilder 对象的内容可以被修改，包括添加、插入、删除字符等操作，而不会创建新的对象。
效率： 由于可变性，StringBuilder 在执行大量字符串拼接或修改时比 String 更加高效。这是因为在 String 中每次修改都需要创建一个新的字符串对象，而 StringBuilder 可以在原有对象的基础上进行修改。
线程不安全： StringBuilder 不是线程安全的，因此在多线程环境下使用时需要进行额外的同步处理。如果需要线程安全的可变字符串，可以使用 StringBuffer 类，它提供了与 StringBuilder 类似的功能，但是所有的公共方法都是同步的。
常见方法： StringBuilder 提供了一系列方法用于字符串的操作，包括 append() 用于追加字符串、insert() 用于在指定位置插入字符串、delete() 用于删除字符、substring() 用于提取子串等。
class Main {
public static void main ( String [ ] args) {
String s = "a1b2c3" ;
Solution solution = new Solution ( ) ;
String result = String . valueOf ( solution. reverseStr ( s) ) ;
System . out. println ( result) ;
}
}
class Solution {
public StringBuilder reverseStr ( String s) {
char [ ] chars = s. toCharArray ( ) ;
StringBuilder newS = new StringBuilder ( ) ;
for ( int i = 0 ; i < chars. length; i++ ) {
if ( Character . isDigit ( chars[ i] ) ) {
newS. append ( "number" ) ;
} else {
newS. append ( chars[ i] ) ;
}
}
return newS;
}
}
思路
删除字符串前后的空格：trim()返回的是String；
移除收尾的很简单了，定义开始结束的指针，开头是空格，开始指针+1，结尾同理-1，这个可以用trim代替；
其他的都要考虑自己实现一下；
回顾了一下移除元素的算法，变种可以实现移除中间元素；
这题利用StringBulider应该会更好的练习对字符串的理解；
public class StringStructure {
public static void main ( String [ ] args) {
String s = " hello world abc" ;
Solution solution = new Solution ( ) ;
String result = solution. reverseWords ( s) ;
System . out. println ( result) ;
}
}
class Solution {
public String reverseWords ( String s) {
String trimmedString = s. trim ( ) ;
String eraseMidSpaceString = eraseMidSpace ( trimmedString) ;
String reverseString = reverse ( eraseMidSpaceString) ;
return reverseEveryWord ( reverseString) ;
}
public String eraseMidSpace ( String s) {
char target = ' ' ;
char [ ] charS = s. toCharArray ( ) ;
int slow = 1 , fast = 1 ;
while ( fast < s. length ( ) ) {
if ( charS[ fast] == target && charS[ slow - 1 ] == target) {
fast++ ;
continue ;
}
charS[ slow] = charS[ fast] ;
slow++ ;
fast++ ;
}
char [ ] resultS = new char [ slow] ;
for ( int i = 0 ; i < slow; i++ ) {
resultS[ i] = charS[ i] ;
}
return new String ( resultS) ;
}
public String reverse ( String s) {
char [ ] charS = s. toCharArray ( ) ;
for ( int i = 0 , j = s. length ( ) - 1 ; i < s. length ( ) && j > 0 && i <= j; i++ , j-- ) {
char tmp = charS[ i] ;
charS[ i] = charS[ j] ;
charS[ j] = tmp;
}
return new String ( charS) ;
}
public String reverseEveryWord ( String s) {
char [ ] charS = s. toCharArray ( ) ;
for ( int i = 0 , start = 0 ; i < s. length ( ) ; i++ ) {
if ( charS[ i] == ' ' ) {
for ( int j = start, k = i - 1 ; j < i && k > start && j <= k; j++ , k-- ) {
char tmp = charS[ j] ;
charS[ j] = charS[ k] ;
charS[ k] = tmp;
}
start = i + 1 ;
} else if ( i + 1 == s. length ( ) ) {
for ( int j = start, k = i; j <= i && k > start && j <= k; j++ , k-- ) {
char tmp = charS[ j] ;
charS[ j] = charS[ k] ;
charS[ k] = tmp;
}
break ;
}
}
return new String ( charS) ;
}
}
思路
写完通过直接去看答案了。。。。。。
然后才注意到升级了难度。。。。。。
如果有二刷，需要注意升级难度
import java. util. Scanner ;
class Main {
public static void main ( String [ ] args) {
Scanner in = new Scanner ( System . in) ;
int k = Integer . parseInt ( in. nextLine ( ) ) ;
String s = in. nextLine ( ) ;
Solution solution = new Solution ( ) ;
String result = solution. reverseWords ( s, k) ;
System . out. println ( result) ;
}
}
class Solution {
public String reverseWords ( String s, int k) {
StringBuilder sb = new StringBuilder ( ) ;
for ( int i = s. length ( ) - k; i < s. length ( ) ; i++ ) {
sb. append ( s. charAt ( i) ) ;
}
for ( int i = 0 ; i < s. length ( ) - k; i++ ) {
sb. append ( s. charAt ( i) ) ;
}
return sb. toString ( ) ;
}
}
