【数据结构】栈的应用--深度寻路算法

实现思路

如图：我们在起点（1，1）的位置，要到达终点为（8，8）的位置：红色色为墙壁法无移动，白色为路径

已经走过的路会被标记为true，表示已走过，不可以重复再走一遍；没有走的为false，表示可以行走

起始点为（1，1）；试探点（下一步将要移动判断是否可走的一个临时点）为（1，1）;

试探方向 ： 顺时针 上右下左（优先按照顺序通行）

1. 首先我们在起点试探 上方向，为墙壁，所以我们无法移动。我们接着试探 右方向，发现也为墙壁，无法移动。接着试探 下方向，可以移动，则当前位置移动到（1，1）的位置。
2. 接着在新的位置重新开始上右下左的方向遍历，可以得到，继续往下移动，到达（3，1）
3. 接着往下移动，往下移动，往右移动，往右移动，往上移动，往上移动往上移动，往右移动，往上移动，注意：此时到达（1，4） 的位置，但是！！！这个地方是一个死胡同（四个方向都不能走）。请注意我们无法实现自主回退，因为我们无法重新行走已经走过的路径！！

那这样要怎么办呢？这里我们用到了栈回退的功能，我们用一个栈来存储每一步的x，y坐标，栈顶元素即为当前 的位置，我们到达死胡同时，会执行出栈操作，因为出栈会实现回退，这样我们的位置就回退到了（2，4）但是我们此时依旧是死胡同，因为走过的路不能重复走，所以我们必须继续栈回退，直到我们退到了一个可以继续走的位置：（4，3）（是一个十字路口），第一次我们往上走，走不通，所以这次我们会跳过上的方向，向右试探，发现可以走，于是向右移动到（4，4），接着往右，往下，往下…
绿色的路径表示最终所走的路径，蓝色路径表示走到了死胡同进行栈回退的路径；

栈结构准备

#define MaxSize 100 //定义栈中元素的最大个数
typedef struct Stack {
    Point data[MaxSize]; //存放栈中的元素
    int top; //栈顶指针
}Stack;

//初始化栈
void InitStack(Stack* stack);
//判断空栈
bool isEmpty(Stack* stack);
//进栈
void Push(Stack* stack, Point pos);
//出栈
void Pop(Stack* stack);
//读栈顶元素
Point GetTop(Stack* stack);

void InitStack(Stack* stack)
{
	stack->top = -1;
}

bool isEmpty(Stack* stack)
{
	if (stack->top == -1)
		return true;
	else
		return false;
}

void Push(Stack* stack, Point x)
{
	if (stack->top == MaxSize - 1)
	{
		printf("栈已经满了\n");
		return;
	}
	stack->data[++stack->top] = x;
}


void Pop(Stack* stack)
{
	if (stack->top == -1)
	{
		printf("栈已经空了\n");
		return;
	}
	stack->top--;
}

Point GetTop(Stack* stack)
{
	if (isEmpty(stack))
	{
		printf("栈空\n");
		return;
	}
	else
		return (stack->data[stack->top]);
}

算法实现

准备一个地图和一个辅助地图

#define ROW 10
#define COL 10
enum Dir { e_up, e_right, e_down, e_left };
enum Dtate { e_road, e_wall };
typedef struct pathNode
{
	int dir;	//当前点的当前试探方向
	bool isFind;	//是否走过
}pathNode;
typedef struct Point
{
	int x, y;
}Point;

//地图
	int map[ROW][COL] = {
		{1,1,1,1,1,1,1,1,1,1},
		{1,0,1,1,0,1,0,0,0,1},
		{1,0,1,0,0,1,0,1,0,1},
		{1,0,1,0,1,1,1,1,0,1},
		{1,0,1,0,0,0,1,1,0,1},
		{1,0,0,0,1,0,1,1,0,1},
		{1,0,1,1,1,0,0,0,0,1},
		{1,0,1,1,0,0,1,0,1,1},
		{1,0,1,0,0,1,1,0,0,1},
		{1,1,1,1,1,1,1,1,1,1}
	};
	//辅助地图
	pathNode pathMap[ROW][COL] = { 0 };

确定初始点、试探点和终点

	Point begPos = { 1,1 };//初始点
	Point endPos = { 8,8 };//终点
	pathMap[begPos.x][begPos.y].isFind = true;
	Point currentPos = begPos;//当前点
	Point searchPos;//试探点

初始点入栈

	Stack stack;
	InitStack(&stack);
	Push(&stack, begPos);

循环寻路

如果终点的坐标等于当前点的坐标，说明到达终点
如果最后栈为空，说明路径没有终点，因为到达死胡同会一直退栈，如果退栈到栈为空，说明整条路没有可以走的路了，则没有终点

while (1)
	{
		//找出试探点
		searchPos = currentPos;
		switch (pathMap[currentPos.x][currentPos.y].dir)
		{
		case e_up:
			searchPos.x--;
			//当前点试探方向改变
			pathMap[currentPos.x][currentPos.y].dir = e_right;

			//判断能不能走
			if (e_road == map[searchPos.x][searchPos.y] && pathMap[searchPos.x][searchPos.y].isFind == false)//能走
			{
				Push(&stack, searchPos);
				pathMap[searchPos.x][searchPos.y].isFind = true;
				currentPos = searchPos;
			}
			break;
		case e_right:
			searchPos.y++;
			//不管能不能走，当前点试探方向都是要改变的
			pathMap[currentPos.x][currentPos.y].dir = e_down;

			//判断能不能走
			if (e_road == map[searchPos.x][searchPos.y] && pathMap[searchPos.x][searchPos.y].isFind == false)//能走
			{
				Push(&stack, searchPos);
				pathMap[searchPos.x][searchPos.y].isFind = true;
				currentPos = searchPos;
			}
			break;

		case e_down:
			searchPos.x++;
			//不管能不能走，当前点试探方向都是要改变的
			pathMap[currentPos.x][currentPos.y].dir = e_left;

			//判断能不能走
			if (e_road == map[searchPos.x][searchPos.y] && pathMap[searchPos.x][searchPos.y].isFind == false)//能走
			{
				Push(&stack, searchPos);
				pathMap[searchPos.x][searchPos.y].isFind = true;
				currentPos = searchPos;
			}
			break;
		case e_left:
			searchPos.y--;
			//不管能不能走，当前点试探方向都是要改变的
			pathMap[currentPos.x][currentPos.y].dir = e_up;

			//判断能不能走
			if (e_road== map[searchPos.x][searchPos.y] && pathMap[searchPos.x][searchPos.y].isFind == false)//能走
			{
				Push(&stack, searchPos);
				pathMap[searchPos.x][searchPos.y].isFind = true;
				currentPos = searchPos;
			}
			else
			{
				Pop(&stack);
				if (!isEmpty(&stack))
				{
					currentPos.x = GetTop(&stack).x;
					currentPos.y = GetTop(&stack).y;
				}
			}
			break;
		default:
			break;
		}
		if (currentPos.x == endPos.x && currentPos.y == endPos.y)
		{
			printf("找到终点了\n");
			break;
		}
		//没有到达终点
		if (isEmpty(&stack))
		{
			printf("这条路没有终点!\n");
			return 0;
		}

	}

打印路径

如果找到了终点，那么栈中的数据就是最终所走的路径了

while (!isEmpty(&stack))
	{
		printf("(%d,%d) ", GetTop(&stack).x, GetTop(&stack).y);
		Pop(&stack);
	}

简单测试一下