代码随想录算法训练营第八天| 344 反转字符串 151 反转字符串中的单词 122 路径加密182 动态口令 541 反转字符串II

目录

344 反转字符串

541 反转字符串II

151 反转字符串中的单词

122 路径加密

182 动态口令

使用StringBuilder 

使用char数组

---

344 反转字符串

异或的性质：

1. 交换律：a ^ b = b ^ a

2. 结合律：(a ^ b) ^ c = a ^ (b ^ c)

3.任何数异或0都等于自己 a ^ 0 = a

4.任何数异或自己都等于0 a ^ a = 0

可以通过异或的方式交换值。

s[l] ^= s[r];//此时s[l]变成了s[l]与s[r]异或后的值
s[r] ^= s[l];//此时s[r]变成了原来的s[l]   任何数与自己异或都为0
s[l] ^= s[r];//此时s[l]变成了原来的s[r]

class Solution {
    public void reverseString(char[] s) {
        int l = 0,r = s.length - 1;
        while(r > l){
            s[l] ^= s[r];
            s[r] ^= s[l];
            s[l] ^= s[r];
            l++;r--;
        }
    }
}

时间复杂度O(n),空间复杂度O(n)。

541 反转字符串II

题目要求将每2k个字符将前k个字符进行翻转，如果剩余字符个数大于k但小于2k则反转前k个字符，如果剩余字符个数小于k则将其全部全部反转。

class Solution {
    public String reverseStr(String s, int k) {
        char ch[] = s.toCharArray();
        for(int i = 0;i < ch.length;i += 2 * k){
            int start = i;
            int end = Math.min(start + k - 1,ch.length - 1); 
            while(end > start){
                ch[start] ^= ch[end];
                ch[end] ^= ch[start];
                ch[start] ^= ch[end];
                start++;end--;
            }
        }
        return new String(ch);
    }
}

时间复杂度O(n)，空间复杂度O(n)。

151 反转字符串中的单词

先去除字符串中多余的空格，再对字符串进行整体的反转，最后针对每个单词进行反转，得到答案。

class Solution {
    public String reverseWords(String s) {
        StringBuilder sb = removeSpcae(s);//去除多余的空格
        reverseString(sb,0,sb.length() - 1);//反转整体
        reverseEveryWord(sb);
        return sb.toString();
    }
    public StringBuilder removeSpcae(String s){
        int l = 0,r = s.length() - 1;
        while(s.charAt(l) == ' ')l++;//去除首部的空格
        while(s.charAt(r) == ' ')r--;//去除尾部的空格
        StringBuilder sb = new StringBuilder();
        while(l <= r){
            char ch = s.charAt(l);//去除中间多余的空格
            if(ch != ' ' || sb.charAt(sb.length() - 1) != ' '){//ch不为' '或者如今维护的sb的上一个字符不为' '
                sb.append(ch);
            }
            l++;
        }
        return sb;
    }
    public void reverseString(StringBuilder sb,int l,int r){
        while(r > l){
            char temp = sb.charAt(l);
            sb.setCharAt(l,sb.charAt(r));
            sb.setCharAt(r,temp);
            l++;r--;
        }
    }
    public void reverseEveryWord(StringBuilder sb){
        int l = 0,r = 1;
        while(r < sb.length()){
            while(r < sb.length() && sb.charAt(r) != ' ')r++;
            reverseString(sb,l,r - 1);
            l = r + 1;
            r = l + 1;
        }
    }
}

时间复杂度O(n)，空间复杂度O(n)。

122 路径加密

使用StringBuilder在循环中遍历path，将'.'变成' '即可。

class Solution {
    public String pathEncryption(String path) {
        StringBuilder sb = new StringBuilder();
        for(char c : path.toCharArray()){
            if(c == '.')sb.append(' ');
            else sb.append(c);
        }
        return sb.toString();
    } 
}

时间复杂度O(n)，空间复杂度O(n)。 

182 动态口令

1.翻转0到target - 1部分

2.翻转target到password.length - 1部分

3.翻转整体

使用StringBuilder 

class Solution {
    public String dynamicPassword(String password, int target) {
        StringBuilder sb = new StringBuilder(password);
        reverseString(sb,0,target - 1);
        reverseString(sb,target,password.length() - 1);
        reverseString(sb,0,password.length() - 1);
        return sb.toString();
    }
    public 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);
            r--;l++;
        }
    }
}

时间复杂度O(n)，空间复杂度O(n)。   

使用char数组

class Solution {
    public String dynamicPassword(String password, int target) {
        char arr[] = password.toCharArray();
        reverseString(arr,0,target - 1);
        reverseString(arr,target,password.length() - 1);
        reverseString(arr,0,password.length() - 1);
        return new String(arr);
    }
    public void reverseString(char[] arr,int l,int r){
        while(l < r){
            arr[l] ^= arr[r];
            arr[r] ^= arr[l];
            arr[l] ^= arr[r];
            r--;l++;
        }
    }
}

时间复杂度O(n)，空间复杂度O(n)。