【C语言】迷宫

一，涉及知识点

结构体，栈，递归

二，实现逻辑

1.定义一个结构体保存当前位置坐标
2.用数组初始化一个迷宫，1表示可以走，0表示墙，迷宫最后一列都是出口
3.打印迷宫
4.走迷宫方法一：使用栈，通过压栈出栈回溯；方法二：在栈的基础上，用递归做回溯
5.记录最短路径，把路径压入栈中，打印最短路径

三，源码

#pragma once
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <stdio.h>

#define ROWS (6)       //行数
#define COLS (6)        //列数
#define MAX_SIZE (100)

//结构体存放坐标
typedef struct Position
{
	int x;
	int y;
}Position;
typedef Position StackDataType;
//栈
typedef struct Stack
{
	StackDataType array[MAX_SIZE];
	int top;        //表示当前个数
}Stack;
void StackInit(Stack *pStack)
{
	pStack->top = 0;
}
void StackDestroy(Stack *pStack)
{
	pStack->top = 0;
}
void StackPush(Stack *pStack, StackDataType data)
{
	assert(pStack->top < MAX_SIZE);
	//pStack->top 永远指向的栈顶后的一个空间
	pStack->array[pStack->top++] = data;
}
void StackPop(Stack *pStack)
{
	assert(pStack->top>0);
	pStack->top--;
}
Position StackTop(Stack *pStack)
{
	assert(pStack->top > 0);
	return pStack->array[pStack->top-1];
}
int StackSize(const Stack *pStack)
{
	return pStack->top;
}
int StackFull(const Stack *pStack)
{
	return pStack->top >= MAX_SIZE;
}
int StackEmpty(const Stack *pStack)
{
	return pStack->top <= 0;
}
void StackCopy(Stack *pDest,Stack *pSrc)
{
	memcpy(pDest->array, pSrc->array, sizeof(StackDataType)*pSrc->top);
	pDest->top = pSrc->top;
}

Stack path;     //当前路径
Stack min;      //之前的最小路径

//简单迷宫
int gMaze[ROWS][COLS] = {
            { 0, 0, 0, 0, 0, 0 },
            { 0, 0, 1, 0, 0, 0 },
            { 0, 0, 1, 0, 0, 0 },
            { 0, 0, 1, 1, 1, 0 },
            { 0, 0, 1, 0, 1, 1 },
            { 0, 0, 1, 0, 0, 0 }
};
//入口
Position gEntry = { 5, 2 };
//判断是否走到出口，最后一列都是出口
int IsExit(Position pos)
{
	if (pos.y == COLS - 1){
		return 1;
	}
	else {
		return 0;
	}
}
//判断是否可以走,没有越界&&值是1
int CanPass(Position pos)
{
	if (pos.x >= ROWS){
		return 0;
	}
	if (pos.y >= COLS){
		return 0;
	}
	return gMaze[pos.x][pos.y] == 1;
}
//打印路径
void PrintPath(Stack *pStack)
{
	Position at;
	for (int i = 0; i < pStack->top; i++){
		at = pStack->array[i];
		printf("x=%d y=%d\n", at.x, at.y);
	}
}
//打印迷宫
void PrintMaze()
{
	for (int i = 0; i < ROWS;i++){
		for (int j = 0; j < COLS;j++){
			if (gMaze[i][j] == 0)
			{
				printf("■", gMaze[i][j]);
			}
			else if (gMaze[i][j] == 1)
			{
				printf("  ", gMaze[i][j]);
			}
			else if (gMaze[i][j] == 2){
				printf("☆", gMaze[i][j]);
			}
		}
		printf("\n");
	}
	printf("\n\n");
}
//方法二
//调用栈做回溯,递归
void RunMazeRec(Position at)
{
	Position next;
	StackPush(&path,at);

	//一进来标记我走过了
	gMaze[at.x][at.y] = 2;
	PrintMaze();

	if (IsExit(at)){
		//如果当前路径(path)小于之前的最小路径(min)，最小路径是path
		if (StackEmpty(&min) || StackSize(&path) < StackSize(&min)){
			StackCopy(&min, &path);
            //打印出最短路径
			PrintPath(&path);
		}
	}
	//根据左->上->右->下来尝试
	//左
	next.x = at.x;
	next.y = at.y - 1;
	if (CanPass(next)){
		RunMazeRec(next);//递归
		//PrintMaze();
	}
	//上
	next.x = at.x - 1;
	next.y = at.y;
	if (CanPass(next)){
		RunMazeRec(next);
		//PrintMaze();
	}
	//右
	next.x = at.x;
	next.y = at.y + 1;
	if (CanPass(next)){
		RunMazeRec(next);
		//PrintMaze();
	}
	//下
	next.x = at.x + 1;
	next.y = at.y;
	if (CanPass(next)){
		RunMazeRec(next);
		//PrintMaze();
	}
	//如果at的四周都没法儿走，at重新置为1
	gMaze[at.x][at.y] = 1;
	StackPop(&path);
	return;   //回溯
}

//方法一
//需要一个栈回溯，压栈出栈
void RunMaze()
{
	Stack stack;
	StackInit(&stack);
	Position next;
	Position at;
	at.x = gEntry.x;
	at.y = gEntry.y;
	
	while (1){
		//一进来标记我走过了
		gMaze[at.x][at.y] = 2;
		PrintMaze();
		//把当前位置压入栈中，方便做回溯
		StackPush(&stack, at);

		if (IsExit(at)){
			//如果到了出口，退出
			PrintPath(&stack);
			return;
		}
		//根据左->上->右->下来尝试
		//左
		next.x = at.x;
		next.y = at.y - 1;
		if (CanPass(next)){
			at.x = next.x;
			at.y = next.y;
			continue;
		}
		//上
		next.x = at.x - 1;
		next.y = at.y;
		if (CanPass(next)){
			at.x = next.x;
			at.y = next.y;
			continue;
		}
		//右
		next.x = at.x;
		next.y = at.y + 1;
		if (CanPass(next)){
			at.x = next.x;
			at.y = next.y;
			continue;
		}
		//下
		next.x = at.x + 1;
		next.y = at.y;
		if (CanPass(next)){
			at.x = next.x;
			at.y = next.y;
			continue;
		}
		//如果四周都没法儿走，出栈
		StackPop(&stack);
		if (StackEmpty(&stack)){
			printf("没有出口\n");
			return;
		}
		at = StackTop(&stack);   //回溯
		StackPop(&stack);
	}
}
void testRunMazeRec()
{
	StackInit(&path);
	StackInit(&min);
	PrintMaze();
	RunMazeRec(gEntry);
}
int main()
{
	PrintMaze();
	//RunMaze();  
	testRunMazeRec();
	system("pause");
	return 0;
}