解密汉诺塔算法：用C语言实现递归与栈的巧妙结合

目录

引言

算法概述

代码详解

运行结果展示

结束语

---

引言

汉诺塔问题是计算机科学中经典的递归算法示例之一。本文通过C语言代码实现了汉诺塔问题的解法，并且使用了栈数据结构进行辅助，以展示递归与栈的结合应用。读者将会了解到如何使用递归思想解决复杂问题，并且学会了如何在实际编程中利用栈这一数据结构进行辅助计算。

算法概述

汉诺塔问题是一个经典的数学问题，它源自印度的一个古老传说。问题的描述是：在一块铁板上，有三根杆子，标记为X、Y、Z。开始时，这些杆子上穿有若干个盘子，盘子大小各不相同，且按照从小到大的顺序从上到下叠放。现在的任务是，把所有盘子从杆子X移到杆子Z上，要求每次移动只能移动一个盘子，并且大盘子不能放在小盘子上面。

解决这个问题的经典算法是递归算法。在递归算法中，我们将大问题分解成小问题，并且通过不断调用自身来解决这些小问题。在汉诺塔问题中，我们可以将移动n个盘子的问题分解为以下几步：

1. 将n-1个盘子从X杆移到Y杆（借助Z杆）。
2. 将剩下的一个最大的盘子从X杆移到Z杆。
3. 将Y杆上的n-1个盘子移动到Z杆（借助X杆）。

通过这种递归思想，我们可以解决汉诺塔问题。但是在实际的编程中，我们还可以结合栈这一数据结构来辅助实现递归算法。

代码详解

以下是一个用C语言实现汉诺塔问题的代码示例。在这段代码中，我们定义了一个栈数据结构，并且利用栈来辅助实现递归算法。通过递归地调用Hanoi函数，我们可以不断地将问题分解为更小的子问题，直到问题规模减小到一个盘子的情况。然后我们利用栈来保存每个子问题的状态，使得算法更加清晰和易于理解。

在main函数中，我们首先初始化了三个栈X、Y、Z，并且将n个盘子依次压入栈X中。然后调用Hanoi函数来解决汉诺塔问题，并且在每一步移动后输出当前的状态，直到所有的盘子都移动到了目标杆上。
 

#define _CRT_SECURE_NO_WARNINGS  // 忽略 Visual Studio scanf中的警告
#include<stdio.h>
#include<stdlib.h>

// 定义栈元素类型
typedef int SElemtype;

// 定义栈的最大容量
#define MAXSIZE 100

// 定义顺序栈结构体
typedef struct {
    SElemtype* top; // 栈顶指针
    SElemtype* base; // 栈底指针
    int stacksize; // 栈的容量
} SqStack;

// 初始化栈
void InitStack(SqStack& S) {
    S.base = (SElemtype*)malloc(sizeof(SElemtype) * MAXSIZE); // 分配存储空间
    if (!S.base) {
        exit(0); // 内存分配失败
    }
    S.top = S.base; // 初始化栈顶指针等于栈底指针
    S.stacksize = MAXSIZE; // 初始化栈的容量
}

// 入栈操作
void Push(SqStack& S, SElemtype e) {
    if (S.top - S.base == S.stacksize) {
        return; // 栈满，无法入栈
    }
    *S.top = e; // 将元素e入栈
    S.top++; // 栈顶指针上移
}

// 出栈操作
void Pop(SqStack& S, SElemtype* e) {
    if (S.base == S.top) {
        return; // 栈空，无法出栈
    }
    S.top--; // 栈顶指针下移
    *e = *S.top; // 将栈顶元素出栈
}

