链接

https://leetcode-cn.com/problems/zuo-xuan-zhuan-zi-fu-chuan-lcof/
难度： #简单

题目

字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。

示例 1：

输入: s = "abcdefg", k = 2
输出: "cdefgab"

示例 2：

输入: s = "lrloseumgh", k = 6
输出: "umghlrlose"

限制：
1 <= k < s.length <= 10000

代码框架

class Solution {
    public String reverseLeftWords(String s, int n) {

    }
}

题目解析

解答思路1：
使用String的subString()方法，
找到左半边的字符串，
加到右半边剩下的字符串的右边。

解答思路2：
使用String的toCharArray()方法，
新建一个char数组，
将原数组左边的部分向右移动到新数组尾部，
将原数组右边的部分向左移动到新数组头部。

解答思路3：
为了让本题更有意义，提升一下本题难度：
不能申请额外空间，只能在本串上操作。
使用整体反转+局部反转实现：

1. 反转区间为前n的子串；
2. 反转区间为n到末尾的子串；

3. 反转整个字符串。
   画图演示思路：

   
   

解答思路4：
使用String的toCharArray()方法，
把这个数组当成循环数组，
同时新建一个char数组，
将原数组从n开始的元素移动到新数组的头部，
一共要移动length个元素。

测试用例

package edu.yuwen.sowrd.num58_II.solution;

import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;

import edu.yuwen.sowrd.num58_II.sol3.Solution;

public class SolutionTest {

    /**
     * 输入: s = "abcdefg", k = 2
     * 输出: "cdefgab"
     */
    @Test
    public void testCase1() {
        Solution solution = new Solution();
        String s = "abcdefg";
        int n = 2;
        String res = solution.reverseLeftWords(s, n);
        Assertions.assertEquals("cdefgab", res);
    }

    /**
     * 输入: s = "lrloseumgh", k = 6
     * 输出: "umghlrlose"
     */
    @Test
    public void testCase2() {
        Solution solution = new Solution();
        String s = "lrloseumgh";
        int n = 6;
        String res = solution.reverseLeftWords(s, n);
        Assertions.assertEquals("umghlrlose", res);
    }
}

解答1 推荐

package edu.yuwen.sowrd.num58_II.sol1;

public class Solution {
    public String reverseLeftWords(String s, int n) {
        String left = s.substring(0, n);
        String right = s.substring(n);
        return right + left;
    }
}

解答2

package edu.yuwen.sowrd.num58_II.sol2;

public class Solution {
    public String reverseLeftWords(String s, int n) {
        char[] chars = s.toCharArray();
        int length = chars.length;
        char[] newChars = new char[length];
        for (int i = 0; i < length; i++) {
            // 左边的右移length-n位
            if (i < n) {
                newChars[i + (length - n)] = chars[i];
            }
            // 右边的左移n位
            else {
                newChars[i - n] = chars[i];
            }
        }
        return new String(newChars);
    }
}

解答3

package edu.yuwen.sowrd.num58_II.sol3;

public class Solution {
    public String reverseLeftWords(String s, int n) {
        char[] chars = s.toCharArray();

        // 1.反转区间为前n的子串
        int start = 0;
        int end = n - 1;
        reverserChars(chars, start, end);

        // 2.反转区间为n到末尾的子串
        start = n;
        end = chars.length - 1;
        reverserChars(chars, start, end);

        // 反转整个字符串
        start = 0;
        end = chars.length - 1;
        reverserChars(chars, start, end);

        return new String(chars);
    }

    // 反转数组中的指定子串
    private void reverserChars(char[] chars, int start, int end) {
        for (; start < end; start++, end--) {
            char temp = chars[start];
            chars[start] = chars[end];
            chars[end] = temp;
        }
    }
}

解答4

package edu.yuwen.sowrd.num58_II.sol4;

public class Solution {
    public String reverseLeftWords(String s, int n) {
        char[] chars = s.toCharArray();
        int length = chars.length;
        char[] newChars = new char[length];

        int index = n;
        for (int i = 0; i < length; i++) {
            newChars[i] = chars[index];
            index++;
            // 循环数组索引到了边界，重新开始
            if (index >= length) {
                index = 0;
            }
        }
        return new String(newChars);
    }
}