Go语言每日一题：反转字符串中的字母与特殊字符

2026-05-30阅读 0热度 0

其他

2026-05-30：字母翻转与特殊字符反转——分两步处理字符串。给定一个仅包含小写英文字母（a-z）和特定特殊字符的字符串，要求首先将所有小写字母的顺序整体逆序后放回原位，再对所有特殊字符执行同样的逆序操作，最终输出结果字符串。题目源自力扣第3823题，字符串长度范围1到100，特殊字符限定为“!@#$%^&*()”。

举一个边界例子：输入为全特殊字符 !@#$%^&*()，输出是 )(*&^%$#@!。原因很简单：字符串中没有字母，第一步反转字母不产生任何变化，第二步反转特殊字符等价于反转整个字符串。理解了这个逻辑，实现细节就清晰了。

一、分步骤执行过程（输入：!@#$%^&*()）

输入字符串：!@#$%^&*()。全程不含小写字母，全是特殊字符，这个场景非常适合验证算法的边界处理能力。

步骤1：调用 reverseByType 函数，将字符串转换为字节切片

先把字符串转成字节数组 t，数组元素依次为：!、@、#、$、%、^、&、*、(、)，共计10个元素。

步骤2：第一次调用 reverse 函数（处理小写字母）

判断条件：是小写字母（a-z）
执行逻辑：
1. 初始化双指针 i=0（左指针）、j=9（右指针）；
2. 左指针向右遍历：所有元素都是特殊字符，不满足“是小写字母”的条件，左指针停在原位；
3. 右指针向左遍历：同理，所有元素都不满足条件，右指针停在原位；
4. 交换左右指针指向的元素，然后两指针各自向内移动；
5. 循环持续到指针相遇，最终结果：字节数组被完全反转！
第一次反转后的字节数组：)、(、*、&、^、%、$、#、@、!。

补充：如果字符串包含字母的执行逻辑（帮助理解）

举例说明：输入 a!b@c

第一次 reverse（判断条件：是字母）：
- 跳过字母，只交换特殊字符？不，逻辑是：满足条件（是字母）就继续前进，不满足（特殊字符）就停下然后交换；
- 最终效果：字母的相对顺序整体反转后放回原位置，特殊字符位置保持不变；
- 示例：a!b@c → 字母反转后 → c!b@a。

步骤3：第二次调用 reverse 函数（处理特殊字符）

判断条件：不是小写字母（即特殊字符）
执行逻辑：
1. 此时字节数组已经是 )、(、*、&、^、%、$、#、@、!；
2. 遍历所有元素：全是特殊字符，全部满足“不是小写字母”的条件；
3. 双指针会直接遍历到相遇，没有任何字符需要交换；
第二次反转后的字节数组：保持 )、(、*、&、^、%、$、#、@、! 不变。

步骤4：将字节切片转回字符串

最终得到的字符串为：)(*&^%$#@!，与题目要求的输出完全吻合。

二、时间复杂度分析

字符串转字节切片：O(n)，n 为字符串长度；
第一次 reverse 函数：双指针遍历整个切片一次，O(n)；
第二次 reverse 函数：双指针遍历整个切片一次，O(n)；
字节切片转回字符串：O(n)；

总时间复杂度：O(n) + O(n) + O(n) + O(n) = O(n)。线性复杂度，执行时间与字符串长度呈正比。

三、额外空间复杂度分析

额外空间指除输入数据外，程序额外开辟的内存空间。

代码中将字符串转为字节切片 t，开辟了长度为 n 的字节数组，占用 O(n) 空间；
所有变量（指针 i、j、临时变量等）都是常数级空间，O(1)；

总额外空间复杂度：O(n)。需要额外开辟与输入字符串等长的存储空间。

总结

执行过程：输入全特殊字符→转字节切片→第一次反转字母（实际反转整个字符串）→第二次反转特殊字符（无任何交换）→转回字符串；
时间复杂度：O(n)（线性复杂度）；
额外空间复杂度：O(n)（需要等长的字节切片存储数据）。

Go完整代码如下：

package main

import ("fmt")

func reverse(t []byte, f func(byte) bool) {
    i, j := 0, len(t)-1
    for i < j {
        for i < j && f(t[i]) {
            i++
        }
        for i < j && f(t[j]) {
            j--
        }
        t[i], t[j] = t[j], t[i]
        i++
        j--
    }
}

func reverseByType(s string) string {
    t := []byte(s)
    reverse(t, func(ch byte) bool { return 'a' <= ch && ch <= 'z' })
    reverse(t, func(ch byte) bool { return !('a' <= ch && ch <= 'z') })
    return string(t)
}

func main() {
    s := "!@#$%^&*()"
    result := reverseByType(s)
    fmt.Println(result)
}

Python完整代码如下：

# -*-coding:utf-8-*-
def reverse(t, condition_func):
    """按条件反转字符序列"""
    i, j = 0, len(t) - 1
    t_list = list(t)  # 转换为列表以便修改
    while i < j:
        # 从左向右找到第一个不满足条件的字符
        while i < j and condition_func(t_list[i]):
            i += 1
        # 从右向左找到第一个不满足条件的字符
        while i < j and condition_func(t_list[j]):
            j -= 1
        # 交换
        t_list[i], t_list[j] = t_list[j], t_list[i]
        i += 1
        j -= 1
    return ''.join(t_list)

def reverse_by_type(s):
    """按字符类型反转字符串"""
    # 第一次反转：对小写字母进行反转
    s = reverse(s, lambda ch: 'a' <= ch <= 'z')
    # 第二次反转：对非小写字母进行反转
    s = reverse(s, lambda ch: not ('a' <= ch <= 'z'))
    return s

def main():
    s = "!@#$%^&*()"
    result = reverse_by_type(s)
    print(result)

if __name__ == "__main__":
    main()

C++完整代码如下：

#include 
#include 
#include 
#include 

void reverse(std::string& t, bool (*f)(char)) {
    int i = 0, j = t.length() - 1;
    while (i < j) {
        // 从左向右找到第一个不满足条件的字符
        while (i < j && f(t[i])) {
            i++;
        }
        // 从右向左找到第一个不满足条件的字符
        while (i < j && f(t[j])) {
            j--;
        }
        // 交换
        std::swap(t[i], t[j]);
        i++;
        j--;
    }
}

std::string reverseByType(const std::string& s) {
    std::string t = s;  // 复制字符串
    // 第一次反转：对小写字母进行反转
    reverse(t, [](char ch) -> bool {
        return 'a' <= ch && ch <= 'z';
    });
    // 第二次反转：对非小写字母进行反转
    reverse(t, [](char ch) -> bool {
        return !('a' <= ch && ch <= 'z');
    });
    return t;
}

int main() {
    std::string s = "!@#$%^&*()";
    std::string result = reverseByType(s);
    std::cout << result << std::endl;
    return 0;
}