C语言实现汉诺塔求解问题

汉诺塔问题是经典的递归问题，C语言实现代码如下：

#include <stdio.h>

void hanoi(int n, char A, char B, char C) {
    if (n == 1) {
        printf("Move disk %d from rod %c to rod %c\n", n, A, C);
        return;
    }
    hanoi(n-1, A, C, B);
    printf("Move disk %d from rod %c to rod %c\n", n, A, C);
    hanoi(n-1, B, A, C);
}

int main() {
    int n;
    printf("Enter the number of disks: ");
    scanf("%d", &n);
    hanoi(n, 'A', 'B', 'C');
    return 0;
}

代码中的 `hanoi` 函数使用递归的方式求解汉诺塔问题。当只有一个盘子时，直接将其从起始柱子 A 移动到目标柱子 C，然后返回。当盘子数量大于 1 时，先将 n-1 个盘子从起始柱子 A 移动到辅助柱子 B，然后将起始柱子 A 上的最后一个盘子移动到目标柱子 C，最后再将辅助柱子 B 上的 n-1 个盘子移动到目标柱子 C。

相关问题

用C语言实现汉诺塔求解问题

汉诺塔问题是经典的递归问题，可以用递归方式简单地解决。以下是用 C 语言实现汉诺塔问题的代码：

#include <stdio.h>

void hanoi(int n, char a, char b, char c) {
    if (n == 1) {
        printf("%c -> %c\n", a, c);
    } else {
        hanoi(n-1, a, c, b);
        printf("%c -> %c\n", a, c);
        hanoi(n-1, b, a, c);
    }
}

int main() {
    int n;
    printf("请输入汉诺塔的层数：");
    scanf("%d", &n);
    printf("移动步骤如下：\n");
    hanoi(n, 'A', 'B', 'C');
    return 0;
}

解释一下上面的代码：

1. `hanoi` 函数是递归解决汉诺塔问题的函数。参数 `n` 表示要移动的盘子数，`a` 表示起始柱子，`b` 表示中间柱子，`c` 表示目标柱子。

2. 当 `n=1` 时，直接将第一个盘子从起始柱子移动到目标柱子即可。

3. 当 `n>1` 时，先将前 `n-1` 个盘子从起始柱子移动到中间柱子，然后将第 `n` 个盘子从起始柱子移动到目标柱子，最后将前 `n-1` 个盘子从中间柱子移动到目标柱子。

4. 在 `main` 函数中，首先输入要移动的盘子数 `n`，然后调用 `hanoi` 函数求解并输出移动步骤。

以上就是用 C 语言实现汉诺塔问题的代码。

在C语言中用堆栈实现汉诺塔求解问题

下面是用堆栈实现汉诺塔问题的C语言代码：

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define MAX_SIZE 20

// 定义结构体表示栈
typedef struct {
    int top;
    int data[MAX_SIZE];
} Stack;

// 初始化栈
void init(Stack *s) {
    s->top = -1;
}

// 判断栈是否为空
bool is_empty(Stack *s) {
    return s->top == -1;
}

// 判断栈是否已满
bool is_full(Stack *s) {
    return s->top == MAX_SIZE - 1;
}

// 入栈操作
void push(Stack *s, int x) {
    if (is_full(s)) {
        printf("Stack overflow.\n");
        exit(1);
    }
    s->data[++s->top] = x;
}

// 出栈操作
int pop(Stack *s) {
    if (is_empty(s)) {
        printf("Stack underflow.\n");
        exit(1);
    }
    return s->data[s->top--];
}

// 汉诺塔递归函数
void hanoi(int n, char a, char b, char c, Stack *s) {
    if (n == 1) {
        printf("Move disk 1 from %c to %c\n", a, c);
        push(s, 1);
        return;
    }
    hanoi(n - 1, a, c, b, s);
    int x = pop(s) + 1;
    printf("Move disk %d from %c to %c\n", x, a, c);
    push(s, x);
    hanoi(n - 1, b, a, c, s);
}

int main() {
    int n;
    printf("Enter the number of disks: ");
    scanf("%d", &n);
    Stack s;
    init(&s);
    hanoi(n, 'A', 'B', 'C', &s);
    return 0;
}

在这个代码中，我们定义了一个结构体 `Stack` 表示栈，其中包括一个整数 `top` 表示栈顶位置和一个整型数组 `data` 作为栈的数据区。

我们用 `init` 函数初始化栈，用 `is_empty` 和 `is_full` 函数判断栈是否为空或已满，用 `push` 函数将元素入栈，用 `pop` 函数将元素出栈。

在 `hanoi` 函数中，我们使用递归来实现汉诺塔问题。如果有一个盘子，我们直接将它从 A 移动到 C，并将它压入栈中。如果有多个盘子，我们先将前 n-1 个盘子从 A 移动到 B，再将最后一个盘子从 A 移动到 C，最后将前 n-1 个盘子从 B 移动到 C。在移动每个盘子的时候，我们要记录它的编号，因为我们需要用栈来记录移动的顺序。

在 `main` 函数中，我们初始化了一个栈，然后调用 `hanoi` 函数来解决汉诺塔问题。