day07 344.反转字符串&&541. 反转字符串II&&54. 替换数字（第八期模拟笔试）&&151.翻转字符串里的单词&&55. 右旋字符串（第八期模拟笔试）

1. 反转字符串（344. Reverse String）
   功能：反转一个字符数组。
   优化点：
   使用双指针（i 和 s.length - 1 - i）交换字符，时间复杂度为 O(n)，空间复杂度为 O(1)。
   代码简洁高效，无需额外优化。
   //344.反转字符串
   public void reverseString(char[] s) {
   for (int i = 0; i < s.length / 2; i++) {
   char temp = s[i];
   s[i] = s[s.length - 1 - i];
   s[s.length - 1 - i] = temp;
   }
   }

2. 反转字符串 II（541. Reverse String II）
   功能：每 2k 个字符中，反转前 k 个字符。
   优化点：
   使用双指针交换字符，避免了多余的临时变量。
   通过 Math.min 处理边界情况，确保不会越界。
   时间复杂度为 O(n)，空间复杂度为 O(1)。
   //541. 反转字符串II
   public String reverseStr(String s, int k) {
   //繁琐且效率不高
   /char[] chars = s.toCharArray();
   int len = chars.length;
   if(len==0){
   return s;
   } else if (len < k) {
   for (int j = 0; j < len/2; j++) {
   char temp = chars[j];
   chars[j] = chars[len - 1 - j];
   chars[len - 1 - j] = temp;
   }
   return String.valueOf(chars);
   } else if (len<2k) {
   for (int j = 0; j < k / 2; j++) {
   char temp = chars[j];
   chars[j] = chars[j + k-1 - j];
   chars[j + k-1 - j] = temp;
   }
   return String.valueOf(chars);
   }
   int count = 0;
   for (int i = 0; i < len; i++) {
   count += 1;
   if (count == 2 * k) {
   int c = 0;
   for (int j = i - 2 * k + 1; j < i - 2 * k + 1 + k / 2; j++) {
   char temp = chars[j];
   chars[j] = chars[i - k - c];
   chars[i - k - c] = temp;
   c++;
   }
   int num = len - i - 1;
   if (num == 0) {
   return String.valueOf(chars);
   } else if ((num) < k) {
   int c1 = 0;
   for (int j = i + 1; j < i + 1 + num / 2; j++) {
   char temp = chars[j];
   chars[j] = chars[len - 1 - c1];
   chars[len - 1 - c1] = temp;
   c1++;
   }
   return String.valueOf(chars);
   } else if (num < 2 * k) {
   int c2 = 0;
   for (int j = i + 1; j < i + 1 + k / 2; j++) {
   char temp = chars[j];
   chars[j] = chars[i + k - c2];
   chars[i + k - c2] = temp;
   c2++;
   }
   return String.valueOf(chars);
   }
   count = 0;
   }
   }
   return new String(chars);/
   //优化后代码
   char[] chars = s.toCharArray();
   int len = chars.length;
   // 遍历字符串，每次处理2k个字符
   for (int i = 0; i < len; i += 2 * k) {
   // 反转前k个字符
   int start = i; // 当前段的起始位置
   int end = Math.min(i + k - 1, len - 1); // 当前段的结束位置（不超过字符串长度）
   while (start < end) {
   char temp = chars[start];
   chars[start] = chars[end];
   chars[end] = temp;
   start++;
   end--;
   }
   }
   return new String(chars);
   /效率最高（因为某些特定的测试用例或环境因素导致的。）
   char[] c = s.toCharArray();
   for(int i = 0; i < c.length; i += 2* k) {
   //如果剩余字符少于k个，则将剩余字符全部反转
   if(c.length - i < k) {
   reverse(i, c.length - 1,c);
   }else {
   //如果剩余字符小于2k但大于或等于k，则反转前k个
   reverse(i, i + k - 1, c);
   }

    }
    return String.valueOf(c);
   

   }

   public void reverse(int left,int right,char[] c) {
   while(left < right) {
   char tmp = c[left];
   c[left] = c[right];
   c[right] = tmp;
   left++;
   right--;
   }
   * */
   }

3. 替换字符串中的数字（第八期模拟笔试）
   功能：将字符串中的非小写字母字符替换为 "number"。
   优化点：
   使用 StringBuilder 拼接字符串，避免多次创建新的字符串对象。
   时间复杂度为 O(n)。
   改进建议：
   如果输入字符串很长，可以考虑直接操作字符数组，避免额外的字符串构建。
   //54. 替换数字（第八期模拟笔试）
   public String replaceString(String s) {
   char[] chars = s.toCharArray();
   StringBuilder sb = new StringBuilder();
   for (char aChar : chars) {
   if (aChar >= 'a' && aChar <= 'z') {
   sb.append(aChar);
   } else {
   sb.append("number");
   }
   }
   return sb.toString();
   }

4. 翻转字符串里的单词（151. Reverse Words in a String）
   功能：反转字符串中的单词顺序。
   优化点：
   避免使用正则表达式，直接操作字符数组，减少字符串分割和拼接的开销。
   时间复杂度为 O(n)，空间复杂度为 O(n)。
   //151.翻转字符串里的单词
   public String reverseWords(String s) {
   //利用正则表达式切割处理，代码量虽少，但效率不高，6ms
   /String[] split = s.trim().split("\s+");
   StringBuilder sb = new StringBuilder();
   for (int i = split.length - 1; i > 0; i--) {
   sb.append(split[i]).append(" ");
   }
   sb.append(split[0]);
   return sb.toString();/
   //1ms
   char[] oldArr=s.toCharArray();
   int oldPos=oldArr.length-1;
   char[] newArr=new char[oldArr.length+1];
   int newPos=0;
   while(oldPos>=0){
   while(oldPos>=0&&oldArr[oldPos]' '){
   oldPos--;
   }
   if(oldPos<0){
   break;
   }
   int right=oldPos;//结尾的单词字母下标
   while(oldPos>=0&& oldArr[oldPos]!=' '){
   oldPos--;
   }
   int left=oldPos+1;//单词首字母下标开头
   while(left<=right){
   newArr[newPos]=oldArr[left];
   newPos++;
   left++;
   }
   newArr[newPos]=' ';
   newPos++;
   }
   if(newPos0){
   return "";
   }
   else{
   return new String(newArr,0,newPos-1);
   }
   }

5. 右旋字符串（第八期模拟笔试）
   功能：将字符串右旋 k 个字符。
   优化点：
   使用字符数组操作，避免多次字符串拼接。
   时间复杂度为 O(n)，空间复杂度为 O(n)。
   //55. 右旋字符串（第八期模拟笔试）
   public static String dextralString(String s,int k) {
   int len = s.length();
   if(len<=k){
   return s;
   }
   char[] chars = s.toCharArray();
   char[] res=new char[len];
   int newPos=0;
   for(int j=len-k;j<len;j++){
   res[newPos++]=chars[j];
   }
   for(int j=0;newPos<len;j++){
   res[newPos++]=chars[j];
   }
   return new String(res);
   }