迷宫算法（DFS），用链栈实现，迷宫的路径是倒着打印的（一个bug找了半天，细节真的太重要了）

#include<iostream>
using namespace std;
   typedef  class maps
        {
            public :
                int x;
                int y;
                int d;
                maps *next;
        }*LinkStack,Link;

        const int M=10,N=10;
        int cx=8,cy=8;//定义出口变量
        void push(LinkStack &L,int i,int j,int di);
        void pop(LinkStack &L);
        void init_LinkStack(LinkStack &L);
        int main()

            {
                int a[M][N]={
                    {1,1,1,1,1,1,1,1,1,1},
                    {1,0,0,1,0,0,0,1,0,1},
                    {1,0,0,1,0,0,0,1,0,1},
                    {1,0,0,0,0,1,1,0,0,1},
                    {1,0,1,1,1,0,0,0,0,1},
                    {1,0,0,0,1,0,0,0,0,1},
                    {1,0,1,0,0,0,1,0,0,1},
                    {1,0,1,1,1,0,1,1,0,1},
                    {1,1,0,0,0,0,0,0,0,1},
                    {1,1,1,1,1,1,1,1,1,1}
                    };
                LinkStack L;
                init_LinkStack(L);
                LinkStack p=L->next;
                LinkStack s;
                int counts=0,di,founds=0;
                int ix=1,jy=1;
                int i,j;
                while(p!=NULL)
                {
                    if(p->x==8&&p->y==8)
                    {
                        while(p!=NULL)
                        {
                            cout<<"("<<p->x<<","<<p->y<<")"<<" ";
                            counts++;
                            if(counts%5==0)
                            {
                                cout<<endl;
                            }
                            p=p->next;
                        }
                    }

                    else
                    {
                        di=0;
                        while(di<4)
                        {
                                switch(di)
                                {

                                case 0:
                                    i=ix-1;
                                    j=jy;
                                    break;

                                case 1:
                                    i=ix;
                                    j=jy+1;
                                    break;

                                case 2:
                                    i=ix+1;
                                    j=jy;
                                    break;

                                case 3:
                                    i=ix;
                                    j=jy-1;
                                    break;
                            }

                        if(a[i][j]==0)

                        {
                            ix=i;
                            jy=j;
                            push(L,ix,jy,di);
                            p=L->next;
                            a[ix][jy]=-1;
                            break;
                        }

                        else
                        {
                            di++;
                        }


                            if(di==4)
                                {
                                    cout<<p->x<<" "<<p->y<<endl;
                                    pop(L);
                                    p=L->next;
                                    ix=p->x;
                                    jy=p->y;

                                }

                    }


                        }
                    }
                    if(p==NULL)
                    {
                        cout<<"尽力了，迷宫的出口找不到qaq"<<endl;
                    }

                }


        void push(LinkStack &L,int i,int j,int di)
            {

                LinkStack s=new Link;
                LinkStack p=L->next;
                p->d=di;
                s->x=i;
                s->y=j;
                s->next=L->next;
                L->next=s;
            }

        void pop(LinkStack &L)
            {
                if(L->next==NULL)

                    {
                        return ;
                    }

                else
                    {
                        LinkStack p=L->next;
                        L->next=p->next;
                        delete(p);
                    }
            }

            void init_LinkStack(LinkStack &L)

                {
                    L=new Link;
                    L->next=NULL;
                    LinkStack s=new Link;
                    s->x=1;
                    s->y=1;
                    s->d=-1;
                    s->next=L->next;
                    L->next=s;
                }