// 输出栈中所有元素的值
void PutAll(SqStack& S) {
    if (S.base == S.top) {
        printf("该栈为空\n"); // 栈为空
        return;
    }
    // 复制栈，因为下面要出栈，出栈要改变栈的结构，这里只是遍历打印栈的结构，要保证原栈不可被改变，
    //所以可以将原栈复制一份，再将复制的栈遍历出栈,
    SqStack stack = S; 
    printf("栈的示意图如下：\n");
    int n = 0;
    while (stack.base != stack.top) {
        Pop(stack, &n);
        printf("|	");
        printf("%d	", n);// 输出栈中元素的值
        printf("|\n");
        printf("|");
        printf("---------------");
        printf("|\n");
    }
    printf("\n");
}

// 将一个元素从栈M移动到栈N
void move(SqStack& M, SqStack& N) {
    int num = 0;
    Pop(M, &num); // 出栈
    Push(N, num); // 入栈
}

// 输出栈X、Y、Z的当前状态
void print(SqStack X, SqStack Y, SqStack Z, int* count) {
    printf("第%d步结果：\n", *count);
    printf("X:  ");
    PutAll(X); // 输出栈X的元素
    printf("Y:  ");
    PutAll(Y); // 输出栈Y的元素
    printf("Z:  ");
    PutAll(Z); // 输出栈Z的元素
    printf("\n");
    (*count)++; // 步数加1
}

// 汉诺塔算法实现
/*
这里为什么要传两遍X,Y,Z栈呢，如果只是递归汉诺函数则不需要传两遍，
但是我还要打印每一个步骤，如果只有一个X,Y,Z（A,B,C）参数的话，
则第一次递归Hanoi(A, C, B, n - 1, count)函数时，将C传给了B,B传给了C,
再通过 print(A, B, C, count)函数打印时B,C时，此时B,C对应的原Z，Y栈，
而 print(A, B, C, count)函数进行打印时，定义的是A对应X栈,B对应Y栈，
C对应Z栈，则打印信息则会混乱，可以再传一遍X,Y,Z参数，X,Y,Z参数递归
后位置不需要变化，再进行 print(X, Y, Z, count)就能打印对栈对应的结构了
*/
void Hanoi(SqStack& X, SqStack& Y, SqStack& Z, SqStack& A, SqStack& B, SqStack& C, int n, int* count) {
    if (n == 1) {
        move(A, C); // 将A栈顶元素移动到C栈
        print(X, Y, Z, count); // 输出当前状态
    }
    else {
        Hanoi(X, Y, Z, A, C, B, n - 1, count); // 将n-1个盘子从A经过C移动到B
        move(A, C); // 将A栈顶元素移动到C栈
        print(X, Y, Z, count); // 输出当前状态
        Hanoi(X, Y, Z, B, A, C, n - 1, count); // 将n-1个盘子从B经过A移动到C
    }
}

int main() {
    int n = 0; // 初始盘子数量
    int count = 1; // 步数计数器
    SqStack X, Y, Z; // 定义三个栈X、Y、Z
    InitStack(X); // 初始化栈X
    InitStack(Y); // 初始化栈Y
    InitStack(Z); // 初始化栈Z
    printf("请输入开始时X上圆盘的数量：");
    scanf("%d", &n); // 输入盘子数量
    while (n > 0) {
        Push(X, n); // 将盘子依次入栈X
        n--;
    }
    printf("初始：\n");
    printf("X:  ");
    PutAll(X); // 输出初始栈X的元素
    printf("Y:  ");
    PutAll(Y); // 输出初始栈Y的元素
    printf("Z:  ");
    PutAll(Z); // 输出初始栈Z的元素
    printf("\n");
    int size = X.top - X.base; // 计算栈X的元素数量
    Hanoi(X, Y, Z, X, Y, Z, size, &count); // 汉诺塔问题求解
}

运行结果展示

结束语

汉诺塔问题是一个经典的递归算法示例，在解决这个问题的过程中，我们学会了如何将大问题分解为小问题，并且利用递归算法来解决这些小问题。同时，我们还学会了如何利用栈这一数据结构来辅助实现递归算法，使得算法更加清晰和易于理解。希望读者通过本文的学习，能够更好地理解递归算法的思想，并且能够将其运用到自己的编程实践中去。