day8

1、leetcode344 反转字符串

1. 代码实现【双指针法，原地修改数组】

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

2、leetcode541 反转字符串Ⅱ

1. 思路

   1. 在遍历字符串的过程中，只要让 i += (2 * k)，i 每次移动 2 * k 就可以了，然后判断是否需要有反转的区间。

2. 代码实现

   class Solution {
       public String reverseStr(String s, int k) {
           char[] chars= s.toCharArray();
           int length = chars.length;
           
           for(int i=0; i<length; i+=2*k){
               // 每隔 2k 个字符的前 k 个字符进行反转
               // 剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符
               if(i+k<length){
                   reverse(chars,i,i+k-1);
                   continue;
               }
               // 剩余字符少于 k 个，则将剩余字符全部反转。
               reverse(chars,i,length-1);
           }
   
           return String.valueOf(chars);
   
       }
   
   
       public void reverse(char[] s,int start,int end){//左闭右闭
           while(start<=end){
               char temp = s[end];
               s[end] = s[start];
               s[start] = temp;
               start++;
               end--;
           }
       }
   }
   

3、剑指Offer05 替换空格

1. 数组填充类问题

   1. 很多数组填充类的问题，都可以先预先给数组扩容带填充后的大小，然后在从后向前进行操作。
   2. 好处：
      1. 不用申请新数组。
      2. 从后向前填充元素，避免了从前向后填充元素时，每次添加元素都要将添加元素之后的所有元素向后移动的问题。

2. 代码实现

   class Solution {
       //方法一
       // public String replaceSpace(String s) {
       //     StringBuilder res = new StringBuilder();
       //     for(char c : s.toCharArray())
       //     {
       //         if(c == ' ') res.append("%20");
       //         else res.append(c);
       //     }
       //     return res.toString();
       // }
   
       //方法二：双指针法
       public String replaceSpace(String s) {
           int count = 0;
           int oldLength = s.length();
           //统计空格数量
           for(int i=0;i<oldLength;i++){
               if(s.charAt(i) == ' '){
                   count++;
               }
           }
   		
           //对字符串进行填充，填充至每个空格替换成"%20"之后的大小
           for(int i=0;i<count;i++){
               s = s + "  ";
           }
   
           int newSize = s.length();
           int left = oldLength-1;//从后向前填充
           int right = newSize -1;//从后向前填充
           char[] chars = s.toCharArray();
   
           while(left>=0){
               if(chars[left]!=' '){
                   chars[right]=chars[left];
                   left--;
                   right--;
               } else {//将空格替换为20%
                   chars[right] = '0';
                   chars[right-1] = '2';
                   chars[right-2] = '%';
                   left--;
                   right = right - 3;
               }
           }
   
           return String.valueOf(chars);
       }
   }
   

4、leetcode151 翻转字符串里的单词

1. 思路

   1. 移除多余空格
   2. 将整个字符串反转
   3. 将每个单词反转

2. 代码实现

   class Solution {
       public String reverseWords(String s) {
           char[] chars = s.toCharArray();
           chars = removeExtraSpaces(chars);//1、去除多余空格，保证单词之间之只有一个空格，且字符串首尾没空格。
           reverse(chars,0,chars.length-1);//2、翻转整个字符串
           //3、反转每个单词
           int start = 0;
           for(int i=0; i<=chars.length; ++i){
               if(i==chars.length || chars[i] ==' '){//到达空格或者串尾，说明一个单词结束。进行翻转。
                   reverse(chars,start,i-1);//翻转，注意是左闭右闭 []的翻转。
                   start = i+1;//更新下一个单词的开始下标start
               }
           }
           return String.valueOf(chars);
       }
   
       public void reverse(char[] chars,int left,int right){//左闭右闭
           while(left<=right){
               char temp = chars[right];
               chars[right] = chars[left];
               chars[left] = temp;
               right--;
               left++;
           }
       }
   
       //用 快慢指针 去除首尾以及中间多余空格
       public char[] removeExtraSpaces(char[] chars){
           int slow = 0;
           for(int fast=0; fast<chars.length; fast++){
               if(chars[fast]!=' '){
                   if(slow != 0){
                       chars[slow] = ' ';
                       slow++;
                   }
                   while(fast<chars.length && chars[fast]!=' '){
                       chars[slow] = chars[fast];
                       slow++;
                       fast++;
                   }
               }
           }
           char[] newChars = new char[slow];
           System.arraycopy(chars, 0, newChars, 0, slow); 
           return newChars;
       }
   }
   

5、剑指offer58-Ⅱ 左旋转字符串

1. 用substring

2. 不能申请额外空间，只能在本串上操作。【整体反转+局部反转】

   1. 反转区间为前n的子串
   2. 反转区间为n到末尾的子串
   3. 反转整个字符串
   4. 最后就可以达到左旋n的目的，而不用定义新的字符串，完全在本串上操作。

3. 代码实现

   class Solution {
       //方法一
       // public String reverseLeftWords(String s, int n) {
       //     String s1 = s.substring(n,s.length());
       //     String s2 = s.substring(0,n);
       //     return s1+s2;
       // }
   
       //方法二【整体反转+局部反转】
       public String reverseLeftWords(String s, int n) {
           char[] chars = s.toCharArray();
           reverse(chars,0,n-1);
           reverse(chars,n,chars.length-1);
           reverse(chars,0,chars.length-1);
           return String.valueOf(chars);
       }
   
   
       public void reverse(char[] chars,int left,int right){
           while(left<=right){
               char temp = chars[right];
               chars[right] = chars[left];
               chars[left] = temp;
               right--;
               left++;
           }
       }
   }