linux学习：栈（汉诺塔游戏）

第一根上面套着 64 个圆的金片，最大的一个在底下，其余一个比一个小，依次叠上去，庙里的众僧不倦地 把它们一个个地从这根棒搬到另一根棒上，规定可利用中间的一根棒作为帮助，但每次只能 搬一个，而且大的不能放在小的上面。

每次只能拿最上面的一个，然后放的时候也必须放到最上面，这 个逻辑其实就是栈。再要解决这个问题，可以将这个问题“递归化”：假设有 n 个汉诺塔 在 A 号柱子上，那么解题的步骤是：

• 第①步：将 A 上面的 n-1 个汉诺塔先搬到 C 上。
• 第②步：直接将 A 最底下的那块汉诺塔出栈，然后直接在 B 上压栈。
• 第③步：再把那 n-1个汉诺塔从 C 搬到 B 上。

1 #include <stdio.h>
2 #include <unistd.h>
3 #include <stdlib.h>
4 #include <stdbool.h>
5
6 struct node // 链式栈节点
7 {
8     int data;
9     struct node *next;
10 };
11
12 struct linked_stack // 链式栈的管理结构体
13 {
14     struct node *top; // 栈顶元素指针
15     int size; // 当前栈元素总数
16 };
17
18 struct linked_stack *s1, *s2, *s3; // 定义成全局变量是为了方便打印
19
20 bool stack_empty(struct linked_stack *s) // 判断栈是否为空
21 {
22     return s->size == 0;
23 }
24
25 struct node *new_node(int data) // 创建一个新的节点
26 {
27     struct node *new = malloc(sizeof(struct node));
28     if(new != NULL)
29     {
30         new->data = data;
31         new->next = NULL;
32     }
33     return new;
34 }
35 // 将新节点 new 压入栈 s 中
36 bool push(struct linked_stack *s, struct node *new)
37 {
38     if(new == NULL)
39         return false;
40
41     new->next = s->top;
42     s->top = new;
43     s->size++;
44
45     return true;
46 }
47 // 从栈 s 中取出栈顶元素
48 bool pop(struct linked_stack *s, struct node **p)
49 {
50     if(stack_empty(s))
51         return false;
52
53     *p = s->top;
54     s->top = s->top->next;
55     (*p)->next = NULL;
56     s->size--;
57
58     return true;
59 }
60
61 void show(struct linked_stack *s1, 
62     struct linked_stack *s2, 
63     struct linked_stack *s3) // 纵向同时显示三个链栈数据
64 {
65     int maxlen, len;
66
67     maxlen = s1->size > s2->size ? s1->size : s2->size;
68     maxlen = maxlen > s3->size ? maxlen : s3->size;
69     len = maxlen;
70
71     struct node *tmp1 = s1->top;
72     struct node *tmp2 = s2->top;
73     struct node *tmp3 = s3->top;
74
75     int i;
76     for(i=0; i<maxlen; i++)
77     {
78         if(tmp1 != NULL && len <= s1->size)
79         {
80             printf("%d", tmp1->data);
81             tmp1 = tmp1->next;
82         }
83         printf("\t");
84
85         if(tmp2 != NULL && len <= s2->size)
86         {
87             printf("%d", tmp2->data);
88             tmp2 = tmp2->next;
89         }
90         printf("\t");
91
92         if(tmp3 != NULL && len <= s3->size)
93         {
94             printf("%d", tmp3->data);
95             tmp3 = tmp3->next;
96         }
97         printf("\n");
98
99         len--;
100     }
101     printf("s1\ts2\ts3\n-----------------\n");
102 }
103
104 void hanoi(int n, struct linked_stack *ss1, 
105     struct linked_stack *ss2, 
106     struct linked_stack *ss3)
107 {
108     if(n <= 0)
109         return;
110
111     struct node *tmp;
112
113     hanoi(n-1, ss1, ss3, ss2); // 第①步：将 n-1 个汉诺塔从 s1 移到 s3
114     getchar();
115     show(s1, s2, s3);
116     pop(ss1, &tmp);// 第②步：将最底层汉诺塔从 s1 移动到 s2
117     push(ss2, tmp);
118     hanoi(n-1, ss3, ss2, ss1); // 第③步：将 n-1 个汉诺塔从 s3 移到 s2
119 }
120 // 初始化一个空的链栈
121 struct linked_stack *init_stack(void)
122 {
123     struct linked_stack *s;
124     s = malloc(sizeof(struct linked_stack)); // 申请链栈管理结构体
125
126     if(s != NULL)
127     {
128         s->top = NULL;
129         s->size = 0;
130     }
131     return s;
132 }
133
134 int main(void)
135 {
136     printf("how many hanois ? ");
137     int hanois;
138     scanf("%d", &hanois);
139
140     s1 = init_stack(); // 初始化三个链栈，用来表示三根金刚石柱子
141     s2 = init_stack();
142     s3 = init_stack();
143
144     int i;
145     for(i=0; i<hanois; i++) // 在第一个栈中压入 n 个数，代表汉诺塔
146     {
147         struct node *new = new_node(hanois-i);
148         push(s1, new);
149     }
150
151     hanoi(hanois, s1, s2, s3); // 使用递归算法移动这些汉诺塔
152     show(s1, s2, s3); // 显示移动之后的汉诺塔形状
153
154     return 0;
155 }