数据结构之迷宫求解（dfs用栈实现）

给一个5*5的方格（可以更大，但是时间可能会慢），让你求从左上角到所给一点的任意一条路径并输出，如果无法到达，输出NO。

深度优先搜索（DFS） 深度优先搜索在搜索过程中访问某个顶点后，需要递归地访问此顶点的所有未访问过的相邻顶点。 初始条件下所有节点为白色，选择一个作为起始顶点，按照如下步骤遍历： a. 选择起始顶点涂成灰色，表示还未访问 b. 从该顶点的邻接顶点中选择一个，继续这个过程（即再寻找邻接结点的邻接结点），一直深入下去，直到一个顶点没有邻接结点了，涂黑它，表示访问过了 c. 回溯到这个涂黑顶点的上一层顶点，再找这个上一层顶点的其余邻接结点，继续如上操作，如果所有邻接结点往下都访问过了，就把自己涂黑，再回溯到更上一层。 d. 上一层继续做如上操作，知道所有顶点都访问过。 -----先引用一下别人对深搜的解释：原文在这https://blog.csdn.net/wumingkeqi/article/details/70940978

code：

#include <cstdio>
#include <stdlib.h>
#include <iostream>
using namespace std;
typedef struct Node
{
    struct Node *next;
    int x,y,step,num;
}node;
char a[1000][1000];
int book[1000][1000];
int next[4][4]={{1,0},{-1,0},{0,1},{0,-1}};//标明前进的四个方向。
class mystack//手写一个栈类
{
public:
    mystack();//构造函数
    void push(int x,int y);
    void pop();
    int topx();
    int topy();
    bool empty();
    ~mystack();//析构函数
    node *s;
};
mystack::mystack()
{
    s=(node*)malloc(sizeof(node));
    s->next=NULL;
}
mystack::~mystack()
{
    node *t;
    if(s->next==NULL)
    {
        return;
    }
    s=s->next;
    while(s!=NULL)
    {
        t=s->next;
        free(s);
        s=t;
    }
}
int mystack::topx()
{
    return s->next->x;
}
int mystack::topy()
{
    return s->next->y;
}
void mystack::pop()
{
    node *ts=s->next;
    s->next=ts->next;
    free(ts);
}
void mystack::push(int x,int y)
{
    node *t;
    t=(node*)malloc(sizeof(node));
    t->x=x;
    t->y=y;
    t->next=s->next;
    s->next=t;
}
bool mystack::empty()
{
   if(s->next==NULL)
   {
       return true;
   }
   else
    return false;
}
int main()
{
    int i,x[100],y[100];
    for(i=0;i<5;i++)
    {
            scanf("%s",a[i]);
    }
    int endx,endy;
    scanf("%d%d",&endx,&endy);
    if(endx==1&&endy==1)
    {
            printf("(1,1)\n");
            return 0;
    }
    mystack q;
    q.push(0,0);
    book[0][0]=1;
    node *t=q.s->next;
    t->step=0;
    int flag=0;
    while(!q.empty())//搜索核心代码
    {
        for(i=(!flag?0:t->step);i<4;i++)
        {
                flag=0;
                int tx=q.topx()+next[i][0];
                int ty=q.topy()+next[i][1];
                if(tx<0||tx>=5||ty<0||ty>=5)
                    continue;
                if(a[tx][ty]=='.'&&!book[tx][ty])//如果当前这个点满足条件就把它压入栈内。
                {
                        q.push(tx,ty);
                        t=q.s->next;
                        if(tx==endx-1&&ty==endy-1)
                        {
                            int k=0;
                            while(!q.empty())
                            {
                                x[k]=q.topx();
                                y[k++]=q.topy();
                                q.pop();
                            }
                            for(int j=k-1;j>=0;j--)
                            {
                               printf("(%d,%d)\n",x[j]+1,y[j]+1);
                            }
                            printf("YES\n");
                            return 0;
                        }
                        book[tx][ty]=1;
                        t->step=i;
                        i=-1;
                }
            }
        q.pop();//说明当前节点已经是个死胡同了，出栈。
        t=q.s->next;
        flag=1;
    }
    printf("NO\n");
    return 0;
}