c語言迷宮圖片,c語言 迷宮

本文目錄一覽：

• 1、C語言用圖的廣度優先遍歷做漫步迷宮問題
• 2、C語言 老鼠走迷宮
• 3、如何用C語言編寫一個迷宮程序？
• 4、C語言迷宮找出路問題。幫畫個流程圖。比如下圖
• 5、用C語言編寫一個迷宮程序，知道出處也行 ~~！

C語言用圖的廣度優先遍歷做漫步迷宮問題

這是我們老師給我們上數據結構課的課件

#include “stdio.h”

typedef int datatype; /*假定線性表元素的類型為整型*/

#define maxsize 1024 /*假定線性表的最大長度為1024*/

# define n 100 /* 圖的頂點最大個數 */

typedef char VEXTYPE; /* 頂點的數據類型 */

typedef float ADJTYPE; /* 權值類型 */

typedef struct

{ VEXTYPE vexs[n] ; /* 頂點信息數組 */

ADJTYPE arcs[n][n] ; /* 邊權數組 */

int num ; /* 頂點的實際個數 */

}GRAPH;

/***********************1。置空圖**********************/

void GraphInit(GRAPH *L)

{

L-num=0;

}

/***********************2。求結點數**********************/

int GraphVexs(GRAPH *L)

{

return(L-num);

}

/***********************3。創建圖**********************/

void GraphCreate(GRAPH *L)

