哈工大C语言经典问题精讲：从链表逆序到汉诺塔的工程化实现

在C语言学习过程中，链表操作和递归算法是检验编程能力的试金石。许多同学在面对链表逆序和汉诺塔问题时，常常陷入代码逻辑的迷宫。本文将从工程实践角度，深入剖析这两个经典问题的多种解法，并分享调试技巧和性能优化策略。

1. 链表逆序的三种实现方式

链表逆序是数据结构课程中的基础操作，但实现方式却大有讲究。我们先来看一个最常见的数组模拟链表逆序方案：

c复制#include <stdio.h>
#define N 100

void reverse_array(int a[], int size) {
    for(int i = 0; i < size/2; i++) {
        int temp = a[i];
        a[i] = a[size-1-i];
        a[size-1-i] = temp;
    }
}

这种实现简单直接，但存在明显的局限性——它实际上操作的是数组而非真正的链表。真正的链表逆序需要处理指针关系，下面我们看一个标准的链表节点定义和逆序实现：

c复制typedef struct Node {
    int data;
    struct Node* next;
} Node;

Node* reverse_linked_list(Node* head) {
    Node *prev = NULL, *current = head, *next = NULL;
    while (current != NULL) {
        next = current->next;  // 保存下一个节点
        current->next = prev;  // 反转指针
        prev = current;        // 移动prev指针
        current = next;        // 移动current指针
    }
    return prev;  // 新链表头
}

常见错误排查清单：

• 忘记处理空链表的情况
• 反转后未正确更新头指针
• 循环条件设置不当导致指针越界
• 内存泄漏（特别是动态分配的链表）

对于追求代码简洁性的同学，递归解法可能更具吸引力：

c复制Node* reverse_recursive(Node* head) {
    if (head == NULL || head->next == NULL) 
        return head;
    
    Node* rest = reverse_recursive(head->next);
    head->next->next = head;
    head->next = NULL;
    return rest;
}

三种实现方式的性能对比如下：

2. 汉诺塔问题的深度解析

汉诺塔问题看似简单，却蕴含着递归思想的精髓。我们先看基础实现：

c复制#include <stdio.h>

void hanoi(int n, char from, char to, char aux, int *count) {
    if (n == 1) {
        (*count)++;
        printf("%2d-(%2d): %c -> %c\n", *count, n, from, to);
        return;
    }
    hanoi(n - 1, from, aux, to, count);
    (*count)++;
    printf("%2d-(%2d): %c -> %c\n", *count, n, from, to);
    hanoi(n - 1, aux, to, from, count);
}

理解汉诺塔递归逻辑的关键在于把握三个核心步骤：

1. 将n-1个盘子从起始柱移动到辅助柱
2. 将第n个盘子从起始柱移动到目标柱
3. 将n-1个盘子从辅助柱移动到目标柱

汉诺塔移动次数公式：对于n个盘子，最少需要移动2ⁿ-1次。这个指数级增长的特性使得传统递归解法在n较大时效率低下。

优化方案可以采用非递归实现，使用栈模拟递归过程：

c复制#include <stdbool.h>

typedef struct {
    int n;
    char from, to, aux;
    bool processed;
} StackFrame;

void hanoi_iterative(int n, char from, char to, char aux) {
    StackFrame stack[100];
    int top = 0;
    int count = 0;
    
    stack[top++] = (StackFrame){n, from, to, aux, false};
    
    while (top > 0) {
        StackFrame current = stack[--top];
        
        if (current.n == 1) {
            printf("%2d-( 1): %c -> %c\n", ++count, current.from, current.to);
            continue;
        }
        
        if (!current.processed) {
            stack[top++] = (StackFrame){current.n-1, current.aux, current.to, current.from, false};
            stack[top++] = (StackFrame){current.n, current.from, current.to, current.aux, true};
            stack[top++] = (StackFrame){current.n-1, current.from, current.aux, current.to, false};
        } else {
            printf("%2d-(%2d): %c -> %c\n", ++count, current.n, current.from, current.to);
        }
    }
}

3. 猴子吃桃问题的数学建模

猴子吃桃问题看似简单，却能很好地训练逆向思维。我们先看基础解法：

c复制int peach_count(int days) {
    int count = 1;
    for (int i = 1; i < days; i++) {
        count = (count + 1) * 2;
    }
    return count;
}

这个问题实际上可以建立数学模型：设第n天有aₙ个桃子，则有递推关系：
aₙ₋₁ = (aₙ + 1) × 2

通过数学推导，可以得到通项公式：
aₙ = 3 × 2ⁿ⁻¹ - 2

对应的优化实现：

c复制#include <math.h>

int peach_formula(int days) {
    return 3 * pow(2, days-1) - 2;
}

两种实现方式的性能对比：

4. 鞍点检测的优化策略

二维数组鞍点检测是数组应用的经典问题。基础实现需要双重循环：

c复制void find_saddle_point(int matrix[][N], int rows, int cols) {
    for (int i = 0; i < rows; i++) {
        int max_in_row = matrix[i][0];
        int col_index = 0;
        
        // 找行最大
        for (int j = 1; j < cols; j++) {
            if (matrix[i][j] > max_in_row) {
                max_in_row = matrix[i][j];
                col_index = j;
            }
        }
        
        // 检查是否为列最小
        int is_saddle = 1;
        for (int k = 0; k < rows; k++) {
            if (matrix[k][col_index] < max_in_row) {
                is_saddle = 0;
                break;
            }
        }
        
        if (is_saddle) {
            printf("Saddle point at (%d,%d): %d\n", 
                  i, col_index, max_in_row);
            return;
        }
    }
    printf("No saddle point found.\n");
}

优化策略可以预先计算行最大值和列最小值：

c复制void find_saddle_point_optimized(int matrix[][N], int rows, int cols) {
    int row_max[rows];
    int col_min[cols];
    
    // 初始化
    for (int i = 0; i < rows; i++) row_max[i] = INT_MIN;
    for (int j = 0; j < cols; j++) col_min[j] = INT_MAX;
    
    // 计算行最大和列最小
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            if (matrix[i][j] > row_max[i]) 
                row_max[i] = matrix[i][j];
            if (matrix[i][j] < col_min[j])
                col_min[j] = matrix[i][j];
        }
    }
    
    // 检测鞍点
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            if (matrix[i][j] == row_max[i] && 
                matrix[i][j] == col_min[j]) {
                printf("Saddle point at (%d,%d): %d\n", 
                      i, j, matrix[i][j]);
                return;
            }
        }
    }
    printf("No saddle point found.\n");
}

两种算法的效率对比：

在实际项目中遇到类似问题时，建议先分析数据规模和使用场景，再选择合适的算法实现。对于教学演示，基础版本更直观；对于工程应用，优化版本更可靠。