【代码随想录刷题笔记】DAY8 344.反转字符串 541. 反转字符串II 剑指Offer 05.替换空格 151.翻转字符串里的单词 剑指Offer58-II.左旋转字符串

344.反转字符串 

题目链接/文章讲解/视频讲解：代码随想录

//双指针
//该字符串类型是char[]数组, 可以通过s[i] access字母
class Solution {
    public void reverseString(char[] s) {
        int left = 0, right = s.length - 1;
        while(right > left) {
            char temp = s[left];
            s[left] = s[right];
            s[right] = temp;
            right--;
            left++;    
        }
    }
}

541. 反转字符串II

题目链接/文章讲解/视频讲解：代码随想录

所以当需要固定规律一段一段去处理字符串的时候，要想想在在for循环的表达式上做做文章。

//当需要固定规律一段一段去处理字符串的时候，要想想在在for循环的表达式上做做文章
//从字符数组转回字符串： return new String(a);
class Solution {
    public String reverseStr(String s, int k) {
        char[] a = s.toCharArray();
        //遍历字符数组，每次增加2k
        for(int i = 0; i < a.length; i += 2*k) {
            //对每一段2k按要求进行反转k个
            int start = i;
            //判断尾数够不够k个来取决end指针的位置
            int end = Math.min(start + k - 1, a.length - 1);
            while(start < end) {
                char temp = a[start];
                a[start++] = a[end];
                a[end--] = temp;
            }
        }
        return new String(a);
    }
}

剑指Offer 05.替换空格 

对于线性数据结构，填充或者删除，后序处理会高效的多.

从后向前填充元素，避免了从前向后填充元素时，每次添加元素都要将添加元素之后的所有元素向后移动的问题。​​​​​​​

题目链接/文章讲解：代码随想录

class Solution {
    public String replaceSpace(String s) {
        if(s == null) {
            return null;
        }
        StringBuilder sb = new StringBuilder();
        //for 循环遍历s并复制到sb。
        for(int i = 0; i < s.length(); i++){
            if(s.charAt(i) == ' ') {
                sb.append("%20");
            } else {
                sb.append(s.charAt(i));
            }
        }
        return sb.toString();
    }
}

151.翻转字符串里的单词 (比较难）

题目链接/文章讲解/视频讲解：代码随想录

//快慢指针删空格
//双指针反转
//自己写辅助函数调用
//整个字符串反转，每个单词再反转： 整体反转+局部反转
class Solution {
    public String reverseWords(String s) {
        //对String s进行char[]操作
        char[] chars = s.toCharArray();
        //1. 去除多余空格
        chars = removeExtraSpaces(chars);
        //2. 整个字符串反转
        reverse(chars, 0, chars.length - 1);
        //3. 字符串里面的每一个单词反转（调用了2中间的反转方法）
        reverseEachWord(chars);
        //返回新的String
        return new String(chars);
    }
        
    //1. 去除多余空格--快慢指针
    //fast: 获取新数组中的元素（不要空格的元素）
    //slow: 获取新数组中需要更新的位置（不符合要求的slow不更新）
    private char[] removeExtraSpaces(char[] chars) {
        int slow = 0;
        for(int fast = 0; fast < chars.length; fast++) {
            //遇到非空格就处理，即删除所有空格。
            if(chars[fast] != ' ') {
                //slow控制空格，给单词之间添加空格， 加完空格,slow指向下一个位置。
                //slow != 0说明不是第一个单词，需要在单词前添加空格。
                if (slow != 0){
                    chars[slow++] = ' ';
                }
                while(fast < chars.length && chars[fast] != ' ') {
                    chars[slow++] = chars[fast++];
                }
            }
        }
         //相当于 c++ 里的 resize()
        char[] newChars = new char[slow];
        System.arraycopy(chars, 0, newChars, 0, slow); 
        return newChars;  
    }
     
    private void reverse(char[] chars, int start, int end) {
        while(start < end) {
            char temp = chars[start];
            chars[start] = chars[end];
            chars[end] = temp;
            start++;
            end--; 
        }
    }
    
    private void reverseEachWord(char[] chars) {
        int start = 0;
        for (int end = 0; end <= chars.length; end++) {
            // end 每次到单词末尾后的空格或串尾,开始反转单词
            if (end == chars.length || chars[end] == ' ') {
                reverse(chars, start, end - 1);
                start = end + 1;
            }
        }
    }       
}

剑指Offer58-II.左旋转字符串 

题目链接/文章讲解：代码随想录

//思路为：先反转前n，再反转后n，再整个反转
class Solution {
    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 new String(chars);
    }

    private void reverse(char[] chars, int start, int end) {
        while(start < end) {
            char temp = chars[start];
            chars[start] = chars[end];
            chars[end] = temp;
            start++;
            end--;
        }
    }
}