迷宫问题求解--完整可编译源码

经典迷宫问题求解，编译已经通过并且大作业验收，笔者总共写过两次迷宫，第一次是在C语言期末小作业使用递归写的，第二次在暑假小学期使用BFS算法写的，给初入C语言的小伙伴借鉴一下吧（笔者当时写一个小破迷宫花了一周，因为实在找不到参考，网上的代码很杂很乱，绝大部分不能编译，对新手很不友好，各种定义新手很难看不懂，所以我当时就有想法想着给C语言初学者一个好的学习代码！可以少走弯路！）
创建迷宫无非就是两步，第一构建迷宫，第二走迷宫，创建迷宫呢，得先想好怎么存储迷宫，最简单的办法就是数组，然后怎么构建迷宫呢？笔者时间有限，在这不展开论述，大家可以看看其他视频就知道了，这里我也给出全部代码和大家共同学习进步。走迷宫的方法也很多，递归，栈，队列，BFS，DFS都可以，笔者使用两种办法走迷宫。

首先就是笔者第一次写的递归走迷宫，代码如下，代码十分简略，当时水平有限，也就只能靠自己使用递归写出一个简简单单的迷宫，第一份代码比较简单，再菜靠自己也能看懂。

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int createMaze();       //创建随机迷宫
int createFreeMaze();   //创建自定义迷宫
void createWall();      //创建迷宫外墙
int visit(int row2, int col2) ;

int startI = 1, startJ = 1;   // 入口
int success = 0;
//迷宫数组
int maze[100][100];
int row = 0;
int col = 0;
int i,j;
//迷宫矩阵，2代表墙壁，0代表通道

//创建迷宫外墙
void createWall()   
{
    //创建迷宫外墙,第一行、第一列、最后一行、最后一列均为墙壁
    for( i = 0; i < col; i++)//第一行
         maze[0][i] = 2;
    for( i = 1; i < row; i++)//第一列
         maze[i][0] = 2;
    for( i = 1; i < col; i++)//最后一行
         maze[row-1][i] = 2;    
    for(i = 1; i < row-1; i++)//最后一列
         maze[i][col-1] = 2;
    

}

//创建随机迷宫
int createMaze()
{
    srand(time(0));
    for( i = 1; i < row-1; i++)
    {
        for( j = 1; j < col-1; j++)
        {
             if((rand()%100+1) % 2 == 0)
                maze[i][j] = 0;
             else
                maze[i][j] = 2;
         }
     }
    maze[1][1] = 0;
    maze[row-2][col-2] = 0;
}

//创建自定义迷宫
int createFreeMaze()
{
    for( i = 1; i < row-1; i++)
    {
        //第一行，第一格为入口
        if(i == 1)
        {
           printf("迷宫第%d行，共%d格：  ",i,col-3);
           for( j = 2; j < col-1; j++)
              scanf("%d",&maze[i][j]);
        }
        //最后一行,最后一格为出口
        else if(i == row-2)  
        {
            printf("迷宫第%d行，共%d格：",i,col-3);
            for( j = 1; j < col-2; j++)
               scanf("%d",&maze[i][j]);
        }
        else
        {
            printf("迷宫第%d行，共%d格：",i,col-2);
            for( j = 1; j < col-1; j++)
                scanf("%d",&maze[i][j]);
         }
     }
    maze[1][1] = 0;           //入口为通道
    maze[row-2][col-2] = 0;   //出口为通道
}

int visit(int row2, int col2) 
{ 
    int endI = row-2, endJ = col-2;      // 出口
    //该点走过，标记为1
    maze[row2][col2] = 1; 
    //走到终点，成功
    if(row2 == endI && col2 == endJ)
        success = 1; 
    //向四个方向递归调用函数visit()
    if(success != 1 && maze[row2][col2+1] == 0) 
          visit(row2, col2+1); 
    if(success != 1 && maze[row2+1][col2] == 0) 
          visit(row2+1, col2); 
    if(success != 1 && maze[row2][col2-1] == 0) 
          visit(row2, col2-1); 
    if(success != 1 && maze[row2-1][col2] == 0) 
          visit(row2-1, col2); 
 
    //该点走过，但没成功，则该点重新置为0
    if(success != 1) 
        maze[row2][col2] = 0; 
    
    return success; 
}

