文章目录
- 前言
- 一、概要设计
- 1、基本信息
- 2、功能模块图
- 3、功能描述
- 4、调用关系图
- 5、结果演示
- ① 创建迷宫
- ② 求解
- ③ 清除多余路径
- 二、完整代码
前言
最近刚好在写自己的课设，匆匆忙忙写出来的课设系统，仍有不足，拿出来和大家分享一下，希望能对大家有帮助。
一、概要设计
1、基本信息
具体功能包括：
（1） 选择创建的迷宫的方式：文件读取、用户输入、系统随机生成。
（2） 向用户展示生成的迷宫
（3） 选择求解的方式（DFS or BFS）
（4） 向用户展示迷宫路径
（5） 用户选择是否去掉多余路径
开发环境：VS2019
2、功能模块图
3、功能描述
（1） 迷宫的创建：文件读取（提前在文件中写好迷宫直接读取），用户输入（用户手动输入），系统随机生成（rand%2的方式随机生成迷宫）
（2） 求解方式：DFS（通过栈，以及DFS回溯的方式求解），BFS（通过队列，以及BFS穷举的方式求解）
（3） 去掉多余路径：多余标记全部删除
4、调用关系图
5、结果演示
提前在源文件同一目录下创建好这两个文件
① 创建迷宫
读取文件：
提前在文件 maze_information.txt 中写好，迷宫矩阵：
用户输入：
系统随机生成：
② 求解
栈+DFS:
队列 + BFS：
③ 清除多余路径
栈+DFS:
队列 + BFS：
二、完整代码
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<Windows.h>
#include<time.h>
typedef int Status; // 下一个通道方向
#define RANGE 100 // 迷宫大小
#define STACK_INIT_SIZE 100 // 栈的初始大小
#define STACKINCREMENT 10 // 栈的储存增量
#define ROW 10 // 迷宫的行数
#define COL 10 // 迷宫的列数
// 迷宫
typedef struct
{
int m, n;
int arr[RANGE][RANGE]; // 迷宫数组
}MazeType;
//坐标(row,col)
typedef struct
{
int row; // 迷宫中的行
int col; // 迷宫中的列
}PosType;
// 路径
typedef struct
{
int step; // 当前位置在路径上的"序号"
PosType seat; // 当前坐标
Status di; // 往下一个坐标位置的方向
}SElemType;
// 定义栈
typedef struct
{
SElemType* base; // 栈底
SElemType* top; // 栈顶
int stacksize; // 栈长
}SqStack;
// 定义队列
typedef struct
{
PosType seat; // 当前坐标
int pre; // 父节点
}Strnode;
Strnode que[ROW * COL];
// 原始迷宫，其中'1'表示墙，'0'表示通道
int a[ROW][COL];
// 创建迷宫
void ChoiceMazeInterface(); // 选择创建方式界面
int ReadMaze(int a[ROW][COL]); // 读取文件中迷宫
int WriteMaze(int a[ROW][COL]); // 用户输入迷宫
int CreateMaze(int a[ROW][COL]); // 随机迷宫
int SaveMaze(MazeType& maze); // 保存文件
// 栈的实现
int InitStack(SqStack& s); // 栈的初始化
int GetTop(SqStack s, SElemType& e); // 当栈s不为空时,返回栈顶e
int Push(SqStack& s, SElemType e); // 入栈
int Pop(SqStack& s, SElemType& e); // 出栈
int StackEmpty(SqStack s); // 判空栈
int DestoryStack(SqStack& s); // 销毁栈
// 迷宫操作
int InitMaze(MazeType& maze, int a[ROW][COL]); // 初始化迷宫
int Pass(MazeType maze, PosType curpos); // 判断当前节点是否走过
int FootPrint(MazeType& maze, PosType curpos); // 标记可以通过
int MarkPrint(MazeType& maze, PosType curpos); // 标记不能通过
SElemType CreateSElem(int step, PosType pos, int di); // 创建路径
PosType NextPos(PosType curpos, Status di); // 移动
int PosEqual(PosType pos1, PosType pos2); // 判断是不是出口
void PrintMaze(MazeType maze, int row, int col); // 打印路径
// 实现方法
void Welcome(); // 迷宫路径界面
int DepthFirstInterface(MazeType& maze, PosType start, PosType end); // 深搜界面
int DepthFirstMazePath(MazeType& maze, PosType start, PosType end); // 深搜求解迷宫maze中,从入口start到出口end的一条路径
int BreadthFirstInterface(MazeType& maze, PosType start, PosType end); // 广搜界面
int BreadthFirstMazePath(MazeType& maze, PosType start, PosType end); // 广搜求解迷宫maze中,从入口start到出口end的一条路径
void Sign(MazeType& maze, int ans); // 广搜标记地图
void Clean(MazeType& maze); // 清除错误路径
void GoodBye(); // 结束
int main()
{
int i, j;
int choice;
PosType start, end; //开始，终点坐标
MazeType maze;
while (1)
{
ChoiceMazeInterface();
scanf("%d", &choice);
switch (choice)
{
case 1:
ReadMaze(a);
break;
case 2:
WriteMaze(a);
break;
case 3:
CreateMaze(a);
break;
default:
GoodBye();
break;
}
while (1)
{
InitMaze(maze, a); // 初始化迷宫
system("cls");
printf("\n-------------------------------------------------\n");
printf("\n迷宫如下：\n");
PrintMaze(maze, ROW, COL);
printf("\n-------------------------------------------------\n");
printf("\n请输入迷宫起点坐标：");
scanf("%d %d", &start.row, &start.col);
printf("\n请输入迷宫终点坐标：");
scanf("%d %d", &end.row, &end.col);
Welcome();
scanf("%d", &choice);
switch (choice)
{
case 1:
if (DepthFirstInterface(maze, start, end))
{
system("cls");
printf("\n-------------- 栈 + 深搜 --------------\n");
Clean(maze);
}
break;
case 2:
if (BreadthFirstInterface(maze, start, end))
{
system("cls");
printf("\n-------------- 队列 + 广搜 --------------\n");
Clean(maze);
}
break;
case 0:
GoodBye();
break;
default:
break;
}
SaveMaze(maze);
printf("\n-------------------------------------------------\n");
printf("是否需要继续对该迷宫操作？（Yes：1 / No：0)：");
scanf("%d", &choice);
if (choice == 0)
break;
}
}
GoodBye();
}
// 选择创建方式界面
void ChoiceMazeInterface()
{
system("cls");
printf("****************************************************************\n");
printf("*********** 迷宫创建 ***********\n");
printf("*********** 1 ---- 读取文件 ***********\n");
printf("*********** 2 ---- 用户输入 ***********\n");
printf("*********** 3 ---- 随机生成 ***********\n");
printf("*********** else ---- 退出 ***********\n");
printf("****************************************************************\n");
printf("请选择想要创建迷宫的方式（数字）：");
}
// 读取文件
int ReadMaze(int a[ROW][COL])
{
FILE* pfRead = fopen("maze_information.txt", "r");
if (pfRead == NULL)
{
return 0;
}
for (int i = 1; i < ROW - 1; i++)
{
for (int j = 1; j < COL - 1; j++)
{
fscanf(pfRead, "%d", &a[i][j]);
}
fscanf(pfRead, "\n");
}
fclose(pfRead);
return 1;
}
// 保存文件
int SaveMaze(MazeType& maze)
{
FILE* pfRead = fopen("maze_answer.txt", "w");
if (pfRead == NULL)
{
return 0;
}
for (int i = 1; i < ROW - 1; i++)
{
for (int j = 1; j < COL - 1; j++)
{
fprintf(pfRead, "%d", maze.arr[i][j]);
}
fprintf(pfRead, "\n");
}
fclose(pfRead);
return 1;
}
// 用户输入迷宫
int WriteMaze(int a[ROW][COL])
{
printf("\n-------------------------------------------------\n");
printf("\n请输入原始迷宫：(8×8)\n");
printf("(其中'1'表示墙，'0'表示通道)\n");
for (int i = 1; i < ROW - 1; i++)
{
printf("请输入第 %d 行:", i);
for (int j = 1; j < COL - 1; j++)
{
scanf("%d", &a[i][j]);
}
}
return 1;
}
// 随机迷宫
int CreateMaze(int a[ROW][COL])
{
srand(time(0));
for (int i = 1; i < ROW - 1; i++)
{
for (int j = 1; j < COL - 1; j++)
{
if ((rand() % 100 + 1) % 2 == 0)
a[i][j] = 0;
else
a[i][j] = 1;
}
}
return 1;
}
// 栈的初始化
int InitStack(SqStack& s)
{
s.base = (SElemType*)malloc(STACK_INIT_SIZE * sizeof(SElemType));
if (!s.base)
exit(0);
s.top = s.base;
s.stacksize = STACK_INIT_SIZE;
return 1;
}
// 当栈s不为空时,返回栈顶e
int GetTop(SqStack s, SElemType& e)
{
// 判空栈
if (s.top == s.base)
return 0;
e = *(s.top - 1);
return 1;
}
// 入栈
int Push(SqStack& s, SElemType e)
{
// 判满栈
if (s.top - s.base >= s.stacksize)
{
// 若栈满，追加存储空间
s.base = (SElemType*)realloc(s.base, (s.stacksize + STACKINCREMENT) * sizeof(SElemType));
if (!s.base)
exit(0);
s.top = s.base + s.stacksize;
s.stacksize += STACKINCREMENT;
}
*s.top++ = e;
return 1;
}
// 出栈
int Pop(SqStack& s, SElemType& e)
{
// 判空栈
if (s.top == s.base)
return 0;
e = *--s.top; //e指向新栈顶
return 1;
}
// 判空栈
int StackEmpty(SqStack s)
{
return s.base == s.top;
}
// 销毁栈
int DestoryStack(SqStack& s)
{
free(&s);
return 1;
}
// 初始化迷宫
int InitMaze(MazeType& maze, int a[ROW][COL])
{
// 设置迷宫maze的初值,包括加上边缘一圈的值
int i, j;
for (i = 1; i < ROW - 1;i++)
{
for (j = 1; j < COL - 1; j++)
{
maze.arr[i][j] = a[i][j];
}
}
//加上围墙
for (j = 0; j < ROW; j++)
maze.arr[0][j] = maze.arr[ROW - 1][j] = 1;
for (i = 0; i < COL; i++)
maze.arr[i][0] = maze.arr[i][COL - 1] = 1;
return 1;
}
// 判断当前节点是否走过
int Pass(MazeType maze, PosType curpos)
{
if (maze.arr[curpos.row][curpos.col] == 0)
return 1;
else
return 0;
}
// 标记可以通过
int FootPrint(MazeType& maze, PosType curpos)
{
// 标记为2表示可以通过
maze.arr[curpos.row][curpos.col] = 2;
return 1;
}
// 标记不能通过
int MarkPrint(MazeType& maze, PosType curpos)
{
// 标记为3表示不能通过
maze.arr[curpos.row][curpos.col] = 3;
return 1;
}
// 创建路径
SElemType CreateSElem(int step, PosType pos, int di)
{
SElemType e;
e.step = step;
e.seat = pos;
e.di = di;
return e;
}
// 移动
PosType NextPos(PosType curpos, Status di)
{
// 返回当前节点的下一节点
PosType pos = curpos;
switch (di)
{
case 1: //右
pos.col++;
break;
case 2: //下
pos.row++;
break;
case 3: //左
pos.col--;
break;
case 4: //上
pos.row--;
break;
}
return pos;
}
// 判断是不是出口
int PosEqual(PosType pos1, PosType pos2)
{
if (pos1.row == pos2.row && pos1.col == pos2.col)
return 1;
else
return 0;
}
// 打印路径
void PrintMaze(MazeType maze, int row, int col)
{
int i, j;
printf(" ");
for (i = 0; i < col; i++)
printf("%d ", i);
printf("\n");
for (i = 0; i < row; i++)
{
printf("%d ",i);
for (j = 0; j < col; j++)
{
switch (maze.arr[i][j])
{
case 0:
printf(" "); // 没走过，但是通路
break;
case 1:
printf("■"); // 墙，障碍物
break;
case 2:
printf("* "); // 走过且走得通
break;
case 3:
printf("@ "); // 走过但走不通，死胡同
break;
default:
break;
}
}
printf("\n");
}
}
// 迷宫路径界面
void Welcome()
{
system("cls");
printf("****************************************************************\n");
printf("*********** 迷宫路径 ***********\n");
printf("*********** 1 ---- 栈 + 深搜 ***********\n");
printf("*********** 2 ---- 队列 + 广搜 ***********\n");
printf("*********** 0 ---- 退出 ***********\n");
printf("****************************************************************\n");
printf("请选择想要查看的方法路径（数字）：");
}
// 深搜界面
int DepthFirstInterface(MazeType& maze, PosType start, PosType end)
{
system("cls");
printf("\n-------------- 栈 + 深搜 --------------\n");
InitMaze(maze, a);
// 如果找到一条路径
if (DepthFirstMazePath(maze, start, end))
{
printf("\n-------------------------------------------------\n");
printf("\n迷宫路径如下：\n");
printf("(其中'*'表示求解路径，'@'表示死胡同)\n");
// 输出迷宫路径
PrintMaze(maze, ROW, COL);
printf("\n\n");
printf("是否需要清除错误路径？（Yes：1 / No：0)：");
int choice;
scanf("%d", &choice);
return choice;
}
// 没有通路
else
printf("\n--------------从入口到出口没有通路!--------------\n");
printf("\n\n");
return 0;
}
// 深搜求解迷宫maze中,从入口start到出口end的一条路径
int DepthFirstMazePath(MazeType& maze, PosType start, PosType end)
{
SqStack s;
SElemType e;
InitStack(s);
PosType curpos = start;
// 探索第一步
int curstep = 1;
do {
// 如果当前位置可以通过,即是未曾走到的通道块
if (Pass(maze, curpos))
{
FootPrint(maze, curpos); // 标记
e = CreateSElem(curstep,curpos, 1); // 创建元素
Push(s, e); // 加入路径
// 到达终点（出口）
if (PosEqual(curpos, end))
return 1;
curpos = NextPos(curpos, 1); // 获得下一节点
curstep++; // 继续探索
}
else
{
// 当前位置不能通过
if (!StackEmpty(s))
{
Pop(s, e);
while (e.di == 4 && !StackEmpty(s)) // 找寻了四个方向
{
// 留下不能通过的标记,并退回一步
MarkPrint(maze,e.seat);
Pop(s, e);
}
if (e.di < 4)
{
// 换一个方向探索
e.di++;
Push(s, e);
// 设定当前位置是该方向上的相邻块
curpos = NextPos(e.seat, e.di);
}
}
}
} while (!StackEmpty(s));
return 0;
}
// 广搜界面
int BreadthFirstInterface(MazeType& maze, PosType start, PosType end)
{
system("cls");
printf("\n-------------- 队列 + 广搜 --------------\n");
InitMaze(maze, a);
// 如果找到一条路径
if (BreadthFirstMazePath(maze, start, end))
{
printf("\n-------------------------------------------------\n");
printf("\n迷宫路径如下：\n");
printf("(其中'*'表示求解路径，'@'表示死胡同)\n");
// 输出迷宫路径
PrintMaze(maze, ROW, COL);
printf("\n\n");
printf("是否需要清除错误路径？（Yes：1 / No：0)：");
int choice;
scanf("%d", &choice);
return choice;
}
// 没有通路
else
printf("\n--------------从入口到出口没有通路!--------------\n");
printf("\n\n");
return 0;
}
// 广搜求解迷宫maze中,从入口start到出口end的一条路径
int BreadthFirstMazePath(MazeType& maze, PosType start, PosType end)
{
int d[4][2] = { {-1,0},{0,-1},{1,0},{0,1} }; // 控制上下左右
int vis[ROW][COL]; // 访问标记数组
memset(vis, 0, sizeof(vis)); // 初始化标记数组
int head = 0, tail = 0, i = 0, ans; // 队首对位，ans当前标记
// 从起点开始
que[tail].seat = start;
que[tail++].pre = -1;
vis[start.row][start.col] = 1;
while (head < tail)
{
Strnode temp = que[head++];
MarkPrint(maze, temp.seat);
// 到达终点（出口）
if (PosEqual(temp.seat, end))
{
ans = head - 1;
Sign(maze,ans);
return 1;
}
for (i = 0; i < 4; i++)
{
int dx = temp.seat.row + d[i][0];
int dy = temp.seat.col + d[i][1];
// 未访问并且通路
if (!vis[dx][dy] && !maze.arr[dx][dy])
{
/*MarkPrint(maze, que[tail].seat);*/
que[tail].seat.row = dx;
que[tail].seat.col = dy;
que[tail++].pre = head - 1;
vis[dx][dy] = 1;
}
}
}
return 0;
}
// 广搜标记地图
void Sign(MazeType& maze, int ans)
{
if (que[ans].pre != -1)
{
Sign(maze, que[ans].pre);
}
FootPrint(maze, que[ans].seat);
return;
}
// 清除错误路径
void Clean(MazeType& maze)
{
for (int i = 1; i < ROW - 1; i++)
{
for (int j = 1; j < COL - 1; j++)
{
if (maze.arr[i][j] == 3)
maze.arr[i][j] = 0;
}
}
printf("\n-------------- 清除错误路径 --------------\n");
printf("\n-------------------------------------------------\n");
printf("\n迷宫路径如下：\n");
printf("(其中'*'表示求解路径)\n");
// 输出迷宫路径
PrintMaze(maze, ROW, COL);
}
// 结束界面
void GoodBye()
{
system("cls");
printf("ByeBye！！！\n");
Sleep(1000);
exit(0);
}
