简单迷宫(链栈)

Stack.h

Code:

1. #ifndef STACK_H_H   
2. #define OK  0   
3. #define ERROR   -1   
4.   
5. typedef struct Point   
6. {   
7.     int x;   
8.     int y;   
9. }Point;   
10.   
11. typedef struct Stack   
12. {   
13.     Point pt;       //保存坐标点   
14.     struct Stack *next;   
15. }*LinkStack;   
16.   
17. int init_linkStack(LinkStack*);   
18. int make_node(Stack**);   
19. int clear_linkStack(LinkStack);   
20. int destroy_linkStack(LinkStack*);   
21. int push(LinkStack, Point);   
22. int pop(LinkStack, Point*);   
23. int create_linkStack(LinkStack);   
24. int print_linkStack(LinkStack);   
25. int get_top(LinkStack, Stack**);   
26. int stack_empty(LinkStack);   
27. #endif  

Stack.cpp

Code:

1. #include<stdio.h>   
2. #include<stdlib.h>   
3. #include "Stack.h"   
4.   
5. int init_linkStack(LinkStack *lstack)   
6. {   
7.     if(!((*lstack) = (LinkStack)malloc(sizeof(Stack))))   
8.         return ERROR;   
9.     (*lstack)->pt.x = 0;   
10.     (*lstack)->pt.y = 0;   
11.     (*lstack)->next = NULL;   
12.     return OK;   
13. }   
14.   
15. int make_node(Stack **node)   
16. {   
17.     if(!((*node) = (LinkStack)malloc(sizeof(Stack))))   
18.         return ERROR;   
19.     (*node)->pt.x = 0;   
20.     (*node)->pt.y = 0;   
21.     return OK;   
22. }   
23.   
24. int clear_linkStack(LinkStack lstack)   
25. {   
26.     if(lstack == NULL || lstack->next == NULL)   
27.         return ERROR;   
28.     Stack *tmp = lstack->next;   
29.     Stack *tmp1;   
30.     while(tmp != NULL)   
31.     {   
32.         tmp1 = tmp;   
33.         tmp = tmp->next;   
34.         free(tmp1);   
35.     }   
36.     lstack->next = NULL;   
37.     return OK;   
38. }   
39.   
40. int destroy_linkStack(LinkStack *lstack)   
41. {   
42.     if((*lstack) == NULL)   
43.         return ERROR;   
44.     Stack *tmp;   
45.     while((*lstack) != NULL)   
46.     {   
47.         tmp = *lstack;   
48.         (*lstack) = (*lstack)->next;   
49.         free(tmp);   
50.     }   
51.     (*lstack) = NULL;   
52.     return OK;   
53. }   
54.   
55. int push(LinkStack lstack, Point pt)   
56. {   
57.     if(lstack == NULL)   
58.         return ERROR;   
59.     Stack *node;   
60.     if(make_node(&node))   
61.         return ERROR;   
62.     node->pt = pt;   
63.     node->next = lstack->next;   
64.     lstack->next = node;   
65.     return OK;   
66. }   
67.   
68. int pop(LinkStack lstack, Point *pt)   
69. {   
70.     if(lstack == NULL || lstack->next == NULL)   
71.         return ERROR;   
72.     Stack *tmp;   
73.     *pt = lstack->next->pt;   
74.     tmp = lstack->next;   
75.     lstack->next = tmp->next;   
76.     free(tmp);   
77.     return OK;   
78. }   
79.   
80. int create_linkStack(LinkStack lstack)   
81. {   
82.     if(lstack == NULL || lstack->next != NULL)   
83.         return ERROR;   
84.     Point pt;   
85.     printf("input x, y: ");   
86.     scanf("%d,%d",&pt.x, &pt.y);   
87.     while(0 != pt.x && 0 != pt.y)   
88.     {   
89.         push(lstack,pt);       
90.         scanf("%d,%d",&pt.x, &pt.y);   
91.     }   
92.     return OK;   
93. }   
94.   
95. int print_linkStack(LinkStack lstack)   
96. {   
97.     if(lstack == NULL || lstack->next == NULL)   
98.         return ERROR;   
99.     Stack *tmp = lstack->next;   
100.     while(tmp != NULL)   
101.     {   
102.         printf("(%d,%d), ",tmp->pt.x, tmp->pt.y);   
103.         tmp = tmp->next;   
104.     }   
105.     printf("/n");   
106.     return OK;   
107. }   
108.   
109. int get_top(LinkStack lstack, Stack **node)   
110. {   
111.     if(lstack == NULL || lstack->next == NULL)   
112.         return ERROR;   
113.     *node = lstack->next;   
114.     return OK;   
115. }   
116.   
117. int stack_empty(LinkStack lstack)   
118. {   
119.     if(lstack == NULL)   
120.         return ERROR;   
121.     if(lstack->next == NULL)   
122.         return true;   
123.     return false;   
124. }  

