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

1.反转字符串

class Solution {
    public void reverseString(char[] s) {
        if(s == null || s.length <= 1){
            return;
        }
        
        int left = 0;
        int right = s.length-1;
        char temp;

        while(left < right){
            temp = s[left];
            s[left] = s[right];
            s[right] = temp;
            left++;
            right--;
        }

        return;
    }
}

• 时间复杂度: O(n)
• 空间复杂度: O(1)

新学了一个用 亦或 交换元素

1. 异或操作的交换律：a ^ b = b ^ a
2. 异或操作的结合律：(a ^ b) ^ c = a ^ (b ^ c)
3. 相同数字异或的结果为0：a ^ a = 0
4. 任何数与0异或的结果为自身：a ^ 0 = a

 交换过程可以这样

a ^= b; // a = a^b
b ^= a; // b = b^a=b^(a^b) = b^b^a = 0^a = a
a ^= b; // a = a^b= a^b^a = b^0 = b

 

2. 反转字符串II

leetcode

i 从 0 开始，加2k

剩余长度大于k，反转 i 到 i+k-1

小于k，反转 i 到最后一位

class Solution {
    public String reverseStr(String s, int k) {
        if( k== 1) return s;
        char[] ch = s.toCharArray();
        int length = s.length();

        for(int i = 0; i < length; i+=2*k){
            // 剩余长度大于等于k
            if(length-i >= k)
                reverse(ch, i, i+k-1);
            else
                reverse(ch, i, length-1);
        }
        return new String(ch);
    }

    public void reverse(char[] s, int a, int b){
        for(; a<b; a++, b--){
            s[a] ^= s[b];
            s[b] ^= s[a];
            s[a] ^= s[b];
        }
    }
}

• 时间复杂度: O(n)
• 空间复杂度: O(1)或O(n), 取决于使用的语言中字符串是否可以修改.

3. 替换空格

class Solution {
    public String replaceSpace(String s) {
        if (s == null) {
            return null;
        }

        StringBuilder sb = new StringBuilder();
        for(int i = 0; i< s.length(); i++){
            if(s.charAt(i) == ' '){
                sb.append("%20");
            }else
                sb.append(s.charAt(i));
        }

        return sb.toString();
    }
}

4. 翻转字符串里的单词

leetcode

没有多余空格的很容易

先反转整个字符串，再按单词反转

这题多了去多余空格，我自己写了个方法

class Solution {
    public String reverseWords(String s) {
        //去除尾部空格
        int end = s.length()-1;
        while(s.charAt(end) == ' ') end--;

        //去除头部和中间多余空格
        StringBuilder sb = new StringBuilder();
        int i = 0;
        boolean flag = false; //是否可以加空格
        while(i <= end){
            if(s.charAt(i) != ' '){
                sb.append(s.charAt(i));
                if(i != end && s.charAt(i+1) == ' ') 
                    flag = true;//不是最后一位,下一位有空格
            }
            if(flag){
                sb.append(' ');
                flag = false;//只加一个空格
            }
            i++;
        }

        int length = sb.length();
        //反转所有
        reverse(sb, 0, length-1);

        int left = 0;
        int right = 0;

        //单词内字母反转
        while(right < length){
            if(sb.charAt(right) == ' '){
                left++;//找到单词首位
                right++;
            }
            while(right < length && sb.charAt(right) != ' '){
                right++;//找到单词后的空格 或者 找到字符串最后一位
            }
            reverse(sb, left, right-1);

            left = right;
        }

        return sb.toString();
    }

    public void reverse(StringBuilder sb, int a, int b){
        for(; a < b; a++, b--){
            char temp = sb.charAt(a);
            sb.setCharAt(a, sb.charAt(b));
            sb.setCharAt(b, temp);
        }
    }
}

• 时间复杂度: O(n)
• 空间复杂度: O(n)