数据结构递归与非递归走迷宫

今天做实验，走迷宫问题，要求用递归与非递归两种方法：

要求：

1）数据结构：

² 用二维数组MAZE[m+2][n+2]表示迷宫的结构，数组中的值为1表示是墙，为0表示可以走通。（用MAZE[m+2][n+2]而不用MAZE[m][n]的原因在于想表示和编写代码的时候简单些，而且让迷宫周围都是墙，防止错误的走出去）

² 用二维数组MARK[m+2][n+2]表示迷宫是否被走过，主要是为了回溯时已经证明走不通的路线就不要再去走了。（用MARK[m+2][n+2]而不用MARK[m][n]的原因在于想表示和编写代码的时候简单些）

² 二维数据MOVE[8][2]是为了更方便的移动到下一步，改变坐标。这个二维数组是为了更好的转换坐标（八个方向，从0到7），而且也能避免重复走路

² 用栈保存走过的路径

（2）输出：

² 迷宫布局，用0表示可以走通的地方，用1表示墙

² 如果能走通，则输出路径和路径的长度；若不能走通，则输出提示不能走通

² 带有路径的迷宫布局

以下是代码：

maze.h

#include<stack>
using namespace std;
const int rowsize = 10;             //定义走通路径时数组的下标
const int colsize = 11; 
const int MOVE[8][2]={{0,1},{1,1},{1,0},{1,-1},{-1,0},{-1,-1},{0,-1},{-1,1}};    //定义路径
struct step            //存放走通的路
{
    int x;
    int y;
    int mov;
};
class Maze
{
public:
    Maze();
    int  getmaze(int i,int j);            //返回路径
    bool solve(int i, int j);         //递归算法
    bool path();                //非递归算法
    int maze[12][12];             //用于储存迷宫
    stack<step> STACK;         //用于储存步骤
};

maze.cpp

#include"maze.h"
#include<ctime>
#include<cstdlib>
#include<iostream>
using namespace std;
Maze::Maze()
{
    srand((unsigned int) time(NULL));     //随机生成一个迷宫
    for(int i=0;i<12;i++)
    {
        for(int j=0;j<12;j++)
        {
            if(i!=0&&i!=11&&j!=0&&j!=11)
            {
                maze[i][j]=(int)rand()%2;
            }
            else
                maze[i][j]=1;
        }
    }
    maze[1][1]=0;         //将初位置和末位置都设为可以走通的状态'0'
    maze[10][10]=0;
    maze[10][11]=0;
} 
int Maze::getmaze(int i,int j)
    /*获取迷宫*/
{
    return maze[i][j];
}
bool Maze::path()                //非递归算法
{
    maze[1][1]='x';             //将第一个位置压栈
    int g=0,h=0;
    step STEP;
    STEP.x=1;
    STEP.y=1;
    STEP.mov=0;
    STACK.push(STEP);
    while(!STACK.empty())            //寻找路径
    {
        STEP=STACK.top();
        STACK.pop();
        while(STEP.mov!=8 )         //按八个方向寻找路径
        {
            g=STEP.x+MOVE[STEP.mov][0];
            h=STEP.y+MOVE[STEP.mov][1];
            if( g==rowsize && h==colsize)
            {
                return true;         //迷宫可以走通
            }
            if (maze[g][h]==0)
            {
                maze[g][h]='x';
                STACK.push(STEP);
                STEP.x=g;
                STEP.y=h;
                STEP.mov=0;
            }
            else
            {          
                STEP.mov=STEP.mov+1;         //改变方向搜索
            }
        }
        if(STEP.mov==8) //若八个方向都走不通就把该位置标记为'Y'即表示该位置已经走过且走不通
        {
            maze[STEP.x][STEP.y]='Y';
            STEP.mov=0;
        }
    }
        return false;             //走不通
}

bool Maze::solve(int i,int j)
{
    bool finish = false;
    maze[i][j] = 'X';
    if (i == rowsize && j == colsize)
        return true; // because we're done
    if (!finish && maze[i+1][j] == 0)
        finish = solve(i+1, j);
    if (!finish && maze[i][j+1] == 0)
        finish = solve(i, j+1);
    if (!finish && maze[i-1][j] == 0)
        finish = solve(i-1, j);
    if (!finish && maze[i][j-1] == 0)
        finish = solve(i, j-1);
    if (!finish && maze[i-1][j-1] == 0)
        finish = solve(i-1, j-1);
    if (!finish && maze[i-1][j+1] == 0)
        finish = solve(i-1, j+1);
    if (!finish && maze[i+1][j+1] == 0)
        finish = solve(i+1, j+1);
    if (!finish && maze[i+1][j-1] == 0)
        finish = solve(i+1, j-1);
    if (!finish) //无法走通，那么修改原来设置的X符号，但是不设置为0，因为这个点现在已经走过
        maze[i][j] = 'Y';
    return finish;
}

main.cpp

#include<iostream>
#include"maze.h"
using namespace std;
int main()
    {
    int i=0,j=0;
    Maze a;                //生成一个迷宫
    cout<<"非递归算法"<<endl;
    for(i=0;i<12;i++)        //显示一个迷宫
    {
        for(j=0;j<12;j++)
        {
            cout<<a.getmaze(i,j)<<"  ";
        }
            cout<<endl;
    }
    

    //非递归
    bool b;                //用于判断迷宫是否可以走通
    b=a.path();
    cout<<"----------------------------------------------------------------"<<endl;
    if(b==false)
        cout<<"不能走出迷宫"<<endl;
    else
    {
     cout<<"走出迷宫的路线为："<<endl;
        cout<<"----------------------------------------------------------------"<<endl;
    for(i=0;i<12;i++)        //显示走出迷宫的路径
    {
        for(j=0;j<12;j++)
        {
            if(a.getmaze(i,j)==0||a.getmaze(i,j)==1)
            cout<<a.getmaze(i,j)<<"  ";
            else if(a.getmaze(i,j)=='Y')
                cout<<'0'<<"  ";
            else
                cout<<(char)a.getmaze(i,j)<<"  ";
        }
            cout<<endl;
    }
    }
    
    //显示走出迷宫的路径
    for(i=0;i<12;i++)        
    {
        for(j=0;j<12;j++)
        {
            if((char)a.getmaze(i,j)=='x')
            {
                
                cout<<"x="<<i<<"y="<<j<<"  ";
            }
        }
        cout<<endl;
    }



    //递归
    bool c;
    c=a.solve(1,1);
    cout<<c<<endl;
    if(c==false)
    {
        cout<<"不能走出迷宫！"<<endl;
    }
    else
    {
        for(i=0;i<12;i++)        
        {
            for(j=0;j<12;j++)
            {
                if(a.getmaze(i,j)==0||a.getmaze(i,j)==1)
            cout<<a.getmaze(i,j)<<"  ";
            else if(a.getmaze(i,j)=='Y')
                cout<<'0'<<"  ";
            else
                cout<<(char)a.getmaze(i,j)<<"  ";
            }
            cout<<endl;
        }
    }


    for(i=0;i<12;i++)        
    {
        for(j=0;j<12;j++)
        {
            if((char)a.getmaze(i,j)=='X')
            {
                
                cout<<"x="<<i<<"y="<<j<<"  ";
            }
        }
        cout<<endl;
    }
    return 0;
}

一直都不怎么注意做笔记，弄得现在感觉好多东西就算做过了一会就忘了。