int main(void) 
{ 
    int i, j,choice;

    printf("请输入迷宫行数row(0<row<100)：");    
    scanf("%d",&row);
    printf("请输入迷宫列数col(0<col<100)：");
    scanf("%d",&col);

    createWall();//创建迷宫外墙


    printf("请选择创建随机迷宫还是自定义迷宫（1为随机迷宫，2为自定义迷宫）:");
    scanf("%d",&choice);
    if(choice == 1)
    {
        createMaze();   //创建迷宫
    }
    else if(choice == 2)
    {
         printf("\n请输入自定义迷宫的墙壁和通道，2代表墙壁，0代表通道\n");
         createFreeMaze();
     }

    printf("\n显示迷宫：\n"); 
    for(i = 0; i < row; i++)
    { 
        for(j = 0; j < col; j++) 
        {
            if(maze[i][j] == 2) 
                printf("国"); 
            else 
                printf("  "); 
        }
       printf("\n"); 
    }

    if(visit(startI, startJ) == 0)
    {
        printf("\n没有找到出口！\n"); 
    }
   else 
   { 
        printf("\n显示路径：\n"); 
        for(i = 0; i < row; i++) 
       { 
            for(j = 0; j < col; j++)
            { 
                if(maze[i][j] == 2) 
                    printf("国"); 
                else if(maze[i][j] == 1) 
                    printf("->"); 
                else 
                    printf("  "); 
            } 
            printf("\n"); 
        } 
    }

system("pause");

    return 0; 
}

然后就是笔者暑假小学期写的一个迷宫，这次写的迷宫比较第一次写的算是有一个进步吧。代码如下，均已编译通过验收，使用的软件是VS2019 ，BFS算法走迷宫：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<windows.h>
#include<time.h>
int map[100][100],map1[100][100];
int max_x, max_y;
int pre[10000];
void build();
int IsHaveNeighbor(int X_index, int Y_index);
void Creat(int X_index, int Y_index);
void print();
int I, J;

struct node
{
	int x, y;//横纵坐标
}que[36000], start, end;
int xx[] = { -1, 1, 0, 0 };//横坐标的变化，上下左右四个方向
int yy[] = { 0, 0, -1, 1 };//纵坐标
void show(int a)
{
	int b = pre[a];//指向前一个点
	if (b == 0)
	{
		//printf("(0, 0)\n");
		//printf("(%d, %d)\n", que[a].x, que[a].y);
		map[que[a].x][que[a].y] = 1;
		return;
	}
	else
		show(b);
	//printf("(%d, %d)\n", que[a].x, que[a].y);
	//printf("bfs\n");
	map[que[a].x][que[a].y] = 1;
}
void bfs(int a, int b)
{
	int front = 0, rear = 0;
	end.x = a;
	end.y = b;
	map1[a][b] = 0;
	pre[0] = -1;
	
	que[rear++] = end;
	while (front < rear)
	{
		
		start = que[front];
		//printf("%d\n",q.x);
		if (start.x == max_x-2 && start.y == max_y-2)//走到终点
		{
			show(front);
			printf("bfs算法\n");
			printf("⊙是起点，☆是终点，◇是路径\n");
			return;
		}
		for (int i = 0; i < 4; i++)
		{
			end.x = start.x + xx[i];
			end.y = start.y + yy[i];
			if (map[end.x][end.y] == 5 && map1[end.x][end.y] == 5)
			{
				pre[rear] = front;
				//rear = rear + 1;
				que[rear++] = end;
				map1[end.x][end.y] = 0;
			}			
		}
		front++;
		
	}
	return;
}

