用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);
    hanoi(n, 'A', 'B', 'C');
    return 0;
}

在这个程序中，我们定义了一个递归函数hanoi来求解汉诺塔问题。函数的参数包括：

- n：表示当前要移动的盘子数目；
- A：表示起始柱子；
- B：表示中间柱子；
- C：表示目标柱子。

当n等于1时，我们直接将起始柱子上的盘子移动到目标柱子上；否则，我们先将n-1个盘子从起始柱子移动到中间柱子上，然后将第n个盘子从起始柱子移动到目标柱子上，最后将n-1个盘子从中间柱子移动到目标柱子上。

在main函数中，我们首先输入汉诺塔的盘数，然后调用hanoi函数来解决问题。最终，程序会输出一系列移动步骤，将所有盘子从起始柱子移动到目标柱子上。

相关问题

用c语言栈测试“汉诺塔”问题。

以下是使用C语言的栈来解决“汉诺塔”问题的示例代码：

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

typedef struct {
    int n;  // 盘子编号
    char from;  // 源柱子
    char to;  // 目标柱子
    char aux;  // 中间柱子
} Move;

typedef struct {
    Move *data;
    int top;
    int capacity;
} Stack;

Stack* createStack(int capacity) {
    Stack *stack = (Stack*) malloc(sizeof(Stack));
    stack->data = (Move*) malloc(capacity * sizeof(Move));
    stack->top = -1;
    stack->capacity = capacity;
    return stack;
}

void destroyStack(Stack *stack) {
    free(stack->data);
    free(stack);
}

void push(Stack *stack, Move move) {
    if (stack->top == stack->capacity - 1) {
        printf("Stack overflow!\n");
        exit(1);
    }
    stack->top++;
    stack->data[stack->top] = move;
}

Move pop(Stack *stack) {
    if (stack->top == -1) {
        printf("Stack underflow!\n");
        exit(1);
    }
    Move move = stack->data[stack->top];
    stack->top--;
    return move;
}

void hanoi(int n, char from, char to, char aux) {
    Stack *stack = createStack(n);
    push(stack, (Move) { n, from, to, aux });
    while (stack->top != -1) {
        Move move = pop(stack);
        if (move.n == 1) {
            printf("Move disk %d from %c to %c\n", move.n, move.from, move.to);
        } else {
            push(stack, (Move) { move.n - 1, move.aux, move.to, move.from });
            push(stack, (Move) { 1, move.from, move.to, move.aux });
            push(stack, (Move) { move.n - 1, move.from, move.aux, move.to });
        }
    }
    destroyStack(stack);
}

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

在这个示例中，我们定义了一个`Move`结构体来表示每次移动的操作，其中包括盘子的编号、源柱子、目标柱子和中间柱子。我们还定义了一个`Stack`结构体来表示栈，其中包括栈的数据、栈顶指针和容量。

我们使用`createStack`函数来创建一个指定容量的栈，并使用`destroyStack`函数来销毁栈。我们使用`push`函数来将一个操作压入栈中，并使用`pop`函数来从栈中弹出一个操作。

在`hanoi`函数中，我们首先创建一个栈，并将起始操作压入栈中。然后，我们循环执行以下操作：

1. 弹出栈顶的操作，如果这个操作只需要移动一个盘子，就直接输出移动的步骤；
2. 否则，我们将这个操作拆分成三个子操作，分别是将前n-1个盘子从源柱子移动到中间柱子、将第n个盘子从源柱子移动到目标柱子、将前n-1个盘子从中间柱子移动到目标柱子。将这三个子操作依次压入栈中。

最后，我们在主函数中读取用户输入的盘子数量，然后调用`hanoi`函数来解决“汉诺塔”问题。