Easy

题目描述

给你一个字符串 s 和一个整数 k。

反转字符串 s 的前 k 个字符，并返回结果字符串。

示例 1：

输入：s = "abcd", k = 2
输出："bacd"
解释：前 k = 2 个字符 "ab" 反转为 "ba"。最终结果字符串是 "bacd"。

示例 2：

输入：s = "xyz", k = 3
输出："zyx"
解释：前 k = 3 个字符 "xyz" 反转为 "zyx"。最终结果字符串是 "zyx"。

示例 3：

输入：s = "hey", k = 1
输出："hey"
解释：前 k = 1 个字符 "h" 反转后保持不变。最终结果字符串是 "hey"。

提示：

  • 1 <= s.length <= 100
  • s 由小写英文字母组成
  • 1 <= k <= s.length

解题思路

这是一道字符串操作的基础题，我们需要反转字符串的前 k 个字符。

解题思路

方法一：双指针反转（推荐）

  1. 使用双指针技巧，左指针指向字符串开头（索引 0），右指针指向第 k-1 个位置
  2. 不断交换左右指针对应的字符，直到左指针不小于右指针
  3. 这样就完成了前 k 个字符的反转

方法二：字符串拼接

  1. 将字符串分为三部分：前 k 个字符、反转后的前 k 个字符、剩余字符
  2. 将前 k 个字符反转后，与剩余字符拼接

方法三：利用内置函数

  1. 在某些语言中可以直接使用内置的反转函数
  2. 对字符串的前 k 个字符子串进行反转操作

双指针方法是最优解，时间复杂度为 O(k)，空间复杂度为 O(1)（不考虑结果字符串）。由于题目约束较小，所有方法都能有效解决问题。

代码实现

class Solution {
public:
    string reversePrefix(string s, int k) {
        int left = 0, right = k - 1;
        while (left < right) {
            swap(s[left], s[right]);
            left++;
            right--;
        }
        return s;
    }
};

class Solution:
    def reversePrefix(self, s: str, k: int) -> str:
        s_list = list(s)
        left, right = 0, k - 1
        while left < right:
            s_list[left], s_list[right] = s_list[right], s_list[left]
            left += 1
            right -= 1
        return ''.join(s_list)

public class Solution {
    public string ReversePrefix(string s, int k) {
        char[] chars = s.ToCharArray();
        int left = 0, right = k - 1;
        while (left < right) {
            char temp = chars[left];
            chars[left] = chars[right];
            chars[right] = temp;
            left++;
            right--;
        }
        return new string(chars);
    }
}

var reversePrefix = function(s, k) {
    let chars = s.split('');
    let left = 0, right = k - 1;
    while (left < right) {
        [chars[left], chars[right]] = [chars[right], chars[left]];
        left++;
        right--;
    }
    return chars.join('');
};
在 LeetCode 上运行： 力扣中文版 LeetCode 国际版

复杂度分析

复杂度双指针方法
时间复杂度O(k)
空间复杂度O(1)*

*注：空间复杂度不包括存储结果字符串所需的空间。在某些语言中，由于字符串不可变性，可能需要 O(n) 的额外空间来存储字符数组。