2026-05-08：反转字符串前缀。用go语言，给定字符串 s 和整数 k，把 s 的开头 k 个字符顺序完全倒过来（其余字符保持原样），输出新的字

2026-05-08：反转字符串前缀。用go语言，给定字符串 s 和整数 k，把 s 的开头 k 个字符顺序完全倒过来（其余字符保持原样），输出新的字符串。

1 <= s.length <= 100。

s 仅由小写英文字母组成。

1 <= k <= s.length。

输入: s = "abcd", k = 2。

输出: "bacd"。

解释:

前 k = 2 个字符 "ab" 反转为 "ba"。最终得到的结果字符串为 "bacd"。

题目来自力扣3794。

执行过程详细描述 步骤1：接收输入参数

程序接收到两个关键输入：

• • 待处理的原始字符串：abcd（由4个小写英文字母组成）

• • 需要反转的前缀长度：2（表示只反转字符串最开头的2个字符）

Go语言中的字符串是不可变类型，无法直接修改字符顺序，因此需要将字符串转换为字节切片：

• • 原始字符串abcd转换后得到字节切片：['a', 'b', 'c', 'd']

• • 转换的目的：只有字节切片支持直接交换元素位置，才能实现字符反转

1. 1. 计算字节切片的总长度：长度为4

2. 2. 校验输入的k值：题目规定1<=k<=字符串长度，这里k=2小于4，无需调整

3. 3. 确定反转区间：需要反转索引0到索引1的字符（前k个字符，索引从0开始计数，结束位置为k-1）

使用左指针和右指针相向移动，交换指针指向的字符，直到两指针相遇：

1. 1. 初始化指针：左指针l指向起始位置0（字符a），右指针r指向结束位置1（字符b）

2. 2. 第一次交换：交换l=0和r=1的字符，字节切片变为['b', 'a', 'c', 'd']

3. 3. 指针移动：左指针l加1变为1，右指针r减1变为0

4. 4. 终止判断：此时l >= r，反转操作结束，无需继续交换

反转完成后，索引2、3位置的字符c、d全程没有被修改，保持原始顺序不变。
最终的字节切片为：['b', 'a', 'c', 'd']

步骤6：字节切片转换回字符串

将处理完成的字节切片重新转换为Go语言字符串格式，得到最终结果：bacd

步骤7：输出结果

程序将最终的字符串bacd打印输出，完成整个处理流程。

时间复杂度与额外空间复杂度分析 1. 时间复杂度

时间复杂度为O(k)（k是需要反转的前缀长度）：

• • 核心操作是双指针交换字符，只需要遍历前k个字符，交换次数为k/2次；

• • 剩余的字符无需任何操作，整体执行次数和k成正比，与字符串总长度n无关。

• • 简化表示：也可写为O(n)（n为字符串总长度），因为k≤n，是等价的复杂度量级。

额外空间复杂度为O(n)（n为字符串总长度）：

• • 程序额外创建了一个和原字符串长度相同的字节切片，用于存储和修改字符；

• • 除了这个字节切片外，只使用了常数个指针变量（l、r、n等），没有占用其他额外空间；

• • 额外空间大小与输入字符串的长度成正比。

1. 1. 执行核心：转字节切片→双指针反转前k个字符→转回字符串，剩余字符保持不变；

2. 2. 时间复杂度：O(k)（最优情况，仅遍历需要反转的部分）；

3. 3. 额外空间复杂度：O(n)（因字符串不可变，必须开辟新切片存储）。

package main

 import (
    "fmt"
)

 func reversePrefix(s string, k int)string {
    // 将字符串转换为字节切片以便交换
    bytes := []byte(s)
    n := len(bytes)
    // 确保 k 不超过字符串长度
    if k > n {
        k = n
    }
    // 反转从 0 到 k-1 的字符
    for l, r := 0, k-1; l < r; l, r = l+1, r-1 {
        bytes[l], bytes[r] = bytes[r], bytes[l]
    }
    returnstring(bytes)
}

 func main() {
    s := "abcd"
    k := 2
    result := reversePrefix(s, k)
    fmt.Println(result)
}

Python完整代码如下：

# -*-coding:utf-8-*-

 def reversePrefix(s: str, k: int) -> str:
    # 将字符串转换为列表以便交换
    chars = list(s)
    n = len(chars)
    # 确保 k 不超过字符串长度
    if k > n:
        k = n
    # 反转从 0 到 k-1 的字符
    left, right = 0, k - 1
    while left < right:
        chars[left], chars[right] = chars[right], chars[left]
        left += 1
        right -= 1
    return''.join(chars)

 if __name__ == "__main__":
    s = "abcd"
    k = 2
    result = reversePrefix(s, k)
    print(result)  

C++完整代码如下：

  

  


 using namespace std;

 string reversePrefix(string s, int k) {
    // 确保 k 不超过字符串长度
    int n = s.length();
    if (k > n) {
        k = n;
    }
    // 反转从 0 到 k-1 的字符
    for (int l = 0, r = k - 1; l < r; l++, r--) {
        swap(s[l], s[r]);
    }
    return s;
}

 int main() {
    string s = "abcd";
    int k = 2;
    string result = reversePrefix(s, k);
    cout << result << endl;
    return0;
}

我们相信人工智能为普通人提供了一种“增强工具”，并致力于分享全方位的AI知识。在这里，您可以找到最新的AI科普文章、工具评测、提升效率的秘籍以及行业洞察。 欢迎关注“福大大架构师每日一题”，发消息可获得面试资料，让AI助力您的未来发展。