{

int i,j;

GraphInit(L);

printf(“請輸入頂點數目：”);

scanf(“%d”,L-num);

printf(“請輸入各頂點的信息(單個符號）：”);

for(i=0;iL-num;i++)

{

fflush(stdin);

scanf(“%c”,L-vexs[i]);

}

printf(“請輸入邊權矩陣的信息：”);

for(i=0;iL-num;i++)

{

for(j=0;jL-num;j++)

{

scanf(“%f”,L-arcs[i][j]);

}

}

printf(“圖已經創建完畢！”);

}

/***********************4。圖的輸出**********************/

void GraphOut(GRAPH L)

{

int i,j;

printf(“\n圖的頂點數目為：%d”,L.num);

printf(“\n圖的各頂點的信息為：\n”);

for(i=0;iL.num;i++)

printf(“%c “,L.vexs[i]);

printf(“\n圖的邊權矩陣的信息為：\n”);

for(i=0;iL.num;i++)

{

for(j=0;jL.num;j++)

{

printf(“%6.2f “,L.arcs[i][j]);

}

printf(“\n”);

}

printf(“圖已經輸出完畢！”);

}

/***********************5。圖的深度周遊**********************/

void DFS(GRAPH g,int qidian,int mark[])

//從第qidian個點出發深度優先周遊圖g中能訪問的各個頂點

{

int v1;

mark[qidian]=1;

printf(“%c “,g.vexs[qidian]);

for(v1=0;v1g.num;v1++)

{

if(g.arcs[qidian][v1]!=0mark[v1]==0)

DFS(g,v1,mark);

}

}

/***********************6。圖的深度周遊**********************/

void GraphDFS(GRAPH g)

//深度優先周遊圖g中能訪問的各個頂點

{

int qidian,v,v1,mark[maxsize];

printf(“\n深度周遊：”);

printf(“\n請輸入起點的下標：”);

scanf(“%d”,qidian);

for(v=0;vg.num;v++)

{

mark[v]=0;

}

for(v=qidian;vg.num+qidian;v++)

{

//printf(“v=%d “,v);

v1=v%g.num;

if(mark[v1]==0)

DFS(g,v1,mark);

}

}

typedef int DATATYPE; //隊列元素的數據類型

typedef struct

{

DATATYPE data[maxsize]; //隊中元素

int front,rear; //隊頭元素下標、隊尾元素後面位置的下標

} SEQQUEUE;

/*****************************************************************************/

void QueueInit(SEQQUEUE *sq)

//將順序循環隊列sq置空（初始化）

{

sq-front=0;

sq-rear=0;

}

/*****************************************************************************/

int QueueIsEmpty(SEQQUEUE sq)

//如果順序循環隊列sq為空，成功返回1，否則返回0

{

if (sq.rear==sq.front)

return(1);

else

return(0);

}

/*****************************************************************************/

int QueueFront(SEQQUEUE sq,DATATYPE *e)

//將順序循環隊列sq的隊頭元素保存到e所指地址，成功返回1，失敗返回0

{

if (QueueIsEmpty(sq))

else

}

/*****************************************************************************/

int QueueIn (SEQQUEUE *sq,DATATYPE x)

//將元素x入隊列sq的隊尾，成功返回1，失敗返回0

{

if (sq-front==(sq-rear+1)%maxsize)

{

printf(“queue is full!\n”);

return 0;

}

else

{

sq-data[sq-rear]=x;

sq-rear=(sq-rear+1)%maxsize;

return(1);

}

}

/*****************************************************************************/

int QueueOut(SEQQUEUE *sq)

//將隊列sq隊首元素出隊列，成功返回1,失敗返回0

{

if (QueueIsEmpty(*sq))

{

printf(“queue is empty!\n”);

return 0;

}

else

{

sq-front=(sq-front+1)%maxsize;

return 1;

}

}

/***********************7。圖的廣度周遊**********************/

void BFS(GRAPH g,int v,int mark[])

//從v出發廣度優先周遊圖g中能訪問的各個頂點

{

int v1,v2;

SEQQUEUE q;

QueueInit(q);

QueueIn(q,v);

mark[v]=1;

printf(“%c “,g.vexs[v]);

while(QueueIsEmpty(q)==0)

{

QueueFront(q,v1);

QueueOut(q);

for(v2=0;v2g.num;v2++)

{

if(g.arcs[v1][v2]!=0mark[v2]==0)

{

QueueIn(q,v2);

mark[v2]=1;

printf(“%c “,g.vexs[v2]);

}

}

}

}

/***********************8。圖的廣度周遊**********************/

void GraphBFS(GRAPH g)

//深度優先周遊圖g中能訪問的各個頂點

{

int qidian,v,v1,mark[maxsize];

printf(“\n廣度周遊：”);

printf(“\n請輸入起點的下標：”);

scanf(“%d”,qidian);

for(v=0;vg.num;v++)

{

mark[v]=0;

}

for(v=qidian;vg.num+qidian;v++)

{

v1=v%g.num;

if(mark[v1]==0)

BFS(g,v1,mark);

}

}

/***********************主函數**********************/

void main()

{

GRAPH tu;

GraphCreate(tu);

GraphOut(tu);

GraphDFS(tu);

GraphBFS(tu);

}

C語言 老鼠走迷宮

可以給你點提示：迷宮 可用個二維數組表示。求解方法是：從入口出發，順某個方向走，若能過去，繼續；否則，沿着原路返回，換方向繼續走，直到所有可能的通路都被找到為止。為保證在任何位置上都能沿原路退回，需要一個先進後出的棧結構保存從入口到當前位置的路徑。這裡，給個算法的思想，不實現圖形界面了。假設迷宮數據存放在一txt中：

迷宮數據

8 8 //迷宮的大小，行數與列數

1 1 8 8 //1 1 表入口位置 8 8 表出口位置

0 0 1 0 0 0 1 0 //以下表迷宮，1表示牆、0表示通路，為避免走的過程中越界，最好在四周加上以堵牆。

0 0 1 0 0 0 1 0

0 0 0 0 1 1 0 0

0 1 1 1 0 0 0 0

0 0 0 1 0 0 0 0

0 1 0 0 0 1 0 0

0 1 1 1 0 1 1 0

1 1 0 0 0 0 0 0

#include stdio.h

#include stdlib.h

#define MAXSIZE 50

#define ERROR -1

#define OK 0

#define FALSE 0

#define TRUE 1

typedef enum{RIGHT,DOWN,LEFT,UP} Direction;

typedef enum{YES,NO} MarkTag;

typedef struct position{ //迷宮中位置的坐標

int x;

int y;

}Position;

typedef struct{ //當前位置在路徑中的序號

int order; //當前位置在迷宮中的坐標

Position seat; //從當前位置走到下一位置的方向

Direction di; //棧元素的類型

}SElemType;

typedef struct{

SElemType *elem;

int top;

}Stack;

char maze[MAXSIZE+2][MAXSIZE+2]; //用二維數組表示迷宮

int InitStack(Stack *S){ //創建一個空棧

S-elem=(SElemType *)malloc(MAXSIZE*MAXSIZE*sizeof(SElemType));

if(!S-elem)

return ERROR;

S-top=0;

return OK;

}

int Push(Stack *S,SElemType e){ //元素e入棧

if(S-top=MAXSIZE*MAXSIZE)

return ERROR;

S-elem[S-top++]=e;

return OK;

}

int Pop(Stack *S,SElemType e){ //棧頂元素出棧，由e帶回棧頂元素

if(S-top=0)

return ERROR;

*e=S-elem[–S-top];

return OK;

}

int Empty(Stack S){ //若棧為空，返回TRUE,否則返回FALSE

if(S.top==0)

return TRUE;

return FALSE;

}

int createMaze(char *filename,Position *startpos,Position *endpos){ //從文件filename讀入數據創建迷宮，由參數帶回入口位置和出口位置

FILE *fp;

int i,j,rows,cols,temp;

Position start,end;

fp=fopen(filename,”r”);

if(!fp){

printf(“open file %s error!\n”,filename);

return ERROR;

}

if(!feof(fp)){

fscanf(fp,”%d %d”,rows,cols); //讀入迷宮的行數和列數

fscanf(fp,”%d %d”,start.x,start.y); //讀入迷宮的入口位置

fscanf(fp,”%d %d”,end.x,end.y); //讀入迷宮的出口位置

}

for(i=1;i=rows;i++) //讀入迷宮數據

for(j=1;j=cols;j++){

fscanf(fp,”%d”,temp);

maze[i][j]=48+temp;

}

fclose(fp);

//在迷宮四周加牆

for(i=0,j=0;i=rows+1;i++) maze[i][j]=’1′;

for(i=0,j=cols+1;i=rows+1;i++) maze[i][j]=’1′;

for(i=0,j=0;j=cols+1;j++) maze[i][j]=’1′;

for(i=rows+1,j=0;j=cols+1;j++) maze[i][j]=’1′;

*startpos=start;

*endpos=end;

return OK;

}

int canPass(Position curpos){

if(maze[curpos.x][curpos.y]==’0′)

return TRUE;

return FALSE;

}

void markPos(Position curpos,MarkTag tag){ //為已走過的位置標記

switch(tag){

case YES: maze[curpos.x][curpos.y]=’.’; break; //路徑標記

case NO: maze[curpos.x][curpos.y]=’#’; break; //死胡同標記

}

}

Position nextPos(Position curpos,Direction dir){ //根據當前的位置坐標和下一步要探索的方向dir求下一步要走的位置坐標

Position nextpos;

switch(dir){

case RIGHT: nextpos.x=curpos.x; nextpos.y=curpos.y+1; break;

case DOWN: nextpos.x=curpos.x+1; nextpos.y=curpos.y; break;

case LEFT: nextpos.x=curpos.x; nextpos.y=curpos.y-1; break;

case UP: nextpos.x=curpos.x-1; nextpos.y=curpos.y; break;

}

return nextpos;

}

Direction nextDir(Direction dir){

switch(dir){ //按照RIGHT DOWN LEFT UP的次序進行路徑探索

case RIGHT: return DOWN;

case DOWN: return LEFT;

case LEFT: return UP;

}

}

/*若迷宮中存在從入口start到出口end的通道，則求得一條存放在棧S中，並返回TRUE，若不存在則返回FALSE*/

int Solve(Stack *S,Position start,Position end){

Position curpos;

SElemType e;

int curstep=1;

if(InitStack(S)==ERROR)

return FALSE;

curpos=start;

do{

if(canPass(curpos)){ //當前位置可以通過

markPos(curpos,YES); //留下足跡

e.order=curstep;

e.seat=curpos;

e.di=RIGHT;

Push(S,e);

if(curpos.x==end.x curpos.y=end.y)

return TRUE; //找到從入口到出口的通道

curpos=nextPos(curpos,RIGHT);

curstep++;

}

else{

if(!Empty(*S)){ //當前位置不能通過

if(Pos(S,e)==ERROR)

return FALSE;

while(e.di==UP !Empty(*S)){ //4個方向都找不到通路，則回溯

curpos=e.seat;

markPos(curpos,NO);

if(Pop(S,e)==ERROR)

return FALSE;

}

if(e.di!=UP){ //4個方向還沒有探索完

e.di=nextDir(e.di);

Push(S,e); //換下一個方向探索

curpos=nextPos(e.seat,e.di);

}

}

}while(!Empty(*S));

return FALSE;

}

void main(void){

Position startPos,endPos;

Stack path;

SElemType e;

char *fname=”in.txt”;

if(createMaze(fname,startPos,endPos)==ERROR) return;

Solve(path,startPos,endPos);

while(!Empty(path)){ //輸出出口到入口的路徑

Pop(path,e);

printf(“(%d,%d)\n”,e.seat.x,e.seat.y);

}

}

如何用C語言編寫一個迷宮程序？

#include graphics.h

#include stdlib.h

#include stdio.h

#include conio.h

#include dos.h

#define N 20/*

迷宮的大小，可改變

*/

int oldmap[N][N];/*

遞歸用的數組

,

用全局變量節約時間

*/

int yes=0;/*yes

是判斷是否找到路的標誌

,1

找到，

沒找到

*/

int way[100][2],wayn=0;/*way

數組是顯示路線用的

,wayn

是統計走了幾個格

子

*/

void Init(void);/*

圖形初始化

*/

void Close(void);/*

圖形關閉

*/

void DrawPeople(int *x,int *y,int n);/*

畫人工探索物圖

*/

void PeopleFind(int (*x)[N]);/*

人工探索

*/

void

WayCopy(int

(*x)[N],int

(*y)[N]);/*

為了

8

個方向的遞歸，把舊迷宮圖

拷貝給新數組

*/

int FindWay(int (*x)[N],int i,int j);/*

自動探索函數

*/

void MapRand(int (*x)[N]);/*

隨機生成迷宮函數

*/

void PrMap(int (*x)[N]);/*

輸出迷宮圖函數

*/

void Result(void);/*

輸出結果處理

*/

void Find(void);/*

成功處理

*/

void NotFind(void);/*

失敗處理

*/

void main(void)/*

主函數

*/

{

int map[N][N]; /*

迷宮數組

*/

char ch;

clrscr();

printf(“\n Please select hand(1) else auto\n”);/*

選擇探索方式

*/

scanf(“%c”,ch);

Init(); /*

初始化

*/

MapRand(map);/*

生成迷宮

*/

PrMap(map);/*

顯示迷宮圖

*/

if(ch==’1′)

PeopleFind(map);/*

人工探索

*/

else

FindWay(map,1,1);/*

系統自動從下標

1,1

的地方開始探索

*/

Result();/*

輸出結果

*/

Close();

}

void Init(void)/*

圖形初始化

*/

{

int gd=DETECT,gm;

initgraph(gd,gm,”c:\\tc”); }

void DrawPeople(int *x,int *y,int n)/*畫人工控制圖*/ {/*如果將以下兩句注釋掉，則顯示人工走過的路徑，*/

setfillstyle(SOLID_FILL,WHITE); /*設置白色實體填充樣式*/ bar(100+(*y)*15-6,50+(*x)*15-6,100+(*y)*15+6,50+(*x)*15+6); /*恢復原通路*/

switch(n)/*判斷x,y的變化，8個方向的變化*/ {

case 1: (*x)–;break; /*上*/

case 2: (*x)–;(*y)++;break /*右上*/ case 3: (*y)++;break; /*右*/

case 4: (*x)++;(*y)++;break; /*右下*/ case 5: (*x)++;break; /*下*/

case 6: (*x)++;(*y)–;break; /*左下*/ case 7: (*y)–;break; /*左*/

case 8: (*x)–;(*y)–;break; /*左上*/ }

setfillstyle(SOLID_FILL,RED);/*新位置顯示探索物*/

bar(100+(*y)*15-6,50+(*x)*15-6,100+(*y)*15+6,50+(*x)*15+6); }

void PeopleFind(int (*map)[N])/*人工手動查找*/ {

int x,y;

char c=0;/*接收按鍵的變量*/ x=y=1;/*人工查找的初始位置*/ setcolor(11);

line(500,200,550,200); outtextxy(570,197,”d”); line(500,200,450,200); outtextxy(430,197,”a”); line(500,200,500,150); outtextxy(497,130,”w”); line(500,200,500,250); outtextxy(497,270,”x”); line(500,200,450,150); outtextxy(445,130,”q”); line(500,200,550,150); outtextxy(550,130,”e”); line(500,200,450,250); outtextxy(445,270,”z”); line(500,200,550,250);

outtextxy(550,270,”c”);/*以上是畫8個方向的控制介紹*/

setcolor(YELLOW);

outtextxy(420,290,”Press ‘Enter’ to end”);/*壓回車鍵結束*/ setfillstyle(SOLID_FILL,RED);

bar(100+y*15-6,50+x*15-6,100+y*15+6,50+x*15+6);/*入口位置顯示*/ while(c!=13)/*如果按下的不是回車鍵*/ {

c=getch();/*接收字符後開始各個方向的探索*/ if(c==’w’map[x-1][y]!=1) DrawPeople(x,y,1);/*上*/ else if(c==’e’map[x-1][y+1]!=1) DrawPeople(x,y,2);/*右上*/ else if(c==’d’map[x][y+1]!=1) DrawPeople(x,y,3);/*右*/ else if(c==’c’map[x+1][y+1]!=1) DrawPeople(x,y,4);/*右下*/ else if(c==’x’map[x+1][y]!=1) DrawPeople(x,y,5);/*下*/ else if(c==’z’map[x+1][y-1]!=1) DrawPeople(x,y,6); /*左下*/ else if(c==’a’map[x][y-1]!=1) DrawPeople(x,y,7); /*左*/ else if(c==’q’map[x-1][y-1]!=1) DrawPeople(x,y,8); /*左上*/ }

setfillstyle(SOLID_FILL,WHITE); /*消去紅色探索物，恢復原迷宮圖*/ bar(100+y*15-6,50+x*15-6,100+y*15+6,50+x*15+6); if(x==N-2y==N-2)/*人工控制找成功的話*/ yes=1; /*如果成功標誌為1*/ }

void WayCopy(int (*oldmap)[N],int (*map)[N])/*拷貝迷宮數組 */ {

int i,j;

for(i=0;iN;i++) for(j=0;jN;j++) oldmap[i][j]=map[i][j]; }

int FindWay(int (*map)[N],int i,int j)/*遞歸找路*/ {

if(i==N-2j==N-2)/*走到出口*/ {

yes=1;/*標誌為1,表示成功*/ return; }

map[i][j]=1;/*走過的地方變為1*/ WayCopy(oldmap,map); /*拷貝迷宮圖*/

if(oldmap[i+1][j+1]==0!yes)/*判斷右下方是否可走*/ {

FindWay(oldmap,i+1,j+1); if(yes)/*如果到達出口了，再把值賦給顯示路線的way數組,也正是這個原因,所以具體路線是從最後開始保存*/ { way[wayn][0]=i; way[wayn++][1]=j; return; } }

WayCopy(oldmap,map);

if(oldmap[i+1][j]==0!yes)/*判斷下方是否可以走,如果標誌yes已經是1也不用找下去了*/ {

FindWay(oldmap,i+1,j); if(yes) { way[wayn][0]=i; way[wayn++][1]=j; return; } }

WayCopy(oldmap,map);

if(oldmap[i][j+1]==0!yes)/*判斷右方是否可以走*/ {

FindWay(oldmap,i,j+1); if(yes) { way[wayn][0]=i; way[wayn++][1]=j; return; } }

WayCopy(oldmap,map);

if(oldmap[i-1][j]==0!yes)/*判斷上方是否可以走*/ {

FindWay(oldmap,i-1,j); if(yes) { way[wayn][0]=i; way[wayn++][1]=j; return; } }

WayCopy(oldmap,map);

if(oldmap[i-1][j+1]==0!yes)/*判斷右上方是否可以走*/ {

FindWay(oldmap,i-1,j+1); if(yes) { way[wayn][0]=i; way[wayn++][1]=j; return; } }

WayCopy(oldmap,map);

if(oldmap[i+1][j-1]==0!yes)/*判斷左下方是否可以走*/ {

FindWay(oldmap,i+1,j-1); if(yes) { way[wayn][0]=i; way[wayn++][1]=j; return; } }

WayCopy(oldmap,map);

if(oldmap[i][j-1]==0!yes)/*判斷左方是否可以走*/ {

FindWay(oldmap,i,j-1); if(yes) { way[wayn][0]=i; way[wayn++][1]=j; return; } }

WayCopy(oldmap,map);

if(oldmap[i-1][j-1]==0!yes)/*判斷左上方是否可以走*/ {

FindWay(oldmap,i-1,j-1); if(yes) { way[wayn][0]=i; way[wayn++][1]=j; return; } }

return; }

void MapRand(int (*map)[N])/*開始的隨機迷宮圖*/ {

int i,j;

cleardevice();/*清屏*/

randomize(); /*隨機數發生器*/ for(i=0;iN;i++) {

for(j=0;jN;j++) { if(i==0||i==N-1||j==0||j==N-1)/*最外面一圈為牆壁*/ map[i][j]=1; else if(i==1j==1||i==N-2j==N-2)/*出發點與終點表示為可走的*/ map[i][j]=0; else map[i][j]=random(2);/*其它的隨機生成0或1*/ } } }

void PrMap(int (*map)[N])/*輸出迷宮圖*/ {

int i,j;

for(i=0;iN;i++) for(j=0;jN;j++) if(map[i][j]==0) { setfillstyle(SOLID_FILL,WHITE);/*白色為可走的路*/ bar(100+j*15-6,50+i*15-6,100+j*15+6,50+i*15+6); } else { setfillstyle(SOLID_FILL,BLUE);/*藍色為牆壁*/ bar(100+j*15-6,50+i*15-6,100+j*15+6,50+i*15+6);

} }

void Find(void)/*找到通路*/ {

int i;

setfillstyle(SOLID_FILL,RED);/*紅色輸出走的具體路線*/ wayn–;

for(i=wayn;i=0;i–) {

bar(100+way[i][1]*15-6,50+way[i][0]*15-6,100+ way[i][1]*15+6,50+way[i][0]*15+6); sleep(1);/*控制顯示時間*/ }

bar(100+(N-2)*15-6,50+(N-2)*15-6,100+ (N-2)*15+6,50+(N-2)*15+6); /*在目標點標紅色*/ setcolor(GREEN);

settextstyle(0,0,2);/*設置字體大小*/ outtextxy(130,400,”Find a way!”); }

void NotFind(void)/*沒找到通路*/ {

setcolor(GREEN);

settextstyle(0,0,2);/*設置字體大小*/ outtextxy(130,400,”Not find a way!”); }

void Result(void)/*結果處理*/ {

if(yes)/*如果找到*/ Find();

else/*沒找到路*/ NotFind(); getch(); }

void Close(void)/*圖形關閉*/ {

closegraph(); }

C語言迷宮找出路問題。幫畫個流程圖。比如下圖

/*

算法

*/

#includestdio.h

#includemalloc.h

#includestdlib.h

#define M 4    //行數

#define N 4     //列數

#define MaxSize    100     //棧最多元素個數

int mg[M+2][N+2]={      //一個迷宮，其四周要加上均為1的外框，1為牆

 {1,1,1,1,1,1},

 {1,0,0,0,1,1},

 {1,1,1,0,1,1},

 {1,0,1,0,1,1},

 {1,1,0,0,0,1},

 {1,1,1,1,1,1}

};

struct migong{

 int i;      //路徑橫坐標

 int j;      //路徑縱坐標

 int di;     //方向

}Stack[MaxSize];      //定義棧

int top=-1;     //棧頂指針

void mgpath(){      //路徑為:(1,1)-(M,N)從起點1,1走到出口m,n

 int i,j,di,find,k;

 top++;

 Stack[top].i=1;

 Stack[top].j=1;

 Stack[top].di=-1;

 mg[1][1]=-1;        //初始結點進棧

 while(top-1){      //棧不空時循環

  i=Stack[top].i;

  j=Stack[top].j;

  di=Stack[top].di;

  if(i==M  j==N){       //找到了出口，輸出路徑

   printf(“迷宮出口路徑如下:\n”);

   for(k=0;k=top;k++){

    printf(“(%d,%d,%d)  “,Stack[k].i,Stack[k].j,Stack[k].di);

    if((k+1)%5==0)      //輸出時每5個結點換一行

     printf(“\n”);

   }

   printf(“\n”);

   break;

  }

  find=0;     

  while(di4  find==0){     //找下一個可走結點

   di++;

   switch(di){

   case 0:i=Stack[top].i-1;j=Stack[top].j;break;   //上面

   case 1:i=Stack[top].i;j=Stack[top].j+1;break;   //右邊

   case 2:i=Stack[top].i+1;j=Stack[top].j;break;   //下面

   case 3:i=Stack[top].i;j=Stack[top].j-1;break;   //左邊

   }

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

    find=1;//找到通路

  }

  if(find == 1){      //找到了下一個可走結點

   Stack[top].di=di;   //修改原棧頂元素的di值

   top++;      //下一個可走結點進棧

   Stack[top].i=i;

   Stack[top].j=j;

   Stack[top].di=-1;

   mg[i][j]=-1;        //避免重複走到該結點

  }

  else{

   mg[Stack[top].i][Stack[top].j]=0;   //讓該位置變為其他路徑的可走結點

   if(Stack[top].i==1  Stack[top].j==1)

   {

    printf(“該迷宮問題沒有解!\n”);

    break;

   }

   top–;

  }

 }

}

int main(){

 printf(“\n”);

 printf(”                        迷宮解題問題中心歡迎您                 \n”);

 printf(“\n”);

 printf(”                                          設計者：么么噠\n”);

 printf(“\n”);

 printf(” ****************************************************************************** \n”);

 printf(“\n”); 

 mgpath();

 return 0;

}

用C語言編寫一個迷宮程序，知道出處也行 ~~！

#includestdio.h

#includestdlib.h

#define M 15

#define N 15

struct mark //定義迷宮內點的坐標類型

{

int x;

int y;

};

struct Element //”戀”棧元素，嘿嘿。。

{

int x,y; //x行,y列

int d; //d下一步的方向

};

typedef struct LStack //鏈棧

{

Element elem;

struct LStack *next;

}*PLStack;

/*************棧函數****************/

int InitStack(PLStack S)//構造空棧

{

S=NULL;

return 1;

}

int StackEmpty(PLStack S)//判斷棧是否為空

{

if(S==NULL)

return 1;

else

return 0;

}

int Push(PLStack S, Element e)//壓入新數據元素

{

PLStack p;

p=(PLStack)malloc(sizeof(LStack));

p-elem=e;

p-next=S;

S=p;

return 1;

}

int Pop(PLStack S,Element e) //棧頂元素出棧

{

PLStack p;

if(!StackEmpty(S))

{

e=S-elem;

p=S;

S=S-next;

free(p);

return 1;

}

else

return 0;

}

/***************求迷宮路徑函數***********************/

void MazePath(struct mark start,struct mark end,int maze[M][N],int diradd[4][2])

{

int i,j,d;int a,b;

Element elem,e;

PLStack S1, S2;

InitStack(S1);

InitStack(S2);

maze[start.x][start.y]=2; //入口點作上標記

elem.x=start.x;

elem.y=start.y;

elem.d=-1; //開始為-1

Push(S1,elem);

while(!StackEmpty(S1)) //棧不為空 有路徑可走

{

Pop(S1,elem);

i=elem.x;

j=elem.y;

d=elem.d+1; //下一個方向

while(d4) //試探東南西北各個方向

{

a=i+diradd[d][0];

b=j+diradd[d][1];

if(a==end.x b==end.y maze[a][b]==0) //如果到了出口

{

elem.x=i;

elem.y=j;

elem.d=d;

Push(S1,elem);

elem.x=a;

elem.y=b;

elem.d=886; //方向輸出為-1 判斷是否到了出口

Push(S1,elem);

printf(“\n0=東 1=南 2=西 3=北 886為則走出迷宮\n\n通路為:(行坐標,列坐標,方向)\n”);

while(S1) //逆置序列 並輸出迷宮路徑序列

{

Pop(S1,e);

Push(S2,e);

}

while(S2)

{

Pop(S2,e);

printf(“–(%d,%d,%d)”,e.x,e.y,e.d);

}

return; //跳出兩層循環，本來用break,但發現出錯，exit又會結束程序，選用return還是不錯滴

}

if(maze[a][b]==0) //找到可以前進的非出口的點

{

maze[a][b]=2; //標記走過此點

elem.x=i;

elem.y=j;

elem.d=d;

Push(S1,elem); //當前位置入棧

i=a; //下一點轉化為當前點

j=b;

d=-1;

}

d++;

}

}

printf(“沒有找到可以走出此迷宮的路徑\n”);

}

/*************建立迷宮*******************/

void initmaze(int maze[M][N])

{

int i,j;

int m,n; //迷宮行,列 [/M]

printf(“請輸入迷宮的行數 m=”);

scanf(“%d”,m);

printf(“請輸入迷宮的列數 n=”);

scanf(“%d”,n);

printf(“\n請輸入迷宮的各行各列:\n用空格隔開,0代表路,1代表牆\n”,m,n);

for(i=1;i=m;i++)

for(j=1;j=n;j++)

scanf(“%d”,maze[i][j]);

printf(“你建立的迷宮為(最外圈為強)…\n”);

for(i=0;i=m+1;i++) //加一圈圍牆

{

maze[i][0]=1;

maze[i][n+1]=1;

}

for(j=0;j=n+1;j++)

{

maze[0][j]=1;

maze[m+1][j]=1;

}

for(i=0;i=m+1;i++) //輸出迷宮

{

for(j=0;j=n+1;j++)

printf(“%d “,maze[i][j]);

printf(“\n”);

}

}

void main()

{

int sto[M][N];

struct mark start,end; //start,end入口和出口的坐標

int add[4][2]={{0,1},{1,0},{0,-1},{-1,0}};//行增量和列增量 方向依次為東西南北 [/M]

initmaze(sto);//建立迷宮

printf(“輸入入口的橫坐標,縱坐標[逗號隔開]\n”);

scanf(“%d,%d”,start.x,start.y);

printf(“輸入出口的橫坐標,縱坐標[逗號隔開]\n”);

scanf(“%d,%d”,end.x,end.y);

MazePath(start,end,sto,add); //find path

system(“PAUSE”);

}