代码随想录算法训练营第八天|344.反转字符串 541. 反转字符串II 剑指Offer 05.替换空格 151.翻转字符串里的单词 剑指Offer58-II.左旋转字符串

344. Reverse String

这个挺简单双指针不说了

541. Reverse String II

这个自己思路跟卡哥不一样，自己的偏暴力一点，但是卡哥那个面试的时候估计想不到

class Solution {
    public String reverseStr(String s, int k) {
        int index = 0;
        StringBuilder res = new StringBuilder(); 
        while( s.length()- index >= 2 *k){
          // pick every "2k";
            String newS = s.substring(index, index + 2*k);
          // reverse "first k"
            newS  = helper(newS, k);
            res.append(newS);
            index += 2 * k;
        }
      // deal with tails
      if( res.length() < s.length()){
        int num = s.length() - res.length();
        String tail = s.substring(s.length() - num);
        // reverse "first k" if tail.length() >=k
        if( tail.length() >= k){
          tail = helper(tail, k);       
        // if tail.length() < k, all reverse;  
        }else{
          tail = helper(tail, tail.length());
        }
        // concat tail
          res.append(tail);
      }
        return new String(res);
    }

     // reverse first k in in String s.
     private String helper(String s , int k){
        String firstPart = s.substring(0, k);
        return new StringBuffer(firstPart).reverse().toString() + s.substring(k);
    }        
}

• 卡哥这个确实很优雅
  • 遍历数组判断 剩下数组长度
    • 够不够K, index + k > len ?(可以理解成下标: index + (k -1) > len -1 ?)
      • 如果够( 情况)，reverse s.substring(index, index +k)
      • 如果不够(情况)， reverse s.substring(index, len)
    • reverse后的 string 接到 res 上
    • 够不够2K index + 2 * k > len ?
      • 如果够， 把第二个k长度的String 不reverse直接拼接倒res上
      • 如果不够，把剩下长度的String 不reverse直接拼接倒res上

• java
  class Solution {
      public String reverseStr(String s, int k) {
          StringBuffer res = new StringBuffer();
          int index = 0;
          int len = s.length();
          
          while( index < len){
              StringBuffer temp = new StringBuffer();
              // 够不够K, index + k > len ?(可以理解成下标: index + (k -1) > len -1 ?)
              int firstK = (index + k) > len ? len : index + k;
              
              int secondK = (index + 2 * k) > len ? len : index + 2* k;
  
  
              // 如果够(`len >= index + k` 情况)，reverse s.substring(index, index +k)
             // 如果不够(`len < index +k`情况)， reverse  s.substring(index, len)
              temp.append(s.substring(index, firstK));
             // reverse后的 string 接到 res 上
              res.append(temp.reverse());
  
  
             // 够不够2K
            //- 如果够， 把第二个k长度的String 不reverse直接拼接倒res上
            //- 如果不够，把剩下长度的String 不reverse直接拼接倒res上
  
            
              if (firstK < secondK){
                  res.append(s.substring(firstK, secondK));
                  
              }
              index += 2 * k;
              
          }
          return res.toString();
      }
  }

 151. Reverse Words in a String

 

• 思路
  • 先去空格
    • 开头结尾空格简单
    • 中间多余的空格
      • 遍历字母
        • 如果非空
          • append
        • 如果为空
          • 检查stringBuilder的最后一位是否为空
            • 如果不为空则说明是第一个空格，append
            • 为空就是多余空格
  • 然后整个String(StringBuilder)反转
    • 双指针一头一尾，用temp变量暂存进行交换
  • 最后反转各个单词
    • 快慢指针
      • 快指针r遍历到空格的时， 反转[l,r)范围内的String
      • l = r+1;
      • r= l+1;

• class Solution {
      public String reverseWords(String s) {
          // remove imporper sapce
          StringBuilder sb = removeSpace(s);
          reverseString(sb, 0, sb.length() - 1);
          reverseWords(sb);
          return sb.toString();
          
      }
      
      private StringBuilder removeSpace(String s){
          int l = 0;
          int r = s.length() - 1;
          //remove space at head and tail
          while(s.charAt(l) == ' '){
              l++;
          }
          while(s.charAt(r) == ' '){
              r--;
          }
          // remove imporper space between each words
          StringBuilder sb = new StringBuilder();
          while( l <= r){
              //append the each char and the 1st space between each char
              char c = s.charAt(l);
              if( c != ' ' || sb.charAt(sb.length() - 1) != ' '){
                  sb.append(c);
              }
              l++;
          }
          return sb;
      }
      
      private void reverseString(StringBuilder sb, int l, int r){
          while( l < r){
              char temp = sb.charAt(l);
              sb.setCharAt(l, sb.charAt(r));
              sb.setCharAt(r, temp);
              l++;
              r--;
          }
      }
      
      private void reverseWords(StringBuilder sb){
          int l = 0;
          int r = 1;
          int n = sb.length();
          while(l < n){
              while( r < n && sb.charAt(r) != ' '){
                  r++;
              }
              reverseString(sb, l, r - 1);
              l = r + 1;
              r = l + 1;
          }
      }     
  }

 剑指 Offer 05. 替换空格

这题挺简单

class Solution {
    public String replaceSpace(String s) {
        StringBuilder str = new StringBuilder();
        for(int i = 0; i < s.length(); i++){
            if(s.charAt(i) == ' '){
                str.append("%20");
            }
            else{
                str.append(s.charAt(i));
            }
        }
        return String.valueOf(str);
    }
}
//TC On
//SC On

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

• 思路
  • 两个StringBuilder
  • 一个存前K个
  • 一个存后K个
  • 两个concat一下

  • java
    class Solution {
        public String reverseLeftWords(String s, int n) {
            StringBuilder beforeK = new StringBuilder();
            StringBuilder afterK = new StringBuilder();
            int index = 0;
            while(index < s.length()){
                char c = s.charAt(index);
                if(index < n){
                    beforeK.append(c);
                }else{
                    afterK.append(c);
                }
                index++;
            }
            return afterK.toString() + beforeK.toString();
    
        }
    }

  • 卡哥思路
    • 前K个reverse
    • 后K个reverse
    • 整体reverse

    • java
      class Solution {
          public String reverseLeftWords(String s, int n) {
              StringBuilder sb = new StringBuilder(s);
              reverse(sb, 0 ,n -1);
              reverse(sb, n, s.length() - 1);
              reverse(sb, 0, s.length() - 1); 
              return sb.toString();
      
          }
          private StringBuilder reverse(StringBuilder sb, int start, int end){
              while( start < end){
                  char temp = sb.charAt(start);
                  sb.setCharAt(start++, sb.charAt(end));
                  sb.setCharAt(end--, temp);
              }
              return sb;
          }
      }