迷宫问题(C语言实现)

问题描述

定义一个二维数组：

int maze[5][5] = {

0, 1, 0, 0, 0,

0, 1, 0, 1, 0,

0, 0, 0, 0, 0,

0, 1, 1, 1, 0,

0, 0, 0, 1, 0,

};

它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。
Input
一个5 × 5的二维数组，表示一个迷宫。数据保证有唯一解。
Output
左上角到右下角的最短路径，格式如样例所示。
Sample Input
0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0

思路（DFS寻路）

• 首先将迷宫存在一个二位数组中，然后遍历数组，遇到1则改变方向，遇到0接着向下走，将此点存入栈中，如果无路，则返回上一结点，将此结点移出栈，并将此点的数组值更改为1，防止死循环。直至找到出口。

struct path
{
	int x;            //横座标
	int y;  		  //纵座标
	struct path *next;
};

typedef struct Link
{
	struct path *head;
}link;

//此处已将队列更换为栈，因为之前的队列删除尾节点会将队列结构完全破坏，而造成队列不能正确工作，sorry！！！


//模拟为栈
void push(link *que, int x, int y)
{
	struct path *p;
	p = (struct path*)malloc(sizeof(struct path));
	p->x = x;
	p->y = y;
	p->next = que->head;;
	que->head = p;
/*
	que->rear->next = p;
	que->rear = p;
	que->rear->next = NULL;
*/
}

void pop(link *que)
{
	//如果不合适将刚入栈的节点删除
	que->head = que->head->next;  //删除栈的头结点就会变得很简单
}

//此处已经不需要这个函数，太多余！
/*
void pop2(link *que, int *x, int *y)
{
	struct path *temp;
	temp = que->head->next;
	que->head->next = temp->next;      //将temp结点出队
	*x = temp->x;
	*y = temp->y;
	free(temp);
}
*/

• 写好队列的实现后，我们来实现对迷宫的分析，此处没有更正，递归是正确的！

/*用递归对迷宫进行遍历*/
void r(int a[5][5], int x, int y, link *que)
{   
    if( x < 5 && x >= 0 && y < 5 && y >= 0)
    {
        if(x == 4 && y == 4)  //到达迷宫出口
            return;
        /*首先判断右边下一个点是否可以走*/
        if(a[x][y + 1] == 0 && (y + 1) < 5) //此处为了防止数组越界
        {
            y++;
            push(que, x, y);   //可以走就将该结点入队
            r(a, x, y, que);   //递归下一个座标
            return;
        }
        /*上一个条件不满足就判断其向下是否能走*/
        if(a[x + 1][y] == 0 && (x + 1) < 5)//防止数组越界
        {
            x++;
            push(que, x, y);       //入队
            r(a, x, y, que);       //递归
            return;
        }
        /*无路可走，就返回上一个座标*/
        if(a[x - 1][y] == 0 && x - 1 >= 0)
        {
            a[x][y] = 1; //并将该点设为1，防止死循环
            pop(que);    //将该座标移出队列
            x--;
            r(a, x, y, que);
            return;
		 }
        if(a[x][y - 1] == 0 && y - 1 >= 0)
        {
            a[x][y] = 1;
            pop(que); //移出队列
            y--;
            r(a, x, y, que);
            return;
        }
    }
}   

总结

1、用到递归和栈的思想，将迷宫当作矩阵，遍历，判断下一个座标是否可以通过，如果不行则换方向，如果无路可走则退格。
2、自己今天有很多思想没有思考到，写一篇博客加深一下印象。

博客如有错误，欢迎大家评论指出，一起探讨一起进步。感谢！！

完整代码

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

//迷宫问题

struct path
{
	int x;            //横座标
	int y;  		  //纵座标
	struct path *next;
};

typedef struct Link
{
	struct path *head;
}link;


//模拟为栈
void push(link *que, int x, int y)
{
	struct path *p;
	p = (struct path*)malloc(sizeof(struct path));
	p->x = x;
	p->y = y;
	p->next = que->head;;
	que->head = p;
/*
	que->rear->next = p;
	que->rear = p;
	que->rear->next = NULL;
*/
}

void pop(link *que)
{
	//如果不合适将刚入栈的节点删除
	que->head = que->head->next;
}

/*
void pop2(link *que, int *x, int *y)
{
	struct path *temp;
	temp = que->head->next;
	que->head->next = temp->next;      //将temp结点出队
	*x = temp->x;
	*y = temp->y;
	free(temp);
}
*/

void r(int a[5][5], int x, int y, link *que)
{
	if( x < 5 && x >= 0 && y < 5 && y >= 0)
	{
		if(x == 4 && y == 4)
			return;
		if(a[x][y + 1] == 0 && (y + 1) < 5)
		{
			y++;
			push(que, x, y);
			r(a, x, y, que);
			return;
		}
	    if(a[x + 1][y] == 0 && (x + 1) < 5)
		{
			x++;
			push(que, x, y);
			r(a, x, y, que);
			return;
		}
	    if(a[x - 1][y] == 0 && x - 1 >= 0)
		{
			a[x][y] = 1;
			pop(que);
			x--;
			r(a, x, y, que);
			return;
		}
	    if(a[x][y - 1] == 0 && y - 1 >= 0)
		{
			a[x][y] = 1;
			pop(que);
			y--;
			r(a, x, y, que);
			return;
		}
	}
}

int main(void)
{
	int a[5][5];
	int i, j;
	int x, y;
	for(i = 0; i < 5; i++)
	{
		for(j = 0; j < 5; j++)
		{
			scanf("%d", &a[i][j]);
		}
	}
	link *top, *temp;
	top = temp = (link *)malloc(sizeof(link));
	top->head = (struct path *)malloc(sizeof(struct path));
	r(a, 0, 0, top);
	printf("(0, 0)\n");
	//此处数组是为了存储路径，因为使用的是栈结构，所以存储的路径必然是倒序！
	int PATH[25] = {0};
	int count = 0;

	//将栈倒序的路径存储进数组中，二维数组太占用空间所以此处我们使用一维数组，并使用数学方法存储！！
	while(top->head->next != NULL)
	{
		PATH[count] = top->head->x *10 + top->head->y;
		++count;
		top->head = top->head->next;
	}
	for(i = count - 1; i >= 0; --i)
	{	
		int num_x = PATH[i] / 10;  //从数据中提取出X
		int num_y = PATH[i] % 10; //从数组中提取出Y
		//打印路径
		printf("(%d, %d)\n", num_x, num_y);
	}
	return 0;
}