大家评下这个8数码写的怎么样，

Question

本帖最后由 三月廿七 于 2011-04-28 09:42 编辑

闲的蛋疼， Ko,

2. #include <stdio.h>
3. #include <string.h>
4. #include <stdlib.h>
6. #define NUM 5
8. typedef struct bgMatrix
9. {
10.     int v, w;
11.     char matrix[NUM][NUM];
12.     int pre;
13. }Matrix;
15. typedef struct bgQueue
16. {
17.     Matrix* data;
18.     int maxLength;
19.     int head;
20.     int tail;
21. }BGQueue;
22. typedef BGQueue* Queue;
24. typedef struct bgStack
25. {
26.     Matrix* data;
27.     int top;
28. }BGStack;
29. typedef BGStack* Stack;
31. char srcMatrix[NUM][NUM] =
32. {
33.     {'*', '*', '*', '*', '*'},
34.     {'*', '2', '8', '3', '*'},
35.     {'*', '1', '0', '4', '*'},
36.     {'*', '7', '6', '5', '*'},
37.     {'*', '*', '*', '*', '*'}
38. };
40. char dstMatrix[NUM][NUM] =
41. {
42.     {'*', '*', '*', '*', '*'},
43.     {'*', '1', '2', '3', '*'},
44.     {'*', '8', '0', '4', '*'},
45.     {'*', '7', '6', '5', '*'},
46.     {'*', '*', '*', '*', '*'}
47. };
49. int dx[4] = {0, -1, 0, 1};
51. int dy[4] = {-1, 0, 1, 0};
53. int cnt = -1;
55. Queue queue;
57. Stack stack;
59. FILE* log;
61. void bfs(Matrix matrix);
63. void initQueue(int length);
65. void putQueue(Matrix matrix);
67. Matrix getQueue(void);
69. int isQueueEmpty(void);
71. int isQueueFull(void);
73. void initStack(int length);
75. void pushStack(Matrix matrix);
77. Matrix popStack(void);
79. int isStackEmpty(void);
81. int matrixCmp(char src[][NUM], char dst[][NUM]);
83. void matrixCpy(char dst[][NUM], char src[][NUM]);
85. void matrixPrint(char matrix[][NUM]);
87. void bgOpenLog(void);
89. void bgWriteLog(const char* s);
91. void bgCloseLog(void);
93. int main(void)
94. {
95.     Matrix src;
97.     bgOpenLog();
99.     initQueue(3628800);
100.     initStack(1000);
102.     src.v = 2;
103.     src.w = 2;
104.     matrixCpy(src.matrix, srcMatrix);
105.     src.pre = cnt;
107.     bfs(src);
109.     bgCloseLog();
111.     getchar();
113.     return 0;
114. }
116. void bfs(Matrix matrix)
117. {
118.     Matrix t, s;
120.     int v, w;
122.     int direction, tmp;
124.     putQueue(matrix);
126.     while (!isQueueEmpty())
127.     {
128.         s = getQueue();
130.         cnt++;
132.         for (direction = 0; direction < 4; direction++)
133.         {
134.             t = s;
135.             v = t.v + dx[direction]; w = t.w + dy[direction];
137.             if (srcMatrix[v][w] != '*')
138.             {
139.                 tmp = t.matrix[t.v][t.w];
140.                 t.matrix[t.v][t.w] = t.matrix[v][w];
141.                 t.matrix[v][w] = tmp;
143.                 t.v = v;
144.                 t.w = w;
145.                 t.pre = cnt;
147.                 for (tmp = 0; tmp < queue->tail; tmp++)
148.                 {
149.                     if (matrixCmp(queue->data[tmp].matrix, t.matrix))
150.                     {
151.                         break;
152.                     }
153.                 }
155.                 if (tmp == queue->tail)
156.                 {
157.                     putQueue(t);
159.                     if (matrixCmp(t.matrix, dstMatrix))
160.                     {
161.                         pushStack(t);
163.                         for (tmp = t.pre; !matrixCmp(queue->data[tmp].matrix, srcMatrix); tmp = queue->data[tmp].pre)
164.                         {
165.                             pushStack(queue->data[tmp]);
166.                         }
168.                         matrixCpy(t.matrix, srcMatrix);
169.                         pushStack(t);
171.                         while (!isStackEmpty())
172.                         {
173.                             s = popStack();
174.                             matrixPrint(s.matrix);
175.                         }
177.                         printf("Hi, BlueGuy");
179.                         return;
180.                     }
181.                 }
182.             }
183.         }
184.     }
185. }
187. void initQueue(int length)
188. {
189.     queue = malloc(sizeof(BGQueue));
191.     queue->data = malloc(sizeof(Matrix) * length);
192.     queue->maxLength = length;
193.     queue->head = 0;
194.     queue->tail = 0;
195. }
197. void putQueue(Matrix matrix)
198. {
199.     queue->data[queue->tail++] = matrix;
200.     queue->tail = queue->tail % queue->maxLength;
201. }
203. Matrix getQueue(void)
204. {
205.     Matrix ret;
207.     ret = queue->data[queue->head++];
208.     queue->head = queue->head % queue->maxLength;
210.     return ret;
211. }
213. int isQueueEmpty(void)
214. {
215.     return queue->head == queue->tail;
216. }
218. int isQueueFull(void)
219. {
220.     return ((queue->tail+1) % queue->maxLength) == queue->head;
221. }
223. void initStack(int length)
224. {
225.     stack = malloc(sizeof(BGStack));
227.     stack->data = malloc(sizeof(Matrix) * length);
228.     stack->top = 0;
230. }
232. void pushStack(Matrix matrix)
233. {
235.     stack->data[stack->top++] = matrix;
236. }
238. Matrix popStack(void)
239. {
240.     Matrix ret;
241.     ret = stack->data[--stack->top];
243.     return ret;
244. }
246. int isStackEmpty(void)
247. {
248.     return (stack->top == 0);
249. }
253. int matrixCmp(char src[][NUM], char dst[][NUM])
254. {
255.     int i, j, s, t, ret;
257.     char srcString[30] = {0};
258.     char dstString[30] = {0};
260.     s = 0;
261.     t = 0;
263.     for (i = 0; i < NUM; i++)
264.     {
265.         for (j = 0; j < NUM; j++)
266.         {
267.             srcString[s++] = src[i][j];
268.             dstString[t++] = dst[i][j];
269.         }
270.     }
272.     ret = !strcmp(srcString, dstString);
274.     return ret;
275. }
278. void matrixCpy(char dst[][NUM], char src[][NUM])
279. {
280.     int i, j;
282.     for (i = 0; i < NUM; i++)
283.     {
284.         for (j = 0; j < NUM; j++)
285.         {
286.             dst[i][j] = src[i][j];
287.         }
288.     }
289. }
291. void matrixPrint(char matrix[][NUM])
292. {
293.     char logTxt[60] = {0};
295.     int i, j, k;
297.     k = 0;
299.     for (i = 0; i < NUM; i++)
300.     {
301.         for (j = 0; j < NUM; j++)
302.         {
303.             logTxt[k++] = matrix[i][j];
304.         }
306.         logTxt[k++] = '\r';
307.         logTxt[k++] = '\n';
308.     }
310.     logTxt[k++] = '\r';
311.     logTxt[k++] = '\n';
313.     bgWriteLog(logTxt);
315. }
317. void bgOpenLog(void)
318. {
319.     if(log == NULL)
320.     {
321.         log = fopen("log.txt", "wb");
322.     }
323. }
325. void bgWriteLog(const char* s)
326. {
327.     fwrite(s, sizeof(char), strlen(s), log);
328. }
330. void bgCloseLog(void)
331. {
332.     fclose(log);
333.     log = NULL;
334. }

复制代码

Answer 1

要用代码方式贴代码。
粗看代码还行

Answer 2

nb啊，lz好nb啊，求带

Answer 3

本帖最后由 三月廿七 于 2011-04-28 09:49 编辑

nb啊，lz好nb啊，求带
txdgtwpv 发表于 2011-04-28 09:34

帖出来就感觉不对劲，
一时冲动， 算了， 评价吧。

还是得静下心写代码，

Answer 4

要用代码方式贴代码。
粗看代码还行
hellioncu 发表于 2011-04-28 09:34

    谢谢，

Answer 5

什么叫8数码

Answer 6

要用代码方式贴代码。
粗看代码还行
hellioncu 发表于 2011-04-28 09:34

    我倒是想帖一个 俄罗斯方块的代码请教一下，
不知为什么 cu禁我的帖， 发不了

Answer 7

什么叫8数码
cjaizss 发表于 2011-04-28 10:10

    低级程序， 不说也罢。

Answer 8

挺漂亮

Answer 9

以前写过NxN的用A*算法的。