c数据结构-栈-迷宫问题（循环实现）

2019年3月24日 307次阅读 来源: 迷宫问题

走迷宫步骤：

  1. 使用二维数组来表示迷宫地图。1表示可以走，0表示不能走。
  2. 设置迷宫入口。
  3. 判断迷宫入口是否合法。
  4. 将入口点入栈
  5. 将当前点设置为入口点。
  6. loop：
  7. 判断是否能往左走，能则将当前点压栈。goto loop
  8. 判断是否能忘上走，能则将当前点压栈。goto loop
  9. 判断是否能往右走，能则将当前点压栈。goto loop
  10. 判断是否能往下走，能则将当前点压栈。goto loop
  11. 判断是否到达出口
  12. 判断是否到达死胡同  是 ？出栈：将弹出的点设置为当前点 goto loop

迷宫定义：

typedef struct Maze
{
	int _map[MAX_ROW][MAX_COL];
}Maze;

压栈的点定义：

typedef struct Position {
	int x;
	int y;
}Position;

栈定义：

#define Init_StackSize 100

typedef Position DataType;

typedef struct Stack {
	//以数组地址为栈底指针  
	DataType* _array;
	//栈顶指针  
	int _top;
	//栈的大小  
	unsigned int _capacity;
}Stack;

具体代码实现：

// 1. 对简单迷宫进行求解----只有一条通路，迷宫不带环
// >> 用循环的方式求解简单迷宫问题
#include <stdio.h>
#include <stdlib.h>
#include "stack.h"
#define MAX_ROW 6 
#define MAX_COL 6 

// 判断是不是通路，判断是不是分支节点，入栈操作，判断是不是出口
#define OPERATE if (IsPass(m, cur))\
				{\
					if (isBranch == 1)\
						StackPush(s, next);\
					isBranch = 0;\
					m->_map[cur.y][cur.x] = 2;\
					next = cur;\
					StackPush(s, cur);\
					if (IsMazeExit(m, cur, enter))\
						return;\
					continue;\
				}

typedef struct Maze
{
	int _map[MAX_ROW][MAX_COL];
}Maze;

// 初始化迷宫地图数据 
void InitMap(Maze* m, int map[MAX_ROW][MAX_COL]);

// 检测迷宫的入口是否有效 
int IsValidEnter(Maze* m, Position enter);

// 检测cur位置是否为迷宫的出口 
int IsMazeExit(Maze* m, Position cur, Position enter);

// 检测当前位置是否为通路 
int IsPass(Maze* m, Position cur);

// 走迷宫 
void PassMazeNor(Maze* m, Position enter, Stack* s);

// 打印迷宫地图数据 
void PrintMap(Maze* m);

// 打印路径 
void PrintPath(Stack* s);

int main() {
	int map[MAX_ROW][MAX_COL] = { 
		{ 0, 0, 0, 0, 0, 0 },
		{ 0, 1, 0, 1, 0, 0 },
		{ 0, 1, 0, 1, 0, 0 },
		{ 0, 1, 1, 1, 1, 1 },
		{ 0, 0, 0, 1, 0, 0 },
		{ 0, 0, 0, 1, 0, 0 },
	};

	Maze* m = malloc(sizeof(Maze));
	if (m == NULL)
		return;

	InitMap(m, map);
	PrintMap(m);
	Position enter = {3, 5};
	Stack* path = (Stack*)malloc(sizeof(Stack));
	StackInit(path);
	PassMazeNor(m, enter, path);
	// 打印路径 
	printf("\n");
	PrintMap(m);
	PrintPath(path);
	return 0;
}

// 初始化迷宫地图数据 
void InitMap(Maze* m, int map[MAX_ROW][MAX_COL]) {
	for (int i = 0; i < MAX_COL; i++) {
		for (int j = 0; j < MAX_ROW; j++) {
			m->_map[i][j] = map[i][j];
		}
	}
}

// 检测迷宫的入口是否有效 
int IsValidEnter(Maze* m, Position enter) {
	if (m->_map[enter.y][enter.x] != 0)
		return 1;
	return 0;
}

// 检测cur位置是否为迷宫的出口 
int IsMazeExit(Maze* m, Position cur, Position enter) {
	if (cur.x != enter.x && cur.y != enter.y && (cur.x >= MAX_ROW - 1 || cur.y >= MAX_COL - 1 || cur.x <= 0 || cur.y <= 0)) {
		printf("找到出口\n");
		return 1;
	}
	return 0;
}

// 检测当前位置是否为通路 
int IsPass(Maze* m, Position cur) {
	if (m->_map[cur.y][cur.x] == 1)
		return 1;
	return 0;
}

// 走迷宫 
void PassMazeNor(Maze* m, Position enter, Stack* s) {
	if (!IsValidEnter(m, enter))
		return;

	//判断是不是分支节点
	int isBranch = 0;

	m->_map[enter.y][enter.x] = 2;
	Position cur = enter;
	Position next = enter;

	StackPush(s, enter);
	while (1) {

		//左
		cur = next;
		cur.x--;
		//宏：定义了走迷宫的步骤
		OPERATE;

		//上
		cur = next;
		cur.y--;
		OPERATE;

		//右
		cur = next;
		cur.x++;
		OPERATE;

		//下
		cur = next;
		cur.y++;
		OPERATE;

		if (StackEmpty(s))
			return;

		StackPop(s, &next);
		isBranch = 1;
	}

}

// 打印迷宫地图数据 
void PrintMap(Maze* m) {
	for (int i = 0; i < MAX_COL; i++) {
		for (int j = 0; j < MAX_ROW; j++) {
			printf("%d ", m->_map[i][j]);
		}
		printf("\n");
	}
}

// 打印路径 
void PrintPath(Stack* s) {
	Position position;
	Stack* path = (Stack*)malloc(sizeof(Stack));
	StackInit(path);
	while (!StackEmpty(s)) {
		StackPop(s, &position);
		StackPush(path, position);
	}
	while (!StackEmpty(path)) {
		StackPop(path, &position);
		printf("(%d, %d)-->", position.x, position.y);
	}
}

栈的操作：

#include "stack.h"
#include "assert.h"
//初始化栈  
void StackInit(Stack* stack) {
	stack->_array = (DataType*)malloc(sizeof(DataType)*Init_StackSize);
	if (!stack->_array) {
		exit(0);
	}
	stack->_top = 0;
	stack->_capacity = Init_StackSize;
}

//压栈  
void StackPush(Stack* stack, DataType data) {
	assert(stack);
	//判断栈是否已满  
	if (stack->_top >= stack->_capacity) {
		//申请10个空间  
		stack->_array = (DataType*)realloc(stack->_array,
			sizeof(DataType)*(stack->_capacity + 10));
		//判断是否申请成功  
		if (!stack->_array) {
			exit(0);
		}
		stack->_top = stack->_capacity;
		stack->_capacity = stack->_capacity + 10;
	}

	*(stack->_array + stack->_top) = data;
	stack->_top++;
}

//出栈  
int StackPop(Stack* stack, DataType* data) {
	assert(stack);
	//判断栈是否为空  
	if (stack->_top == 0) {
		return 0;
	}
	//先减一再取值  
	--stack->_top;
	*data = *(stack->_array + stack->_top);

	return 1;
}

//判断栈是否为空  
int StackEmpty(Stack* stack) {
	assert(stack);
	//为空返回1  
	return stack->_top == 0 ? 1 : 0;
}

运行结果截图：

《c数据结构-栈-迷宫问题（循环实现）》

    原文作者：迷宫问题
    原文地址: https://blog.csdn.net/bugggget/article/details/80031998
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