利用堆棧實現走迷宮算法

數據結構：堆棧

算法思想：堆棧彈棧，壓棧，回溯法

 

 

//迷宮問題
#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); 
}