深度寻路算法-迷宫问题

主要用栈实现回溯，实现从起点到指定位置的路径寻找

 网上找的一个栈模板

MyStack.h头文件代码：

#pragma once
template<class T>
class MyStack{
	T*		pBuff;	//内存首地址
	size_t	len;	//元素个数
	size_t	maxLen; //内存大小
public:
	MyStack(){ pBuff = NULL; len = maxLen = 0; }
	~MyStack(){ if (pBuff) delete[] pBuff; pBuff = NULL; len = maxLen = 0; }

	//入栈
	void push(const T& data);
	//出栈
	void pop(){ len--; }
	//获取栈顶元素
	T getTop(){ return pBuff[len - 1]; }
	//判断栈是否为空
	bool isEmpty(){ return (len == 0); }
};

template<class T>
//入栈
void MyStack<T>::push(const T& data){
	//1 判断是否需要重开内存
	if (len <= maxLen){
		//2 获取新开内存大小
		maxLen = maxLen + (((maxLen >> 1) > 1) ? (maxLen >> 1) : 1);
		//3 新开内存
		T* pTemp = new T[maxLen];
		//4 是否原来有内存
		if (pBuff){
			//5 拷贝原来的数据
			memcpy(pTemp, pBuff, sizeof(T)*len);
			//6 释放原有内存
			delete[] pBuff;
		}

		//7 pBuff指向新开内存
		pBuff = pTemp;
	}

	//8 新数据进栈
	pBuff[len++] = data;
}

#include<Windows.h>
#include <iostream>
#include<stdio.h>
#include "../../../../Desktop/20210823-深度寻路算法/MyStack.h"
#define rows 10
#define cols 10

enum direct{up,down,left,right};
struct myPoint {
    int row;//行
    int col;//列
};
struct pathNode {
    int dir; //当前尝试方向
    bool isFind;//是否走过
};
void  printMap(int map[rows][cols],myPoint pos) {
    Sleep(400);
    printf("\n\n\n\n");
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            if (pos.row == i && pos.col == j) {
                printf("人");
            }
            else if (0 == map[i][j]) {
                printf("  ");
            }
            else if (1 == map[i][j]) {
                printf("墙");
            }
        }
        printf("\n");
    }
}
int main()
{
    int map[rows][cols] = {
        {1,1,1,1,1,1,1,1,1,1},
        {1,0,1,0,1,1,0,1,1,1},
        {1,0,1,0,1,1,0,0,1,1},
        {1,0,0,0,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,1},
        {1,0,1,0,0,1,0,0,0,1},
        {1,0,1,1,0,1,0,1,0,1},
        {1,1,1,1,1,1,1,1,1,1},
    };
    pathNode pathMap[rows][cols] = { 0 };

    //起点和终点
    myPoint begpos = { 1,1 };
    myPoint endpos = { 8,6 };
    //是否找到终点标记
    bool isFindend = false;
    //设置起点\走过
    pathMap[begpos.row][begpos.col].isFind = true;
    //制作一个栈
    MyStack<myPoint>stack;
    stack.push(begpos);
    myPoint currentPos = begpos;//当前点
    myPoint searchPos;//试探点
    while(1){
        //1.找到试探点
        searchPos = currentPos;
        switch (pathMap[currentPos.row][currentPos.col].dir) {
        case up:
            searchPos.row--;
            //改变当前点的试探方向
            pathMap[currentPos.row][currentPos.col].dir = down;
            //2.判断能不能走
            if (map[searchPos.row][searchPos.col] == 0 && pathMap[searchPos.row][searchPos.col].isFind == false) {  //能走
                currentPos = searchPos;
                //标记走过
                pathMap[currentPos.row][currentPos.col].isFind = true;
                //入栈
                stack.push(currentPos);
            }
            break;
        case down:
            searchPos.row++;
            //改变当前点的试探方向
            pathMap[currentPos.row][currentPos.col].dir = left;
            //2.判断能不能走
            if (map[searchPos.row][searchPos.col] == 0 && pathMap[searchPos.row][searchPos.col].isFind == false) {  //能走
                currentPos = searchPos;
                //标记走过
                pathMap[currentPos.row][currentPos.col].isFind = true;
                //入栈
                stack.push(currentPos);
            }
            break;
        case left:
            searchPos.col--;
            //改变当前点的试探方向
            pathMap[currentPos.row][currentPos.col].dir = right;
            //2.判断能不能走
            if (map[searchPos.row][searchPos.col] == 0 && pathMap[searchPos.row][searchPos.col].isFind == false) {  //能走
                currentPos = searchPos;
                //标记走过
                pathMap[currentPos.row][currentPos.col].isFind = true;
                //入栈
                stack.push(currentPos);
            }
            break;
        case right:
            searchPos.col++;
            //2.判断能不能走
            //3.能走就走，标记走过，入栈，改试探方向，不能走也要改试探方向
            if (map[searchPos.row][searchPos.col] == 0 && pathMap[searchPos.row][searchPos.col].isFind == false) {  //能走
                currentPos = searchPos;
                //标记走过
                pathMap[currentPos.row][currentPos.col].isFind = true;
                //入栈
                stack.push(currentPos);
            }
            else {//4.前面三个方向不能走只需要改变试探方向，往右还不能走只能回退
                //删除当前栈顶元素
                stack.pop();
                //跳到当前栈顶元素
                currentPos = stack.getTop();
            }
            break;
        }        
        printMap(map, currentPos);
        //5.判断是否找到终点 结束循环 全部地图都找到遍了，回到原点，结束循环
        if (endpos.row == currentPos.row && endpos.col == currentPos.col) {
            isFindend = true;
            break;
        }
        if (stack.isEmpty())break;
    }
    if (isFindend) {
        printf("找到终点！\n");
        printf("path:");
        while (!stack.isEmpty()) {
            printf("(%d,%d)", stack.getTop().row, stack.getTop().col);
            stack.pop();
            }
        printf("\n");
    }
    else {
        printf("没有找到终点!\n");
    }
    while (1);
    return 0;
}

结果会输出起点到终点路径：