508 lines
14 KiB
Markdown
508 lines
14 KiB
Markdown
<p align="center">
|
||
<a href="https://programmercarl.com/other/xunlianying.html" target="_blank">
|
||
<img src="../pics/训练营.png" width="1000"/>
|
||
</a>
|
||
<p align="center"><strong><a href="https://mp.weixin.qq.com/s/tqCxrMEU-ajQumL1i8im9A">参与本项目</a>，贡献其他语言版本的代码，拥抱开源，让更多学习算法的小伙伴们收益！</strong></p>
|
||
|
||
|
||
|
||
> 简单的反转还不够，我要花式反转
|
||
|
||
# 541. 反转字符串II
|
||
|
||
[力扣题目链接](https://leetcode.cn/problems/reverse-string-ii/)
|
||
|
||
给定一个字符串 s 和一个整数 k，从字符串开头算起, 每计数至 2k 个字符，就反转这 2k 个字符中的前 k 个字符。
|
||
|
||
如果剩余字符少于 k 个，则将剩余字符全部反转。
|
||
|
||
如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。
|
||
|
||
示例:
|
||
|
||
输入: s = "abcdefg", k = 2
|
||
输出: "bacdfeg"
|
||
|
||
## 算法公开课
|
||
|
||
**[《代码随想录》算法视频公开课](https://programmercarl.com/other/gongkaike.html)：[字符串操作进阶！ | LeetCode：541. 反转字符串II](https://www.bilibili.com/video/BV1dT411j7NN)，相信结合视频再看本篇题解，更有助于大家对本题的理解**。
|
||
|
||
## 思路
|
||
|
||
这道题目其实也是模拟，实现题目中规定的反转规则就可以了。
|
||
|
||
一些同学可能为了处理逻辑：每隔2k个字符的前k的字符，写了一堆逻辑代码或者再搞一个计数器，来统计2k，再统计前k个字符。
|
||
|
||
其实在遍历字符串的过程中，只要让 i += (2 * k)，i 每次移动 2 * k 就可以了，然后判断是否需要有反转的区间。
|
||
|
||
因为要找的也就是每2 * k 区间的起点，这样写，程序会高效很多。
|
||
|
||
**所以当需要固定规律一段一段去处理字符串的时候，要想想在在for循环的表达式上做做文章。**
|
||
|
||
性能如下：
|
||
<img src='https://code-thinking.cdn.bcebos.com/pics/541_反转字符串II.png' width=600> </img></div>
|
||
|
||
那么这里具体反转的逻辑我们要不要使用库函数呢，其实用不用都可以，使用reverse来实现反转也没毛病，毕竟不是解题关键部分。
|
||
|
||
使用C++库函数reverse的版本如下：
|
||
|
||
```CPP
|
||
class Solution {
|
||
public:
|
||
string reverseStr(string s, int k) {
|
||
for (int i = 0; i < s.size(); i += (2 * k)) {
|
||
// 1. 每隔 2k 个字符的前 k 个字符进行反转
|
||
// 2. 剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符
|
||
if (i + k <= s.size()) {
|
||
reverse(s.begin() + i, s.begin() + i + k );
|
||
} else {
|
||
// 3. 剩余字符少于 k 个，则将剩余字符全部反转。
|
||
reverse(s.begin() + i, s.end());
|
||
}
|
||
}
|
||
return s;
|
||
}
|
||
};
|
||
```
|
||
|
||
* 时间复杂度: O(n)
|
||
* 空间复杂度: O(1)
|
||
|
||
|
||
|
||
|
||
那么我们也可以实现自己的reverse函数，其实和题目[344. 反转字符串](https://programmercarl.com/0344.反转字符串.html)道理是一样的。
|
||
|
||
下面我实现的reverse函数区间是左闭右闭区间，代码如下：
|
||
|
||
```CPP
|
||
class Solution {
|
||
public:
|
||
void reverse(string& s, int start, int end) {
|
||
for (int i = start, j = end; i < j; i++, j--) {
|
||
swap(s[i], s[j]);
|
||
}
|
||
}
|
||
string reverseStr(string s, int k) {
|
||
for (int i = 0; i < s.size(); i += (2 * k)) {
|
||
// 1. 每隔 2k 个字符的前 k 个字符进行反转
|
||
// 2. 剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符
|
||
if (i + k <= s.size()) {
|
||
reverse(s, i, i + k - 1);
|
||
continue;
|
||
}
|
||
// 3. 剩余字符少于 k 个，则将剩余字符全部反转。
|
||
reverse(s, i, s.size() - 1);
|
||
}
|
||
return s;
|
||
}
|
||
};
|
||
```
|
||
|
||
* 时间复杂度: O(n)
|
||
* 空间复杂度: O(1)或O(n), 取决于使用的语言中字符串是否可以修改.
|
||
|
||
|
||
另一种思路的解法
|
||
|
||
```CPP
|
||
class Solution {
|
||
public:
|
||
string reverseStr(string s, int k) {
|
||
int n = s.size(),pos = 0;
|
||
while(pos < n){
|
||
//剩余字符串大于等于k的情况
|
||
if(pos + k < n) reverse(s.begin() + pos, s.begin() + pos + k);
|
||
//剩余字符串不足k的情况
|
||
else reverse(s.begin() + pos,s.end());
|
||
pos += 2 * k;
|
||
}
|
||
return s;
|
||
}
|
||
};
|
||
```
|
||
|
||
* 时间复杂度: O(n)
|
||
* 空间复杂度: O(1)
|
||
|
||
|
||
|
||
## 其他语言版本
|
||
|
||
### C：
|
||
|
||
```c
|
||
char * reverseStr(char * s, int k){
|
||
int len = strlen(s);
|
||
|
||
for (int i = 0; i < len; i += (2 * k)) {
|
||
//判断剩余字符是否少于 k
|
||
k = i + k > len ? len - i : k;
|
||
|
||
int left = i;
|
||
int right = i + k - 1;
|
||
while (left < right) {
|
||
char temp = s[left];
|
||
s[left++] = s[right];
|
||
s[right--] = temp;
|
||
}
|
||
}
|
||
|
||
return s;
|
||
}
|
||
```
|
||
|
||
### Java：
|
||
|
||
```Java
|
||
//解法一
|
||
class Solution {
|
||
public String reverseStr(String s, int k) {
|
||
StringBuffer res = new StringBuffer();
|
||
int length = s.length();
|
||
int start = 0;
|
||
while (start < length) {
|
||
// 找到k处和2k处
|
||
StringBuffer temp = new StringBuffer();
|
||
// 与length进行判断，如果大于length了，那就将其置为length
|
||
int firstK = (start + k > length) ? length : start + k;
|
||
int secondK = (start + (2 * k) > length) ? length : start + (2 * k);
|
||
|
||
//无论start所处位置，至少会反转一次
|
||
temp.append(s.substring(start, firstK));
|
||
res.append(temp.reverse());
|
||
|
||
// 如果firstK到secondK之间有元素，这些元素直接放入res里即可。
|
||
if (firstK < secondK) { //此时剩余长度一定大于k。
|
||
res.append(s.substring(firstK, secondK));
|
||
}
|
||
start += (2 * k);
|
||
}
|
||
return res.toString();
|
||
}
|
||
}
|
||
|
||
//解法二（似乎更容易理解点）
|
||
//题目的意思其实概括为 每隔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;
|
||
//这里是判断尾数够不够k个来取决end指针的位置
|
||
int end = Math.min(ch.length - 1, start + k - 1);
|
||
//用异或运算反转
|
||
while(start < end){
|
||
ch[start] ^= ch[end];
|
||
ch[end] ^= ch[start];
|
||
ch[start] ^= ch[end];
|
||
start++;
|
||
end--;
|
||
}
|
||
}
|
||
return new String(ch);
|
||
}
|
||
}
|
||
|
||
|
||
// 解法二还可以用temp来交换数值，会的人更多些
|
||
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;
|
||
// 判断尾数够不够k个来取决end指针的位置
|
||
int end = Math.min(ch.length - 1,start + k - 1);
|
||
while(start < end){
|
||
|
||
char temp = ch[start];
|
||
ch[start] = ch[end];
|
||
ch[end] = temp;
|
||
|
||
start++;
|
||
end--;
|
||
}
|
||
}
|
||
return new String(ch);
|
||
}
|
||
}
|
||
```
|
||
```java
|
||
// 解法3
|
||
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;
|
||
}
|
||
|
||
}
|
||
}
|
||
```
|
||
### Python：
|
||
|
||
```python
|
||
class Solution:
|
||
def reverseStr(self, s: str, k: int) -> str:
|
||
"""
|
||
1. 使用range(start, end, step)来确定需要调换的初始位置
|
||
2. 对于字符串s = 'abc'，如果使用s[0:999] ===> 'abc'。字符串末尾如果超过最大长度，则会返回至字符串最后一个值，这个特性可以避免一些边界条件的处理。
|
||
3. 用切片整体替换，而不是一个个替换.
|
||
"""
|
||
def reverse_substring(text):
|
||
left, right = 0, len(text) - 1
|
||
while left < right:
|
||
text[left], text[right] = text[right], text[left]
|
||
left += 1
|
||
right -= 1
|
||
return text
|
||
|
||
res = list(s)
|
||
|
||
for cur in range(0, len(s), 2 * k):
|
||
res[cur: cur + k] = reverse_substring(res[cur: cur + k])
|
||
|
||
return ''.join(res)
|
||
```
|
||
|
||
### Python3 (v2):
|
||
|
||
```python
|
||
class Solution:
|
||
def reverseStr(self, s: str, k: int) -> str:
|
||
# Two pointers. Another is inside the loop.
|
||
p = 0
|
||
while p < len(s):
|
||
p2 = p + k
|
||
# Written in this could be more pythonic.
|
||
s = s[:p] + s[p: p2][::-1] + s[p2:]
|
||
p = p + 2 * k
|
||
return s
|
||
```
|
||
|
||
### Go：
|
||
|
||
```go
|
||
func reverseStr(s string, k int) string {
|
||
ss := []byte(s)
|
||
length := len(s)
|
||
for i := 0; i < length; i += 2 * k {
|
||
// 1. 每隔 2k 个字符的前 k 个字符进行反转
|
||
// 2. 剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符
|
||
if i + k <= length {
|
||
reverse(ss[i:i+k])
|
||
} else {
|
||
reverse(ss[i:length])
|
||
}
|
||
}
|
||
return string(ss)
|
||
}
|
||
|
||
func reverse(b []byte) {
|
||
left := 0
|
||
right := len(b) - 1
|
||
for left < right {
|
||
b[left], b[right] = b[right], b[left]
|
||
left++
|
||
right--
|
||
}
|
||
}
|
||
```
|
||
|
||
### JavaScript:
|
||
|
||
```js
|
||
|
||
/**
|
||
* @param {string} s
|
||
* @param {number} k
|
||
* @return {string}
|
||
*/
|
||
var reverseStr = function(s, k) {
|
||
const len = s.length;
|
||
let resArr = s.split("");
|
||
for(let i = 0; i < len; i += 2 * k) { // 每隔 2k 个字符的前 k 个字符进行反转
|
||
let l = i - 1, r = i + k > len ? len : i + k;
|
||
while(++l < --r) [resArr[l], resArr[r]] = [resArr[r], resArr[l]];
|
||
}
|
||
return resArr.join("");
|
||
};
|
||
|
||
```
|
||
|
||
### TypeScript：
|
||
|
||
```typescript
|
||
function reverseStr(s: string, k: number): string {
|
||
let left: number, right: number;
|
||
let arr: string[] = s.split('');
|
||
let temp: string;
|
||
for (let i = 0, length = arr.length; i < length; i += 2 * k) {
|
||
left = i;
|
||
right = (i + k - 1) >= length ? length - 1 : i + k - 1;
|
||
while (left < right) {
|
||
temp = arr[left];
|
||
arr[left] = arr[right];
|
||
arr[right] = temp;
|
||
left++;
|
||
right--;
|
||
}
|
||
}
|
||
return arr.join('');
|
||
};
|
||
```
|
||
|
||
### Swift:
|
||
|
||
```swift
|
||
func reverseStr(_ s: String, _ k: Int) -> String {
|
||
var ch = Array(s)
|
||
|
||
for i in stride(from: 0, to: ch.count, by: 2 * k) {
|
||
var left = i
|
||
var right = min(s.count - 1, left + k - 1)
|
||
|
||
while left < right {
|
||
(ch[left], ch[right]) = (ch[right], ch[left])
|
||
left += 1
|
||
right -= 1
|
||
}
|
||
}
|
||
return String(ch)
|
||
}
|
||
```
|
||
|
||
### C#：
|
||
|
||
```csharp
|
||
public class Solution
|
||
{
|
||
public string ReverseStr(string s, int k)
|
||
{
|
||
Span<char> span = s.ToCharArray().AsSpan();
|
||
for (int i = 0; i < span.Length; i += 2 * k)
|
||
{
|
||
span[i + k < span.Length ? i..(i + k) : i..].Reverse();
|
||
}
|
||
return span.ToString();
|
||
}
|
||
}
|
||
```
|
||
### Scala:
|
||
|
||
版本一: (正常解法)
|
||
```scala
|
||
object Solution {
|
||
def reverseStr(s: String, k: Int): String = {
|
||
val res = s.toCharArray // 转换为Array好处理
|
||
for (i <- s.indices by 2 * k) {
|
||
// 如果i+k大于了res的长度，则需要全部翻转
|
||
if (i + k > res.length) {
|
||
reverse(res, i, s.length - 1)
|
||
} else {
|
||
reverse(res, i, i + k - 1)
|
||
}
|
||
}
|
||
new String(res)
|
||
}
|
||
// 翻转字符串，从start到end
|
||
def reverse(s: Array[Char], start: Int, end: Int): Unit = {
|
||
var (left, right) = (start, end)
|
||
while (left < right) {
|
||
var tmp = s(left)
|
||
s(left) = s(right)
|
||
s(right) = tmp
|
||
left += 1
|
||
right -= 1
|
||
}
|
||
}
|
||
}
|
||
```
|
||
版本二: 首先利用grouped每隔k个进行分割，再使用zipWithIndex添加每个数组的索引，紧接着利用map做变换，如果索引%2==0则说明需要翻转，否则原封不动，最后再转换为String
|
||
```scala
|
||
object Solution {
|
||
def reverseStr(s: String, k: Int): String = {
|
||
// s = "abcdefg", k = 2
|
||
s.grouped(k) // Iterator ["ab", "cd", "ef", "g"]
|
||
.zipWithIndex // Iterator [("ab", 0), ("cd", 1), ("ef", 2), ("g", 3)]
|
||
.map {
|
||
case (subStr, index) =>
|
||
if (index % 2 == 0) subStr.reverse else subStr
|
||
}
|
||
.mkString
|
||
}
|
||
}
|
||
```
|
||
|
||
版本三: (递归)
|
||
```scala
|
||
import scala.annotation.tailrec
|
||
|
||
object Solution {
|
||
def reverseStr(s: String, k: Int): String = {
|
||
@tailrec // 这个函数已经优化成了尾递归
|
||
def reverse(s: String, needToReverse: Boolean, history: String): String = {
|
||
// 截取前k个字符（判断是否翻转）
|
||
val subStr = if (needToReverse) s.take(k).reverse else s.take(k)
|
||
// 如果字符串长度小于k，返回结果
|
||
// 否则，对于剩余字符串进行同样的操作
|
||
if (s.length < k) history + subStr
|
||
else reverse(s.drop(k), !needToReverse, history + subStr)
|
||
}
|
||
reverse(s, true, "")
|
||
}
|
||
}
|
||
```
|
||
|
||
### Rust:
|
||
|
||
```Rust
|
||
impl Solution {
|
||
pub fn reverse(s: &mut Vec<char>, mut begin: usize, mut end: usize){
|
||
while begin < end {
|
||
let temp = s[begin];
|
||
s[begin] = s[end];
|
||
s[end] = temp;
|
||
begin += 1;
|
||
end -= 1;
|
||
}
|
||
}
|
||
pub fn reverse_str(s: String, k: i32) -> String {
|
||
let len = s.len();
|
||
let k = k as usize;
|
||
let mut s = s.chars().collect::<Vec<_>>();
|
||
for i in (0..len).step_by(2 * k) {
|
||
if i + k < len {
|
||
Self::reverse(&mut s, i, i + k - 1);
|
||
}
|
||
else {
|
||
Self::reverse(&mut s, i, len - 1);
|
||
}
|
||
}
|
||
s.iter().collect::<String>()
|
||
}
|
||
}
|
||
```
|
||
|
||
<p align="center">
|
||
<a href="https://programmercarl.com/other/kstar.html" target="_blank">
|
||
<img src="../pics/网站星球宣传海报.jpg" width="1000"/>
|
||
</a>
|