Here is my simple implementation for hanoi issue.
non-recursive implementation is given also.
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <stdext.h>
4 #define N 2
5
6 struct _tow
7 {
8 char nam; // name
9 int top; // index of the top layer
10 int lay[N]; // lay[i-1] < lay[i] < lay[i+1]
11 };
12 typedef struct _tow tow;
13
14 static int cnt = 0; // move-count
15 /*
16 * move num layers from a to c
17 */
18 void hanoi_r(int num, tow* a, tow* b, tow* c)
19 {
20 if(num == 1)
21 {
22 /* move 1 layer is a easy thing */
23 int i = a->lay[a->top];
24 c->top ++;;
25 c->lay[c->top] = a->lay[a->top];
26 a->lay[a->top] = 0;
27 a->top --;
28 printf("move %d from %c to %c\n", i, a->nam, c->nam);
29 cnt++;
30 }
31 else
32 {
33 hanoi_r(num - 1, a, c, b); // move num-1 layers from tow-a to tower-b
34 hanoi_r( 1, a, b, c); // move 1 layers from tow-a to tower-c
35 hanoi_r(num - 1, b, a, c); // move num-1 layers from tow-b to tower-c
36 }
37 }
38
39 /*
40 * struct used to record the mid-state of nonrecursive metod
41 */
42 struct _state
43 {
44 int num;
45 tow* frm; // move layers from this tower
46 tow* hel; // for temp place to put layers
47 tow* aim; // target tower accepting num layers
48
49 };
50 typedef struct _state state;
51
52 /*
53 * move num layers from tower-a to tower-c with help of tower-b
54 */
55 void hanoi(int num, tow* a, tow* b, tow* c)
56 {
57 cnt = 0;
58 pstack* stc = pstack_create();
59 /* set initial state */
60 state sta;
61 sta.num = num;
62 sta.frm = a;
63 sta.aim = c;
64 sta.hel = b;
65 /* stack initial state */
66 pstack_push(&stc, &sta);
67
68 /* keep moving when stack is not empty */
69 while(pstack_hasmore(stc))
70 {
71 /* pop up top state in stack */
72 state s = *(state*)pstack_pop(&stc);
73 /* move 1 layer when num is 1 */
74 if(s.num == 1) {
75 int i = s.frm->lay[s.frm->top];
76 s.aim->top ++;
77 s.aim->lay[s.aim->top] = s.frm->lay[s.frm->top];
78 s.frm->lay[s.frm->top] = 0;
79 s.frm->top --;
80 /* print out message */
81 printf("move %d from %c to %c\n", i, s.frm->nam, s.aim->nam);
82 cnt++;
83 }
84 else {
85 /*
86 * stack action to execute for further processing and
87 * pay attention to the sequence of stacking. FILO make
88 * we to push s3 first and to push s1 at last.
89 */
90 state s3;
91 s3.num = num -1;
92 s3.frm = s.hel;
93 s3.aim = s.aim;
94 s3.hel = s.frm;
95 pstack_push(&stc, &s3);
96 state s2; s2.num = 1;
97 s2.frm = s.frm;
98 s2.aim = s.aim;
99 s2.hel = s.hel;
100 pstack_push(&stc, &s2);
101 state s1;
102 s1.num = num -1;
103 s1.frm = s.frm;
104 s1.aim = s.hel;
105 s1.hel = s.aim;
106 pstack_push(&stc, &s1);
107 }
108 }
109
110 /* remember to free all resources */
111 pstack_free(&stc);
112 }
113
114 int main()
115 {
116 tow a, b, c;
117 a.nam = 'a'; b.nam = 'b'; c.nam = 'c';
118 int i;
119 for(i = N; i > 0; i--)
120 {
121 a.lay[N-i] = i; b.lay[N-i] = 0; c.lay[N-i] = 0;
122 }
123 a.top = N-1; b.top = -1; c.top = -1;
124 /*
125 * a, b and c is initialized one time, so, one method could be
126 * called at one time.
127 *
128 hanoi_r(N, &a, &b, &c);
129 printf("hanoi_r: mvoe %d times for %d layers\n", cnt, N);
130 */
131
132 hanoi(N, &a, &b, &c);
133 printf("hanoi : mvoe %d times for %d layers\n", cnt, N);
134
135 return 0;
136 }
137