C 语言实例 – 字符串翻转（深入浅出）

C 语言实例 – 字符串翻转：从零开始掌握字符串操作

在学习 C 语言的过程中，字符串处理是一个绕不开的重点。它不仅是程序与用户交互的核心，也是理解内存管理、指针操作的关键入口。今天，我们就来深入探讨一个经典又实用的 C 语言实例——字符串翻转。

你可能会问：字符串翻转有什么用？其实，它在很多场景下都有应用：比如密码验证时的字符逆序校验、文本编辑器中的“反转选中文本”功能、甚至在某些编码算法中作为基础步骤。掌握这个操作，不光是学会一个函数，更是理解 C 语言底层逻辑的一次飞跃。

我们不会直接跳进代码，而是从最基础的概念讲起，循序渐进带你走完整个实现过程。无论你是刚接触 C 语言的初学者，还是已经有一定经验的中级开发者，这篇文章都会让你有新的收获。

什么是字符串？C 语言中的“字符数组”

在 C 语言中，字符串并不是一种独立的数据类型，而是以字符数组的形式存在，以空字符 \0 作为结尾标志。这个 \0 很重要，它就像一扇门的门框，告诉程序“这里结束了”。

举个例子：

char str[] = "Hello";

这行代码在内存中实际存储的是：H, e, l, l, o, \0。一共 6 个字节，最后一个字节必须是 \0，否则程序可能读取到垃圾数据，导致崩溃或输出异常。

💡 小贴士：如果你写 char str[5] = "Hello";，编译器会报错，因为没有给 \0 留空间。必须写成 char str[6] = "Hello"; 才安全。

理解了字符串的本质，我们就能更好地设计翻转逻辑——我们需要遍历字符，从后往前重新排列，但不能破坏结尾的 \0。

方法一：使用双指针法（推荐）

双指针法是翻转字符串最高效、最优雅的方式。它的核心思想是：一头一尾两个指针向中间移动，交换它们所指的字符。

创建数组与初始化

我们先定义一个字符串，并确保有足够的空间：

#include <stdio.h>

int main() {
    // 定义一个字符数组，大小为 100，足够存储较长的字符串
    char str[100] = "C 语言实例 – 字符串翻转";
    
    // 用指针指向字符串开头和结尾
    char *start = str;                    // start 指向第一个字符 'C'
    char *end = str;                      // 先让 end 指向开头

    // 移动 end 指针到字符串末尾（即 \0 前一个字符）
    while (*end != '\0') {
        end++;                            // 指针后移
    }
    end--;                                // 回退一位，指向最后一个有效字符

    // 现在 start 在开头，end 在结尾，准备交换
    while (start < end) {
        // 临时变量保存 start 指向的字符
        char temp = *start;
        // 把 end 指向的字符赋给 start
        *start = *end;
        // 把临时保存的字符赋给 end
        *end = temp;

        // 两个指针向中间移动
        start++;
        end--;
    }

    // 输出翻转后的字符串
    printf("翻转后: %s\n", str);

    return 0;
}

代码逐行解析

• char *start = str;：start 指针指向字符串首字符。
• char *end = str;：end 指针先初始化为开头。
• while (*end != '\0') end++;：end 指针不断后移，直到遇到 \0，此时它指向的是字符串结尾。
• end--;：回退一位，现在指向最后一个有效字符（如 '转'）。
• while (start < end)：当 start 还在 end 左边时，继续交换。
• char temp = *start;：保存 start 所指的字符，防止被覆盖。
• *start = *end;：将 end 的字符写入 start 位置。
• *end = temp;：将原 start 的字符写入 end 位置。
• start++; end--;：两个指针向中间靠拢。

这个过程就像两个人从两端往中间走，每碰到一个字符就交换位置，直到相遇为止。

✅ 优点：时间复杂度 O(n)，空间复杂度 O(1)，效率极高。

方法二：使用数组索引法（适合初学者）

如果你对指针还不太熟悉，可以用索引的方式实现翻转。思路更直观：遍历数组前半部分，与后半部分对称位置交换。

#include <stdio.h>
#include <string.h>

int main() {
    char str[100] = "C 语言实例 – 字符串翻转";

    // 获取字符串长度（不包括 \0）
    int len = strlen(str);

    // 从头到中间进行交换
    for (int i = 0; i < len / 2; i++) {
        // 将第 i 个字符与第 (len - 1 - i) 个字符交换
        char temp = str[i];
        str[i] = str[len - 1 - i];
        str[len - 1 - i] = temp;
    }

    printf("翻转后: %s\n", str);

    return 0;
}

