c語言迷宮求解
⑴ 如何用c語言實現求迷宮的最短路徑
#include<stdio.h>
#include<stdlib.h>
#define M 8
#define N 8
#define Max 100
int mg[M+2][N+2]= //定義迷宮，0表示能走的塊，1表示不能走，在外圍加上一圈不能走的塊
{
{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}
};
struct
{
int i,j; //塊的位置
int pre; //本路徑中上一塊在隊列中的下標
}Qu[Max];
int front=-1,rear=-1;
void print(int n);
int mgpath(int xi,int yi,int xe,int ye) //搜索演算法
{
int i,j,find=0,di;
rear++;
Qu[rear].i=xi;
Qu[rear].j=yi;
Qu[rear].pre=-1;
mg[1][1]=-1;
while(front<=rear&&!find)
{
front++;
i=Qu[front].i;
j=Qu[front].j;
if(i==xe&&j==ye)
{
find=1;
print(front);
return(1);
}
for(di=0;di<4;di++)
{
switch(di) //四個方向
{
case 0:i=Qu[front].i-1;j=Qu[front].j;break;
case 1:i=Qu[front].i;j=Qu[front].j+1;break;
case 2:i=Qu[front].i+1;j=Qu[front].j;break;
case 3:i=Qu[front].i;j=Qu[front].j-1;break;
}
if(mg[i][j]==0)
{
rear++;
Qu[rear].i=i;
Qu[rear].j=j;
Qu[rear].pre=front;
mg[i][j]=-1; //避免死循環
}
}
}
return 0;
}
void print(int n) //輸出 路徑演算法
{
int k=n,j,m=1;
printf("\n");
do //將輸出的路徑上的所有pre改為-1
{
j=k;
k=Qu[k].pre;
Qu[j].pre=-1;
}while(k!=0);
printf("迷宮最短路徑如下：\n");
k=0;
while(k<Max)
{
if(Qu[k].pre==-1)
{
printf("\t(%d,%d)",Qu[k].i,Qu[k].j);
if(m%5==0)
printf("\n");
m++;
}
k++;
}
printf("\n");
}
int main()
{
mgpath(1,1,M,N);
system("pause");
return 0;
}
⑵ 求解c語言一遞歸迷宮問題
給你給偽演算法：（設坐標為x,y,坐標向右和下延生。）
函數：
｛
判斷當前是不是（7,7)，如果是，表示走出迷宮。列印軌跡
1 嘗試往左先走一步（x-1，如果x小於0，或者對應位置標識為阻塞）
2 1如果成功，用本函數遞歸調用左走一步的坐標，並記下當前位置到軌跡列表。
3 嘗試往前先走一步（y+1，如果y小於0，或者對應位置標識為阻塞）
4 3如果成功，用本函數遞歸調用前走一步的坐標,並記下當前位置到軌跡列表。
5 嘗試往右先走一步（x+1，如果x小於0，或者對應位置標識為阻塞）
6 5如果成功，用本函數遞歸調用前走一步的坐標,並記下當前位置到軌跡列表。
如果是（0，0），表示沒有合適的路徑可走出迷宮。
如果不是（0，0），將軌跡列表最後一位彈出。
｝
⑶ c語言的迷宮問題
//尋路_帶權重_帶障礙_最短_文件地圖_不閃------wlfryq------//
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<windows.h>
typedefstruct
{
intx;
inty;
}_PT;
_PTpt;
introw=0,col=0;
//設置CMD窗口游標位置
voidsetxy(intx,inty)
{
COORDcoord={x,y};
SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE),coord);
}
//獲取當前CMD當前游標所在位置
voidgetxy()
{
HANDLEhConsole=GetStdHandle(STD_OUTPUT_HANDLE);
COORDcoordScreen={0,0};//游標位置
CONSOLE_SCREEN_BUFFER_INFOcsbi;
if(GetConsoleScreenBufferInfo(hConsole,&csbi))
{
pt.x=csbi.dwCursorPosition.X;
pt.y=csbi.dwCursorPosition.Y;
}
}
typedefstruct
{
intx;
inty;
inttype;
intv;
}PT;
PT**s=NULL,stack[50],start,end,c;
intpos=0;
voidprt()
{
inti,j;
system("cls");
for(i=0;i<row;i++)
{
for(j=0;j<col;j++)
{
if(s[i][j].type==1)
{
printf("■");
}
elseif(i==end.x&&j==end.y)
{
printf("★");
}
elseif(i==c.x&&j==c.y)
{
printf("◎");
}
else
{
printf("");
}
}
printf(" ");
}
Sleep(500);
}
voidstack_in(PTa)
{
stack[pos++]=a;
}
PTstack_out()
{
inti;
PTt;
t=stack[0];
for(i=0;i<pos-1;i++)
{
stack[i]=stack[i+1];
}
pos--;
returnt;
}
voidfun()
{
PTa;
intx,y,v;
while(1)
{
if(pos==0)
{
break;
}
a=stack_out();
x=a.x;
y=a.y;
if(x==start.x&&y==start.y)
{
break;
}
v=s[x][y].v;
if(x-1>=0&&s[x-1][y].type==0&&(s[x-1][y].v==-1||s[x-1][y].v>v+1))
{
s[x-1][y].v=v+1;
stack_in(s[x-1][y]);
}
if(x+1<=row-1&&s[x+1][y].type==0&&(s[x+1][y].v==-1||s[x-1][y].v>v+1))
{
s[x+1][y].v=v+1;
stack_in(s[x+1][y]);
}
if(y-1>=0&&s[x][y-1].type==0&&(s[x][y-1].v==-1||s[x-1][y].v>v+1))
{
s[x][y-1].v=v+1;
stack_in(s[x][y-1]);
}
if(y+1<=col-1&&s[x][y+1].type==0&&(s[x][y+1].v==-1||s[x-1][y].v>v+1))
{
s[x][y+1].v=v+1;
stack_in(s[x][y+1]);
}
}
}
voidgo(intx,inty)
{
printf(" 按任意鍵開始 ");
getchar();
intv;
while(1)
{
if(x==end.x&&y==end.y)
{
setxy(0,y+2);
printf("end....");
return;
}
v=s[x][y].v;
if(v==0)
{
return;
}
if(x-1>=0&&s[x-1][y].v==v-1)
{
c=s[x-1][y];
setxy(y*2,x);
x=x-1;
printf("");
setxy(y*2,x);
printf("◎");
Sleep(500);
continue;
}
elseif(x+1<=row-1&&s[x+1][y].v==v-1)
{
c=s[x+1][y];
setxy(y*2,x);
x++;
printf("");
setxy(y*2,x);
printf("◎");
Sleep(500);
continue;
}
elseif(y-1>=0&&s[x][y-1].v==v-1)
{
c=s[x][y-1];
setxy(y*2,x);
y--;
printf("");
setxy(y*2,x);
printf("◎");
Sleep(500);
continue;
}
elseif(y+1<=col-1&&s[x][y+1].v==v-1)
{
c=s[x][y+1];
setxy(y*2,x);
y++;
printf("");
setxy(y*2,x);
printf("◎");
Sleep(500);
continue;
}
}
printf(" returngo ");
system("pause");
}
voidGetMapFromFile()
{
inti,j,x,y,len;
charch[50]={' '};
FILE*fp=fopen("e:\map1.txt","r");
if(fp==NULL)
{
printf("openfilefailed. ");
return;
}
x=0;
while(!feof(fp))
{
fgets(ch,50,fp);
row++;
}
col=strlen(ch);
fseek(fp,0L,SEEK_SET);
while(!feof(fp))
{
fgets(ch,50,fp);
if(s==NULL)
{
len=strlen(ch);
for(i=len-1;i>0;i--)
{
if(ch[i]!='0'&&ch[i]!='1')
{
ch[i]=' ';
}
else
{
break;
}
}
len=strlen(ch);
s=(PT**)malloc(sizeof(PT*)*row);
for(j=0;j<len;j++)
{
*(s+j)=(PT*)malloc(sizeof(PT)*len);
}
}
y=0;
for(i=0;i<len;i++)
{
s[x][y].type=ch[i]-48;
s[x][y].x=x;
s[x][y].y=y;
s[x][y].v=-1;
y++;
}
x++;
}
start=s[row-2][1];
end=s[row-2][len-2];
fclose(fp);
}
intmain()
{
GetMapFromFile();
inti,j;
intx,y;
x=end.x;
y=end.y;
s[x][y].v=0;
stack_in(end);
fun();
c=start;
prt();
go(start.x,start.y);
return0;
}
⑷ C語言迷宮問題，求該演算法的時間和空間的復雜度。迷宮的路徑已經定義好，求出路的演算法。
該演算法是不穩定的，其時空復雜度不僅和m,n有關，還和mg[][]的具體數值有關。
最壞情況下：每個點都試探過才走到終點。此時時間復雜度為：(m*n-1)*4，（其中4為4個方向），空間復雜度m*n*2，(其中m*n為存儲迷宮圖空間，m*n為棧空間);
再好情況下：一次試探過就走到終點。此時時間復雜度為：(min(m,n)-1)，空間復雜度m*n;
所以：
該演算法時間復雜度為：[(m*n-1)*4+(min(m,n)-1)]/2，約為2×m×n
空間復雜度為3*m*n/2
⑸ 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語言迷宮問題，以一個m×n的長方陣表示迷宮，0和1分別表示迷宮中的通路和障礙。
#defineSTACK_SIZE1000
#defineTRUE1
#defineFALSE0
#include<stdio.h>
shortDIRECTION_UP=1;
shortDIRECTION_RIGHT=1<<1;
shortDIRECTION_DOWN=1<<2;
shortDIRECTION_LEFT=1<<3;
shortALL_DIRECTIONS=DIRECTION_UP|DIRECTION_RIGHT|DIRECTION_DOWN|DIRECTION_LEFT;
typedefstruct{
intx;
inty;
shortdirections;
}Cell;
typedefstruct{
Cellelem[STACK_SIZE];
inttop;
}Stack;
voidinitStack(Stack*s){
s->top=-1;
}
intisEmpty(Stack*s){
return(s->top==-1?TRUE:FALSE);
}
voidpush(Stack*s,Celle){
s->top++;
s->elem[s->top]=e;
}
voidpop(Stack*s,Cell*e){
*e=s->elem[s->top];
s->top--;
}
inthasDirection(Cell*e,shortd){
return(e->directions&d)!=0?1:0;
}
voidremoveDirection(Cell*e,shortd){
e->directions=e->directions&(~d);
}
intmain(){
inti,j;
intm,n;
intentranceX,entranceY,exitX,exitY;
scanf("%d%d",&m,&n);
shorta[m][n];
shortvisited[m][n];
for(i=0;i<m;i++){
for(j=0;j<n;j++){
scanf("%d",&a[i][j]);
visited[i][j]=0;
}
}
scanf("%d%d%d%d",&entranceX,&entranceY,&exitX,&exitY);
Stacksteps;
initStack(&steps);
Celle;
e.y=entranceX;
e.x=entranceY;
e.directions=ALL_DIRECTIONS;
push(&steps,e);
visited[entranceX][entranceY]=1;
while(!isEmpty(&steps)){
pop(&steps,&e);
if(e.x==exitX&&e.y==exitY){
push(&steps,e);
break;
}
if(e.x>0&&hasDirection(&e,DIRECTION_UP)&&a[e.x-1][e.y]==0&&!visited[e.x-1][e.y]){
removeDirection(&e,DIRECTION_UP);
push(&steps,e);
e.x--;
e.directions=ALL_DIRECTIONS;
removeDirection(&e,DIRECTION_DOWN);
push(&steps,e);
visited[e.x][e.y]=1;
}elseif(e.y<n-1&&hasDirection(&e,DIRECTION_RIGHT)&&a[e.x][e.y+1]==0&&!visited[e.x][e.y+1]){
removeDirection(&e,DIRECTION_RIGHT);
push(&steps,e);
e.y++;
e.directions=ALL_DIRECTIONS;
removeDirection(&e,DIRECTION_LEFT);
push(&steps,e);
visited[e.x][e.y]=1;
}elseif(e.x<m-1&&hasDirection(&e,DIRECTION_DOWN)
&&a[e.x+1][e.y]==0&&!visited[e.x+1][e.y]){
removeDirection(&e,DIRECTION_DOWN);
push(&steps,e);
e.x++;
e.directions=ALL_DIRECTIONS;
removeDirection(&e,DIRECTION_UP);
push(&steps,e);
visited[e.x][e.y]=1;
}elseif(e.y>0&&hasDirection(&e,DIRECTION_LEFT)
&&a[e.x][e.y-1]==0&&!visited[e.x][e.y-1]){
removeDirection(&e,DIRECTION_LEFT);
push(&steps,e);
e.y--;
e.directions=ALL_DIRECTIONS;
removeDirection(&e,DIRECTION_RIGHT);
push(&steps,e);
visited[e.x][e.y]=1;
}
}
if(isEmpty(&steps)){
printf("No");
}else{
printf("Yes");
}
return0;
}
⑺ 走迷宮的C語言版代碼求助 程序開始運行時顯示一個迷宮地圖，迷宮中央有一隻老鼠，迷宮的右下方有一個糧
/*註：本程序探索迷宮的優先順序=> 1-下、2-右、3-上、4-左 <=總體趨勢：下右，逆時針方向。因為出口就在右邊下方*/
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define stack_init_size 200
#define stack_increment 10
#define OVERFLOW 0
#define OK 1
#define ERROE 0
#define TRUE 1
#define FALSE 0
typedef int Status;
typedef struct{
int x;
int y;
}PosType;
typedef struct {
int ord; // 通道塊在路徑上的"序號"
PosType seat; //通道塊在迷宮中的"坐標位置"
int di; //從此通道塊走向下一通道塊的"方向"
}SElemType;
typedef struct{
SElemType *base;
SElemType *top;
int stacksize;
}SqStack;
int mg[20][20];
/*隨機生成迷宮的函數
/*為了能夠讓盡量能通過，將能通過的塊和不能通過的塊數量比大致為2:1*/
void Random(){
int i,j,k;
srand(time(NULL));
mg[1][0]=mg[1][1]=mg[18][19]=0; //將入口、出口設置為"0"即可通過
for(j=0;j<20;j++)
mg[0][j]=mg[19][j]=1; /*設置迷宮外圍"不可走"，保證只有一個出口和入口*/
for(i=2;i<19;i++)
mg[i][0]=mg[i-1][19]=1; /*設置迷宮外圍"不可走"，保證只有一個出口和入口*/
for(i=1;i<19;i++)
for(j=1;j<19;j++){
k=rand()%3; //隨機生成0、1、2三個數
if(k)
mg[i][j]=0;
else{
if((i==1&&j==1)||(i==18&&j==18)) /*因為距入口或出口一步的路是必經之路，故設該通道塊為"0"加大迷宮能通行的概率*/
mg[i][j]=0;
else
mg[i][j]=1;
}
}
}
//構造一個空棧
Status InitStack(SqStack &s){
s.base =(SElemType *)malloc(stack_init_size * sizeof(SElemType));
if(!s.base) return OVERFLOW;
s.top=s.base;
s.stacksize=stack_init_size;
return OK;
}
//當前塊可否通過
Status Pass(PosType e){
if (mg[e.x][e.y]==0) //0時可以通過
return OK; // 如果當前位置是可以通過，返回1
return OVERFLOW; // 其它情況返回0
}
//留下通過的足跡
Status FootPrint(PosType e){
mg[e.x][e.y]=7;
return OK;
}
//壓入棧
Status Push(SqStack &s,SElemType e){
if(s.top-s.base>=s.stacksize){
s.base=(SElemType *)realloc(s.base,(s.stacksize+stack_increment) *sizeof(SElemType));
if(!s.base)exit(OVERFLOW);
s.top=s.base+s.stacksize;
s.stacksize+=stack_increment;
}
*s.top++=e;
return OK;
}
//出棧
Status Pop(SqStack &s,SElemType &e){
if(s.top==s.base)
return ERROE;
e=*--s.top;
return OK;
}
//下一步
PosType NextPos(PosType &e,int dir){
PosType E;
switch(dir){
case 1:E.x=e.x; //向下
E.y=e.y+1;
break;
case 2:E.x=e.x+1; //向右
E.y=e.y;
break;
case 3:E.x=e.x; //向上
E.y=e.y-1;
break;
case 4:E.x=e.x-1; //向左
E.y=e.y;
break;
}
return E;
}
//是否空棧
Status StackEmpty(SqStack s){
if (s.top==s.base)
return OK;
return OVERFLOW;
}
//留下不能通過的足跡
Status MarkPrint(PosType e){
mg[e.x][e.y]=3;
return OK;
}
//迷宮函數
// 若迷宮maze中從入口 start到出口 end的通道，則求得一條存放在棧中
// （從棧底到棧頂），並返回TRUE；否則返回FALSE
Status MazePath(int mg,PosType start,PosType end,SqStack &s){
PosType curpos;
InitStack(s);
SElemType e;
int curstep;
curpos=start; // 設定"當前位置"為"入口位置"
curstep=1; // 探索第一步
do{
if(Pass(curpos)){ // 當前位置可通過，即是未曾走到過的通道塊
FootPrint(curpos); // 留下足跡
e.di =1;
e.ord = curstep;
e.seat= curpos;
Push(s,e); // 加入路徑
if(curpos.x==end.x&&curpos.y==end.y){
printf("\n\n0∩_∩0 能到達終點!");
return TRUE;
}
curpos=NextPos(curpos,1); // 下一位置是當前位置的東鄰
curstep++; // 探索下一步
}
else{ // 當前位置不能通過
if(!StackEmpty(s)){
Pop(s,e);
while(e.di==4&&!StackEmpty(s)){
MarkPrint(e.seat);
Pop(s,e);
}
if(e.di<4){
e.di++;
Push(s,e); // 留下不能通過的標記，並退回一步
curpos=NextPos(e.seat,e.di); /* 當前位置設為新方向的相鄰塊*/
}//if
}//if
}//else
}while(!StackEmpty(s));
printf("\n\n囧 ! 不能到達終點!");
return FALSE;
}
//列印迷宮
void PrintMaze(){
int i,j;
printf("運行路徑:\n\n");
for(i=0;i<20;i++){
for(j=0;j<20;j++){
if(mg[i][j]==0)printf(" ");
else if(mg[i][j]==1) printf("■"); //迷宮的"牆"
else if(mg[i][j]==3) printf("◇"); //不通的路
else if(mg[i][j]==7)printf("○"); //通過的路徑
}
printf("\n");
}
printf("\n");
}
void main(){
SqStack S;
PosType start,end;
start.x=1;start.y=0; //起點坐標
end.x=18;end.y=19; //終點坐標
printf("\n==================迷宮游戲==================");
printf("\n說明:■不能走的區域\t◇走不通的區域");
printf("\n '空格'代表未到過的區域");
printf("\n ○代表能通過的路徑，指向終點");
printf("\n============================================");
Random();
printf("\n\nTest 1:");
MazePath(mg[20][20],start,end,S);
PrintMaze();
system("pause");
Random();
printf("\nTest 2:");
MazePath(mg[20][20],start,end,S);
PrintMaze();
system("pause");
Random();
printf("\nTest 3:");
MazePath(mg[20][20],start,end,S);
PrintMaze();
printf("\n==========程序退出，感謝使用!==========\n");
}
⑻ 數據結構C語言版迷宮問題
剛學都這樣，想當初我學習的時候連一個單鏈表的逆置，都要理解半天。編程就是把實際問題給抽象成數學或非數學模型，結合數據的表示，再找到解決的方法。別忘了，學習數據結構是為了更好的操作數據。
思路：
首先，迷宮如何用計算機語言表示？一般用二維數組。0表示牆，1表示路。
其次，其次就是如何從迷宮中走出來了。結合堆棧，進行搜索。
你可以嘗試著對問題進行分層，然後逐步細化來解決。
如果你要解決一個別人給的走迷宮的問題，同樣還是要這樣，首先把別人給的迷宮在計算機中表示出來，其次結合數據結構所學的知識，找到通路，（關於結合數據結構的知識就看你自己的了，關鍵是對堆棧的了解）。
關於你說的，先看別人的程序，找到思路後自己才能編程問題。我看你是操之過急了，你得明白，知識的學習，首先就是會模仿，等你對整個課程有了系統的認識，你才會有自己的解題思路。創新是在有基礎的前提下進行的。別人的東西，試著理解，畢竟許多東西單憑我們自己是不太可能想出來的，就像kmp演算法一樣（你應該馬上就會學到）。
第一章說過，研究數據間的關系的目的是為了更好的操作數據，迷宮問題，可以說是一類「搜索」問題，更強調的是演算法，即在精通堆棧的基礎上想出一個利用堆棧對迷宮進行搜索的辦法。而堆棧，則是基礎，堆棧的操作就那麼幾個，學完馬上就會用。關鍵是如何運用三種程序設計方法再結合某些數據結構設計出一個演算法。一步一步來吧。
對了，給你一個問題考慮考慮，「不用任何輔助變數」編寫一個程序，逆置一個字元串試試。只給你一個參數：該參數就是指向字元串的指針。
你的最後問題問的就有點沒頭緒了，學習的過程並不是你想的那樣的，不見得數據結構學完之後就能編寫高質量程序，寫程序和看程序是相輔相成的，寫而不學則怠，學而不寫則罔。可以嘗試的寫寫，自己找不到思路可以看看別人是怎麼想的，自己多做做總結。