lc字符串（反转|替换）

344.反转字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
解题思路：使用双指针进行遍历交换

class Solution {
    public void reverseString(char[] s) {
     int right=s.length-1;//right>s.length/2
     for(int left=0;left<s.length/2;left++){
         char temp=s[left];
         s[left]=s[right];
         s[right]=temp;
         right--;
     }
    }
}

541.反转字符串

给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。
如果剩余字符少于 k 个，则将剩余字符全部反转。
如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。

class Solution {
    public String reverseStr(String s, int k) {
        char[] chars = s.toCharArray();
        int len = chars.length;
        int start = 0;
        while (len > 0) {
            if (len < k) {
                reversePartStr(chars, start, chars.length - 1);
                break;
            } else if ((len >= k) && (len < 2 * k)) {
                reversePartStr(chars, start, start + k - 1);
                break;
            } else {
                reversePartStr(chars, start, start + k - 1);
                len -= 2 * k;
                start += 2 * k;
            }
        }
        return String.valueOf(chars);
    }
 
    public void reversePartStr(char[] chars, int start, int end) {
        if (start > end) {
            return;
        }
        int temp = (end - start + 1) / 2;
        for (int i = start; i < start + temp; i++) {
            char mob = chars[i];
            chars[i] = chars[end];
            chars[end] = mob;
            end--;
        }
    }
}

剑指offer 05.替换空格

请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

class Solution {
        public String replaceSpace(String s) {
       StringBuffer buffer=new StringBuffer(s);
       for(int i=0;i<buffer.length();i++){
           if(' '== buffer.charAt(i)){
               buffer.replace(i,i+1,"%20");
           }
       }
       return buffer.toString();
    }
}

151.反转字符串中的单词

给你一个字符串 s ，请你反转字符串中 单词 的顺序。
单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。
返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。

注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。

解题思路：
1、移除多余空格
2、将整个字符串反转
3、 将每个单词反转

class Solution {
        public String reverseWords(String s) {
        StringBuilder builder=deleteSpce(deleteSAndE(s));//移除多余空格
        builder.reverse();// 反转整个StringBuilder
        // 对整个反转的StringBuilder继续处理
        // 再将每个单词反转回来
        int i=0;
        while (i<builder.length()){
            int j=i;
            while (j<builder.length() && builder.charAt(j)!= ' '){//到第一个单词最末尾，也就是空格时停下，存储这个单词
                j++;
            }
            char[] chars=builder.substring(i,j).toCharArray();// 存储每个单词
            reverseChars(chars);//反转单词
            builder.replace(i,j,String.valueOf(chars));
            i=j+1;
        }
        return builder.toString();

    }
    private void reverseChars(char[] chars){
        for(int i=0;i<chars.length/2;i++){
            char temp=chars[i];
            chars[i]=chars[chars.length-1-i];
            chars[chars.length-1-i]=temp;

        }
    }
    private StringBuilder deleteSpce(String s){    // 去除中间多余的空格
     StringBuilder sb=new StringBuilder();
     for(int i=0;i<s.length();i++){
         if(s.charAt(i)!=' '){
             sb.append(s.charAt(i));
         }else{
             if(s.charAt(i+1)!= ' '){
                 sb.append(' ');//如果空格只有一个，就添加这个空格
             }
         }
         }
         return sb;
     }

    private String deleteSAndE(String s){//去除左边及右边空格
        int left=0;
        int right=s.length()-1;
        while (s.charAt(left)==' '){
            left++;
        }
        while (s.charAt(right)==' '){
            right--;
        }
        return s.substring(left,right+1);
    }
}

剑指offer 58-II.左旋转字符串

字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。
解题思路：
1、翻转前n个字符串 ab->ba
2、翻转剩下的字符串 cdefg->gfedc
3、翻转整个字符串 bagfedc->cdrfgab

class Solution {
       public String reverseLeftWords(String s, int n) {
      char[] chars=s.toCharArray();
      reverceChar(chars,0,n-1);
      reverceChar(chars,n,s.length()-1);
      reverceChar(chars,0,s.length()-1);
      return new String(chars);
    }
    public static void reverceChar(char[] chars,int start,int end){
        if(start>=end){
            return;
        }
        int mid=(start+end+1)/2;
        while (start<mid){
            char temp=chars[start];
            chars[start]=chars[end];
            chars[end]=temp;
            start++;
            end--;
        }
    }
}