关键点解析

• strlen(str)：获取字符串的实际长度（不包括 \0）。
• len / 2：只需要交换前一半和后一半的字符，中间点无需处理。
• str[len - 1 - i]：这是对称位置的索引。例如 i = 0 时，对应 len-1；i = 1 时，对应 len-2。

比如字符串 "abcde"，长度为 5，i 从 0 到 2（即 5//2 = 2）：

• i = 0：交换 str[0] 和 str[4] → e b c d a
• i = 1：交换 str[1] 和 str[3] → e d c b a
• i = 2：str[2] 是中间，不需交换

最终得到 "edcba"，完美翻转。

✅ 优点：逻辑清晰，适合初学者理解；无需指针，降低学习门槛。

方法三：递归实现（进阶技巧）

递归是一种优雅但容易出错的编程方式。我们可以用递归实现字符串翻转，思路是：先翻转除第一个字符外的其余部分，再把第一个字符放到末尾。

#include <stdio.h>
#include <string.h>

// 递归函数：翻转字符串
void reverse_string(char *str, int start, int end) {
    // 递归终止条件：当 start >= end 时，说明已经处理完
    if (start >= end) {
        return;
    }

    // 交换首尾字符
    char temp = str[start];
    str[start] = str[end];
    str[end] = temp;

    // 递归处理中间部分
    reverse_string(str, start + 1, end - 1);
}

int main() {
    char str[100] = "C 语言实例 – 字符串翻转";

    int len = strlen(str);
    reverse_string(str, 0, len - 1);

    printf("翻转后: %s\n", str);

    return 0;
}

递归过程图解

假设字符串为 "abc"，长度为 3：

1. reverse_string("abc", 0, 2)：交换 a 和 c → "cba"
2. 调用 reverse_string("cba", 1, 1)：start == end，终止
3. 返回

递归就像是“拆包裹”：你先打开一个大盒子，发现里面还有一个小盒子，你继续打开……直到最里层没有盒子为止。

⚠️ 注意：递归虽然优雅，但对内存使用更高，且容易栈溢出。不建议用于超长字符串。

性能对比与选择建议

• 双指针法：最推荐，效率最高，代码简洁。
• 数组索引法：适合刚学 C 语言的你，逻辑清晰。
• 递归法：作为学习递归的练习，不推荐生产使用。

常见错误与调试技巧

在实现“C 语言实例 – 字符串翻转”时，新手常犯以下错误：

1. 忘记 \0：如果数组大小不够，\0 被覆盖，printf 会无限输出乱码。

   • ✅ 解决：确保数组大小至少为 strlen(str) + 1。

2. 指针越界：end-- 后没有判断是否为负。

   • ✅ 解决：在 while (start < end) 条件中自动防止越界。

3. 交换逻辑错误：比如写成 str[i] = str[len-1-i]; str[len-1-i] = str[i];，这会导致数据丢失。

   • ✅ 解决：务必使用临时变量保存原值。

4. 字符串太长：char str[100] 只能存 99 个字符（+1 给 \0）。

   • ✅ 解决：使用 #define MAX_LEN 256 定义常量，或动态分配内存。

总结与延伸思考

今天，我们系统地学习了“C 语言实例 – 字符串翻转”的三种实现方式：双指针、索引交换和递归。每种方法都有其适用场景和优缺点。

• 初学者建议从索引法入手，理解“对称交换”。
• 进阶者应掌握双指针法，这是面试高频题。
• 递归法可作为思维拓展，理解函数调用栈的运作。

字符串翻转看似简单，但它背后涉及的指针操作、内存管理、边界判断等知识点，正是 C 语言的核心魅力所在。

当你能熟练写出这段代码时，说明你已经迈过了“语法”关，开始真正理解“编程”的本质。

下次你遇到类似问题，比如“判断回文串”“反转单词顺序”时，就能轻松举一反三。因为底层逻辑是一致的：遍历 + 交换 + 控制边界。

希望这篇文章能成为你 C 语言学习路上的一块垫脚石。别忘了动手写一写，调试一下，代码写得多了，自然就熟练了。

祝你在编程的道路上越走越远！