反转字符串

方法一：递归

/*
复杂度分析
时间复杂度：\mathcal{O}(N)O(N)。执行了 N/2N/2 次的交换。
空间复杂度：\mathcal{O}(N)O(N)，递归过程中使用的堆栈空间。
*/
public void reverseString(char[] s) {
	helper(s, 0, s.length - 1);
}

public void helper(char[] s, int left, int right) {
	if (left >= right) {return;}
	char temp = s[left];
	s[left++] = s[right];
	s[right--] = temp;
	helper(s, left, right);
}

双指针 + 异或交换

 public void reverseString(char[] s) {
        int left = 0;
        int right = s.length - 1;
        while (left <= right) {
            this.swap(s, left, right);
            left++;
            right--;
        }
    }
    public void swap(char[] s, int i, int j) {
        if (i == j) return;
        s[i] ^= s[j];
        s[j] ^= s[i];
        s[i] ^= s[j];
    }

双指针

/*
时间复杂度：\mathcal{O}(N)O(N)。执行了 N/2N/2 次的交换。
空间复杂度：\mathcal{O}(1)O(1)，只使用了常数级空间。
*/
public void reverseString(char[] s) {
	int left = 0; right = s.length - 1;
	while (left <= right) {
		char temp = s[left];
		s[left++] = s[right];
		s[right--] = temp;
	}
}

public void reverseString(char[] s) {
	int left = 0; right = s.length - 1;
	while (left < right) {
		char temp = s[left];
		s[left++] = s[right];
		s[right--] = temp;
	}
}

总结:

反转字符串中 上面这两个不管是<还是<=都是可以,只是<=多交换了一次中间字符(自己跟自己交换) ,测试用例要用空数组,和数组中只有一个元素来进行测试

但是 反转字符串 如果取的是到长度的中心,即下面代码

public static void reverseString(char[] s) {
        int left = 0;
        int length = s.length - 1;
        while (left < length / 2) {
            char temp = s[left];
            s[left] = s[length - left];
            s[length - left] = temp;
            left++;
        }
 } 

public static void reverseString(char[] s) {
        int left = 0;
        int length = s.length - 1;
        while (left <= length / 2) {
            char temp = s[left];
            s[left] = s[length - left];
            s[length - left] = temp;
            left++;
        }
 } 

反转字符串中 上面这两个不管是<还是<=都应该是可以,只是<=多交换了一次中间字符(自己跟自己交换) 为什么在Leetcode中提交是错误的呢,我在java中测试hello是正确的啊?

如果是 s = [] 空数组的话,left = 0, length = -1, 这时 while (0 <= 0)下标越界 s[-1 - 0] 下标为s[-1];所以上面的两个都不都不对

反转字符串二

给定一个字符串 s 和一个整数 k，你需要对从字符串开头算起的每隔 2k 个字符的前 k 个字符进行反转。

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

输入: s = “abcdefg”, k = 2 输出: “bacdfeg”
提示：
该字符串只包含小写英文字母。
给定字符串的长度和 k 在 [1, 10000] 范围内。

   public String reverseStr(String s, int k) {
        char[] result = s.toCharArray();
        for (int start = 0; start < result.length; start += 2 * k) {
            int left = start, right = Math.min(start + k - 1, result.length - 1);
            while (left < right) {
                char temp = result[left];
                result[left++] = result[right];
                result[right--] = temp;
            }
        }
        return new String(result);
    }