mg.h

Code:

1. #ifndef MG_H_H   
2. #define MAX_SIZE    10   
3. #define OK  0   
4. #define ERROR   -1   
5.   
6. int create_map(int map[MAX_SIZE][MAX_SIZE], int);   
7. int print_map(int map[MAX_SIZE][MAX_SIZE]);   
8. int maze_path(int map[MAX_SIZE][MAX_SIZE], Point, Point);   
9. #endif  

mg.cpp

Code:

1. #include<stdlib.h>   
2. #include<stdio.h>   
3. #include<time.h>   
4. #include "Stack.h"   
5. #include"mg.h"   
6.   
7. int create_map(int map[MAX_SIZE][MAX_SIZE], int num)   
8. {   
9.     //初始化地图   
10.     for(int i = 0 ; i < MAX_SIZE ; i++)   
11.     {   
12.         for(int j = 0 ; j < MAX_SIZE ; j++)   
13.         {   
14.             if(j == 0 || i == 0   
15.                 || j == MAX_SIZE - 1 || i == MAX_SIZE - 1)   
16.             {   
17.                 map[i][j] = 1;   
18.             }   
19.             else  
20.                 map[i][j] = 0;   
21.         }   
22.     }   
23.   
24.     //产生地图障碍   
25.     srand(time(0));   
26.     while(num > 0)   
27.     {   
28.         int m = rand() % MAX_SIZE;   
29.         int n = rand() % MAX_SIZE;   
30.         map[m][n] = 1;   
31.         num--;   
32.     }   
33.     return OK;   
34. }   
35.   
36. int print_map(int map[MAX_SIZE][MAX_SIZE])   
37. {   
38.     for(int i = 0 ; i < MAX_SIZE ; i++)   
39.     {   
40.         for(int j = 0 ; j < MAX_SIZE ; j++)   
41.             printf("%d ",map[i][j]);   
42.         printf("/n");   
43.     }   
44.     return OK;   
45. }   
46.   
47. int maze_path(int map[MAX_SIZE][MAX_SIZE], Point start, Point end)   
48. {   
49.     LinkStack lstack;   
50.     Stack *node;   
51.     init_linkStack(&lstack);   
52.     Point people = start;   
53.     push(lstack,people);   
54.     do  
55.     {   
56.         //行走的路径放在栈中   
57.         if(people.x == end.x && people.y == end.y)   
58.             break;   
59.         if(map[people.x][people.y + 1] != 1)   
60.         {   
61.             people.y += 1;   
62.             push(lstack,people);   
63.             //走过的路径做下标记   
64.             map[people.x][people.y] = 1;   
65.         }   
66.         else if(map[people.x + 1][people.y] != 1)   
67.         {   
68.             people.x += 1;   
69.             push(lstack,people);   
70.             get_top(lstack,&node);   
71.             map[people.x][people.y] = 1;   
72.         }   
73.         else if(map[people.x][people.y - 1] != 1)   
74.         {   
75.             people.y -= 1;   
76.             push(lstack,people);   
77.             map[people.x][people.y] = 1;   
78.   
79.         }   
80.         else if(map[people.x - 1][people.y] != 1)   
81.         {   
82.             people.x -= 1;   
83.             push(lstack,people);   
84.             map[people.x][people.y] = 1;   
85.         }   
86.         else       
87.         {   
88.             pop(lstack,&people);   
89.         }   
90.     }while(!stack_empty(lstack));   
91.   
92.     if(!stack_empty(lstack))   
93.     {   
94.         while(!stack_empty(lstack))   
95.         {   
96.             pop(lstack,&people);   
97.             printf("(%d,%d) ", people.x, people.y);   
98.         }   
99.         printf("/n");   
100.     }   
101.     else  
102.     {   
103.         printf("not found the outlet./n");   
104.     }   
105.     return OK;   
106. }  

Main.cpp

Code:

1. #include<stdio.h>   
2. #include<stdlib.h>   
3. #include "Stack.h"   
4. #include "mg.h"   
5.   
6. void main()   
7. {   
8.     int map[MAX_SIZE][MAX_SIZE];   
9.     Point start;   
10.     Point end;   
11.     create_map(map,30);   
12.     print_map(map);   
13.     printf("input start point (x,y): ");   
14.     scanf("%d,%d", &start.x, &start.y);   
15.     printf("input end point (x,y): ");   
16.     scanf("%d,%d", &end.x, &end.y);   
17.     maze_path(map, start, end);   
18. }