利用堆栈实现走迷宫算法

数据结构：堆栈

算法思想：堆栈弹栈，压栈，回溯法

//迷宫问题
#include<stdio.h>
#include<stdlib.h>
#define m 9
#define n 9 
#define MAXSIZE 100 
//迷宫问题

//定义移动位置 ,其中 
typedef struct{
    int x,y;
}item;
//定义一个数据类型为dataType，在栈里面存在此数据
//主要作为迷宫移动位置的临时存放点，其中x为当前位置的横坐标，y为当前位置的纵坐标
//d为 搜索的次数(方向) 
typedef struct{
    int x,y,d;
}dataType; 

//定义一个栈 
typedef struct{
    dataType data[MAXSIZE];
    int top; 
}list,*pList;


//创建栈

pList initList(){
    pList p;
    p = (pList)malloc(sizeof(list));
    if(p){
        p->top = -1;
    }
    
    return p; 
} 

//判断栈是否为空
int isEmpty(pList p){
    if(p->top==-1){
        return 1;//如果是空栈就返回1 
    }else{
        return 0;
    }
}

//压栈
int pushList(pList p,dataType data){
    if(p->top==MAXSIZE-1){//如果栈超出了大小，返回0 
        return 0;
    }
    p->top++;
    p->data[p->top] = data;//压栈操作
    return 1;//压栈成功，返回1 
}

//弹栈
int popList(pList p,dataType *data){
    if(isEmpty(p)){
        return 0;//如果是空栈，就不弹，直接返回0 
    }else{
        *data = p->data[p->top];
        p->top--;
        return 1;
    } 
}

//销毁栈
void destory(pList *p){
    if(*p){
        free(*p);
    }
    *p = NULL;
    return; 
} 
 
int mazePath(int maze[][n+2],item move[],int x0,int y0){//maze表示一个迷宫的数组，move表示当前探索，x0,y0表示初始位置
    pList p;//定义栈
    dataType temp;//定义临时位置 
    int x,y,d,i,j;//x，y用来存放临时位置的角标，d表示临时的探索次数，i,j所在位置的迷宫角标
    p = initList();//创建栈
    if(!p){//如果创建失败 
        printf("创建栈失败");
        return 0;  
    }
    
    //初始化走过的位置 
    temp.x = x0;
    temp.y = y0;
    temp.d = -1;
    
    //把迷宫入口压栈
    pushList(p,temp);
    
    //当栈里面不为空时 
    while(!isEmpty(p)){
        popList(p,&temp);//弹栈
        x = temp.x;
        y = temp.y;
        d = temp.d+1;//给d+1，让其进行第一次探索
        while(d<4){//四次探索 
            i = x+move[d].x;//原来的位置加上探索的位置
            j = y+move[d].y;
            
            //当某条路是通路的时候 
            if(maze[i][j]==0){//表示此路可走 
                //使用temp来保存路径 
                temp.x = x;
                temp.y = y;
                temp.d = d;
                //将路径压栈
                pushList(p,temp);
                //x、y来保存当前新的路径 
                x = i;
                y = j; 
                maze[x][y] = -1;//把走过的路径的值设为-1 
                
                if(x==m && y==n){//判断是否走到头，如果走到头 
                    while(!isEmpty(p)){//如果栈不为空 
                        popList(p,&temp);//弹栈
                        printf("(%d,%d,%d),<-",temp.x,temp.y,temp.d);//打印路径 
                    }
                    //程序结束，销毁栈
                    destory(&p);
                    return 1; 
                }else{//如果能走通，但是却没有走完迷宫，把d置为0 
                    d = 0;
                } 
            } else{//如果路不通，换个方向在进行探索 
                d++; 
            } 
        } 
         
    }
    //如果最后都没找到，说明迷宫没有通路
        destory(&p);
        return 0; 
     
} 

void main(){
    item move[4];//定义一个控制探索路径的移动数组
    //定义迷宫数组 
     int maze[11][11]={
                  {1,1,1,1,1,1,1,1,1,1,1},
                 {1,0,0,0,1,0,1,1,1,0,1},
                 {1,0,1,0,0,0,0,1,0,1,1},
                 {1,0,0,1,0,0,0,1,0,0,1},
                 {1,1,0,1,0,1,0,1,0,1,1},
                 {1,0,1,0,1,0,0,1,0,0,1},
                 {1,0,0,0,0,0,1,0,1,0,1},
                 {1,1,1,1,0,1,0,0,0,0,1},
                 {1,0,0,1,0,0,0,1,0,1,1},
                 {1,0,0,0,0,1,0,1,0,0,1},
                 {1,1,1,1,1,1,1,1,1,1,1}
                 };
    
    //定义第一次移动 ,方向为北 
    move[0].x = 0;
    move[0].y = 1;
    
    //定义第二次移动，方向为南 
    move[1].x = 0;
    move[1].y = -1;
    
    //规定第三次移动，方向为东 
    move[2].x = 1;
    move[2].y = 0;
    
    //规定第三次移动,方向为西 
    move[3].x = -1;
    move[3].y = 0; 
    
    mazePath(maze,move,1,1); 
}