用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`函数来解决“汉诺塔”问题。