由于马踏遍棋盘得记录下走过的路径, 并且在不同的时候能够返回到上一个选择节点, 重新选择新的路径, 在最初的几次编写中由于没能够排除之前已经选择的路径导致了死循环, 后来调试分析时才发现问题所在, 最后采用树形图辅助设计程序, 帮助理清了程序不同情况下应做的反应及逻辑顺序. 在每个节点处分配一个栈来储存尚未选择的路径, 供之后回溯时使用.
最后程序代码如下, 但是效率不是很高, 在SIZE 的值比较大时费时较多, 并且对内存的占用也比较厉害, 目前还没有有效的解决办法, 网上虽然有一种贪心算法, 但是那个算法并不完善, 对某些节点无法成功进行运算, 目前采用的是回溯算法, 稍加修改可以算出所有的路径.
PS：有更好的算法的话请指教～～。
试了一下发现 将SIZE设为8时，输入“4 5”马上就能找到。。。= A =，其他的可能会很慢了
代码
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <conio.h>
4 #include <crtdbg.h>
5
6
7 #define STACK_INIT_SIZE 10
8 #define STACKINCREASEMENT 50
9 #define SIZE 8 //棋盘的大小
10
11
12 int Board[SIZE][SIZE] = {0};
13
14 struct step
15 {
16 int i;
17 int j;
18 struct stack *StepStack;
19 };
20
21 typedef struct step Step;
22
23 struct stack
24 {
25 Step *base;
26 Step *top;
27 int stacksize;
28 };
29
30 typedef struct stack Stack;
31
32 void InitStack(Stack *S)
33 {
34 S->base = (Step *)malloc(STACK_INIT_SIZE * sizeof(Step));
35 S->top = S->base;
36 S->stacksize = STACK_INIT_SIZE;
37 }
38
39 void InitStepStack(Step *e)
40 {
41 e->StepStack = (Stack *)malloc(sizeof(Stack));
42 e->StepStack->base = (Step *)malloc(STACK_INIT_SIZE * sizeof(Step));
43 e->StepStack->top = e->StepStack->base;
44 e->StepStack->stacksize = STACK_INIT_SIZE;
45 }
46
47
48 void Push(Stack *S, Step e)
49 {
50 if (S->top - S->base >= S->stacksize)
51 {
52 S->base = (Step *)realloc(S->base, (S->stacksize + STACKINCREASEMENT) * sizeof(Step));
53 S->top = S->base + S->stacksize;
54 S->stacksize += STACKINCREASEMENT;
55 }
56 *S->top++ = e;
57 }
58
59 Step Pop(Stack *S)
60 {
61 Step e;
62 e = *(--S->top);
63 return e;
64 }
65
66 int Equal(Step a, Step b)
67 {
68 if (a.i == b.i && a.j == b.j)
69 return 1;
70 else
71 return 0;
72 }
73
74 int InStack(Step e, Stack *S)
75 {
76 Step *p = S->base;
77 while (p != S->top)
78 {
79 if (Equal(e, *p))
80 return 1;
81 p++;
82 }
83 return 0;
84 }
85
86 int EmptyStack(Stack *S)
87 {
88 if (S->base == S->top)
89 return 1;
90 else
91 return 0;
92 }
93
94
95 void CreateStepStack(Step *e, Stack *S)
96 {
97 int i;
98 InitStepStack(e);
99 Step nextstep[8];
100 nextstep[0].i = e->i - 2;
101 nextstep[0].j = e->j + 1;
102 nextstep[1].i = e->i - 1;
103 nextstep[1].j = e->j + 2;
104 nextstep[2].i = e->i + 1;
105 nextstep[2].j = e->j + 2;
106 nextstep[3].i = e->i + 2;
107 nextstep[3].j = e->j + 1;
108 nextstep[4].i = e->i + 2;
109 nextstep[4].j = e->j - 1;
110 nextstep[5].i = e->i + 1;
111 nextstep[5].j = e->j - 2;
112 nextstep[6].i = e->i - 1;
113 nextstep[6].j = e->j - 2;
114 nextstep[7].i = e->i - 2;
115 nextstep[7].j = e->j - 1;
116 for (i = 0; i < 8; i++)
117 {
118 if (nextstep[i].i >= 0 &&
119 nextstep[i].i <= SIZE - 1 &&
120 nextstep[i].j >= 0 &&
121 nextstep[i].j <= SIZE - 1 &&
122 !(InStack(nextstep[i], S)))
123 Push(e->StepStack, nextstep[i]);
124 }
125
126 }
127
128 //对节点栈进行排序的一种创建StepStack方式，但是发现效率会更低，因此舍弃不用
129
130 /*
131
132 int index(int n[8])
133 {
134 int i, t = -1, min = 10;
135 for (i = 0; i < 8; i++)
136 {
137 if (n[i] != 10 && n[i] < min)
138 {
139 min = n[i];
140 t = i;
141 }
142 }
143 return t;
144 }
145
146
147 void CreateStepStack(Step *e, Stack *S)
148 {
149 int i, j, n[8] = {10, 10, 10, 10, 10, 10, 10, 10};
150 InitStepStack(e);
151 Step f, nextstep[8], nextnextstep[8];
152 nextstep[0].i = e->i - 2;
153 nextstep[0].j = e->j + 1;
154 nextstep[1].i = e->i - 1;
155 nextstep[1].j = e->j + 2;
156 nextstep[2].i = e->i + 1;
157 nextstep[2].j = e->j + 2;
158 nextstep[3].i = e->i + 2;
159 nextstep[3].j = e->j + 1;
160 nextstep[4].i = e->i + 2;
161 nextstep[4].j = e->j - 1;
162 nextstep[5].i = e->i + 1;
163 nextstep[5].j = e->j - 2;
164 nextstep[6].i = e->i - 1;
165 nextstep[6].j = e->j - 2;
166 nextstep[7].i = e->i - 2;
167 nextstep[7].j = e->j - 1;
168 for (i = 0; i < 8; i++)
169 {
170 if (nextstep[i].i >= 0 &&
171 nextstep[i].i <= SIZE - 1 &&
172 nextstep[i].j >= 0 &&
173 nextstep[i].j <= SIZE - 1 &&
174 !(InStack(nextstep[i], S)))
175 {
176 f = nextstep[i];
177 nextnextstep[0].i = f.i - 2;
178 nextnextstep[0].j = f.j + 1;
179 nextnextstep[1].i = f.i - 1;
180 nextnextstep[1].j = f.j + 2;
181 nextnextstep[2].i = f.i + 1;
182 nextnextstep[2].j = f.j + 2;
183 nextnextstep[3].i = f.i + 2;
184 nextnextstep[3].j = f.j + 1;
185 nextnextstep[4].i = f.i + 2;
186 nextnextstep[4].j = f.j - 1;
187 nextnextstep[5].i = f.i + 1;
188 nextnextstep[5].j = f.j - 2;
189 nextnextstep[6].i = f.i - 1;
190 nextnextstep[6].j = f.j - 2;
191 nextnextstep[7].i = f.i - 2;
192 nextnextstep[7].j = f.j - 1;
193 for (j = 0; j < 8; j++)
194 {
195 if (nextnextstep[j].i >= 0 &&
196 nextnextstep[j].i <= SIZE - 1 &&
197 nextnextstep[j].j >= 0 &&
198 nextnextstep[j].j <= SIZE - 1 &&
199 !Equal(nextnextstep[j], nextstep[i]) &&
200 !(InStack(nextnextstep[j], S)))
201 {
202 if (n[i] == 10)
203 n[i] = 0;
204 n[i]++;
205 }
206 }
207 while (index(n) != -1)
208 {
209 Push(e->StepStack, nextstep[index(n)]);
210 n[index(n)] = 10;
211 }
212 }
213 }
214
215 }
216
217 */
218
219
220
221 void main()
222 {
223 int t = 0, n, i, j;
224 Step e, f, *p;
225 Stack STACK, *S = &STACK;
226 printf("Input x and y with \"x y\" format (0<=x<=7,0<=y<=7):\n");
227 scanf("%d %d", &e.i, &e.j);
228 InitStack(S);
229 Push(S, e);
230 while (S->top - S->base < SIZE * SIZE)
231 {
232 if (t == 0)
233 CreateStepStack(S->top - 1, S);
234 else
235 t = 0;
236
237 if (!(EmptyStack((S->top - 1)->StepStack)))
238 {
239 f = Pop((S->top - 1)->StepStack);
240 Push(S, f);
241 }
242 else
243 {
244 free((S->top - 1)->StepStack->base);
245 Pop(S);
246 if (EmptyStack(S))
247 {
248 printf("Error");
249 return;
250 }
251 t = 1;
252 }
253 }
254 n = 1;
255 p = S->base;
256 while (n <= SIZE * SIZE)
257 {
258 Board[p->i][p->j] = n;
259 n++;
260 p++;
261 }
262 n = 1;
263 for (j = 0; j < SIZE; j++)
264 {
265 for (i = 0; i < SIZE; i++)
266 {
267 printf("%3d", Board[j][i]);
268 if (i == SIZE - 1)
269 printf("\n");
270 }
271 }
272 getch();
273
274 }