【LeeCode】541. 反转字符串 II

【题目描述】

给定一个字符串 ​​s​​​ 和一个整数 ​​k​​​，从字符串开头算起，每计数至 ​​2k​​​ 个字符，就反转这 ​​2k​​​ 字符中的前 ​​k​​ 个字符。

• 如果剩余字符少于 ​​k​​ 个，则将剩余字符全部反转。
• 如果剩余字符小于 ​​2k​​​ 但大于或等于 ​​k​​​ 个，则反转前 ​​k​​ 个字符，其余字符保持原样。

 ​​https://leetcode.cn/problems/reverse-string-ii/description/​​

【示例】

【代码】​​LeeCode​​

package com.company;
import java.util.*;

// 2023-2-19
class Solution {
    public String reverseStr(String s, int k) {
        int len  = s.length();
        char[] ch = s.toCharArray();

        for (int left = 0; left < len; left += 2 * k){
            //左指针是为了定义反转位置的开始，右指针定义反转位置的结束。
            //特别备注下，这边的Math.min()起到的作用是，字符小于k时，全部反转的小姑。
            //当k>len的时候，就取len。
            //例如；“a” 4。这种情况就rigth不能取4，应该取1。
            reverseS(ch, left, Math.min(left + k, len) - 1);
        }
        return new String(ch);
    }

    private void reverseS(char[] ch, int left, int right) {
        //只要左指针小于右指针就反转
        //这边是为了兼容处理 k >len情况下，将所有字符都反转
        while (left < right){
            char tmp = ch[right];
            ch[right] = ch[left];
            ch[left] = tmp;
            left++;
            right--;
        }

    }
}

public class Test {
    public static void main(String[] args) {
        new Solution().reverseStr("abcdefg", 2); // 输出："bacdfeg"
        new Solution().reverseStr("abcd", 2); // 输出："bacd"
    }
}

【代码】​​鼹叔​​

package com.company;
import java.util.*;

// 2023-2-19
class Solution {
    public String reverseStr(String s, int k) {
        char[] ch = s.toCharArray();
        int len = s.length();
        // 有多少个 2k
        int lunxun = len / (2 * k);
        // 最后剩余多少个字符
        int leftStr = len - (lunxun * ( 2 * k));

        int left = 0;
        int right = 0;

        while (lunxun != 0){
            right = left + k - 1;
            reverst(ch, left, right);
            left = right + k + 1;
            lunxun--;
        }

        if (leftStr < k){
            reverst(ch, left, len - 1);
        }else{
            reverst(ch, left, left + k - 1);
        }
        return String.valueOf(ch);
    }

    private void reverst(char[] s, int left, int right) {
        while (left < right){
            char c = s[left];
            s[left++] = s[right];
            s[right--] = c;
        }
    }
}

public class Test {
    public static void main(String[] args) {
        new Solution().reverseStr("abcdefg", 2); // 输出："bacdfeg"
        new Solution().reverseStr("abcd", 2); // 输出："bacd"
    }
}

【代码】​​Carl​​

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

    }
    // 定义翻转函数
    public void reverse(char[] ch, int i, int j) {
    for (; i < j; i++, j--) {
        char temp  = ch[i];
        ch[i] = ch[j];
        ch[j] = temp;
    }

    }
}