void build()
{
	int i, j;
	i = rand() % max_x;
	j = rand() % max_y;
	if (i % 2 == 0)
		i = i + 1;
	if (i == max_x)
		i = i - 2;
	if (j % 2 == 0)
		j = j + 1;
	if (j == max_y)
		j = j - 2;

	//map[i][j] = 3;
	I = i;
	J = j;
	Creat(i, j);
	//printf("%d,%d", i, j);
}
int IsHaveNeighbor(int X_index, int Y_index)
{
	int i, j, flag = 0;
	
	if ((X_index >= 3 && map[X_index - 2][Y_index] == 1) || (X_index < max_x - 3 && map[X_index+ 2][Y_index] == 1) || (Y_index >= 3 && map[X_index][Y_index - 2] == 1) || (Y_index < max_y - 3 && map[X_index][Y_index + 2] == 1))
			return 1;
	else
		return 0;
}
void Creat(int X_index,int Y_index)
{
	int rand_position, x, y, flag = 0;
	x = X_index;
	y = Y_index;
	//如果四个方向都没有了，返回上一步，否则，继续
	while (1)
	{
		flag = 0;
		flag = IsHaveNeighbor(X_index, Y_index);
		if (flag == 0)
		{
			return;
		}
		else
		{
			map[X_index][Y_index] = 5;
			x = X_index;
			y = Y_index;
			while (1)
			{
				rand_position = rand() % 4;
				if (rand_position == 0 && X_index >= 3 && map[X_index - 2][Y_index] == 1)//上
				{
					X_index = X_index - 2;
				}
				else if (rand_position == 1 && X_index < max_x - 3 && map[X_index + 2][Y_index] == 1)//下
				{
					X_index = X_index + 2;
				}
				else if (rand_position == 2 && Y_index >= 3 && map[X_index][Y_index - 2] == 1)//左
				{
					Y_index -= 2;
				}
				else if (rand_position == 3 && Y_index < max_y - 3 && map[X_index][Y_index + 2] == 1)//右
				{
					Y_index += 2;
				}
				else continue;
				map[(x + X_index) / 2][(y + Y_index) / 2] = 5;
				map[X_index][Y_index] = 5;
				Creat(X_index, Y_index);
				break;
			}
		}
	}

}

void print()
{
	int i, j;
	map[max_x - 2][max_y - 2] = 4;
	map[I][J] = 3;
	for (i = 0; i < max_x; i++)
	{
		for (j = 0; j < max_y; j++)
		{
			if (map[i][j] == 3) //3是起点
				printf("⊙");
			if (map[i][j] == 0)// 0是墙
				printf("■");
			if (map[i][j] == 5) //5是通路
				printf("  ");
			if (map[i][j] == 4)//4是终点
				printf("☆");
			if (map[i][j] == 1)
				printf("◇");
		}
		printf("\n");
	}

}

int main()
{
	int i, j, k;
	printf("请输入迷宫的行数和列数\n");
	scanf("%d%d", &max_x, &max_y);
	if (max_x % 2 == 0)
		max_x += 1;
	if (max_y % 2 == 0)
		max_y += 1;
	srand((unsigned)time(NULL));

	system("mode con cols=220 lines=100");
	system("color 0A");
	for (i = 0; i < max_x; i++)
	{
		for (j = 0; j < max_y; j++)
		{
			map1[i][j] = 5;
			if (i % 2 != 0 && j % 2 != 0)
			{
				map[i][j] = 1;
			}
			else map[i][j] = 0;
			printf("%d ", map[i][j]);

		}

		printf("\n");
	}

	build();
	printf("请选择起点模式");
	printf("\n1. 随机起点  2.（1，1）为起点\n");
	scanf("%d", &k);
	if (k == 1)
		bfs(I, J);
	else if (k == 2)
	{
		bfs(1, 1);
		I = 1;
		J = 1;
	}
	print();


}