迷宫小白鼠c语言解说

① c语言迷宫求解如何找到所有的路

迷宫源程序*/
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <dos.h>

② 求C语言迷宫程序的解释说明！！！

我看了一下,算法应该是一样的,下面是我以前用C++写的
相信你能看得懂

/////////////////////////
/////////迷宫求解////////
//////作者:hacker/////
/////时间:11.10.2006/////
/////////////////////////
/*class:
Matrix:矩阵类
offsets:搜索偏移
enum directions:四个方向
struct item:搜索节点
Migong:迷宫类
1.创建一个Migong对象
2.使用用Create方法输入数据
3.使用Solve方法进行求解
4.ShowSolve方法显示解
5.可以重复使用Create方法
6.入口只能在左上角
7.默认出口在右下角
ShowAllPath:穷举所有的路径
备注:
由于算法原因,这里的所有路径应该是指
介于:
a.如果两条路存在某个点不同那么就是不同的路
b.如果在一条路中去掉一个或者一个以上的圈,那么他们是同一条路
之间意义上的路
*/
#include <iostream>
#include <stack>
#include <vector>

using namespace std;

#ifndef MIGONG_H
#define MIGONG_H
///////////////////
///////矩阵类//////
///////////////////
class Matrix{
int* m;
int row, col;
bool iscreate;
public:
Matrix(){m=0;iscreate=false;};
~Matrix() {Release();};
bool Create(int, int);
int& operator () (int, int);
int GetRow(){return row;};
int GetCol(){return col;};
void Release();
void Show(char, char );
};

bool Matrix::Create(int r, int c)
{
if( r<=0 || c<=0) return false;

Release();

row = r;
col = c;
m = new int[row*col];

for (int i=0;i<row*col;i++)
{
*(m+i) = 0;
}
iscreate = true;
return true;
}

int& Matrix::operator ()(int r, int c)
{
return *(m+r*col+c);
}

void Matrix::Release()
{
if (iscreate)
{
row = col = 0;
if (m) delete[] m;
m = 0;
}
iscreate = false;
}

void Matrix::Show(char blk='#', char nblk=' ')
{
int i, j;
for (i=0;i<row;i++)
{
for (j=0;j<col;j++)
{
if (*(m+i*col+j) == 0)
cout<<nblk;
else
cout<<blk;
}
cout<<endl;
}
}
/////////////////////////////
////迷宫相关数据结构的定义///
/////////////////////////////
struct offsets{
int a, b;
};

enum directions{
_S = 0,
_E,
_N,
_W
};

struct item{
int row, col, dir;
};

class Migong{
static offsets move[4];
Matrix maze;
Matrix mark;
int row;
int col;
int desr;
int desc;
stack<item> stk;
bool iscreate;
int pathlength;
bool GetPath();
bool IsInPath(int, int);
public:
Migong(){issolved=false;result=0;pathlength=row=col=0;iscreate=false;};
~Migong(){Release();};
bool Create(int* , int , int , int , int );
void Solve();
void Release();
void OutputMaze();
void ShowSolve(char, char );
public:
bool issolved;
item* result;
};

offsets Migong::move[4]={ {1, 0}, {0, 1},
{-1, 0}, {0, -1}};

////////////////////////////
//迷宫数据应该是不含边框的//
////////////////////////////
bool Migong::Create(int* m, int r, int c, int desrow=-1, int descol=-1)
{
if (r<=0 || c<=0) return false;

Release();

if (desrow==-1 || descol==-1)
{
desr = r;
desc = c;
}
else
{
desr = desrow;
desc = descol;
}

row = r;
col = c;
maze.Create(r+2, c+2);
mark.Create(r+2, c+2);

int i, j;

for (i=0;i<r+2;i++)
{
for (j=0;j<c+2;j++)
{
if (j==0 || j==c+1 || i==0 || i==r+1)
{
mark(i, j) = maze(i, j) = 1;

}else
{
mark(i, j) = 0;
maze(i, j) = m[((i-1)*col+j-1)];
}
}
}
return iscreate = true;
}

bool Migong::GetPath()
{
mark(1,1) = 1;
item temp;
temp.col = 1;
temp.row = 1;
temp.dir = _S;
stk.push(temp);

while (!stk.empty())
{
temp = stk.top();
stk.pop();

int i = temp.row;
int j = temp.col;
int d = temp.dir;

while (d<4)
{//根据当前点的状态确定下一个搜索点
int g = i + move[d].a;
int h = j + move[d].b;

if (g==desr && h==desc)
{
return true;
}
//如果这个点不是障碍点且没有被搜索过那么可以对这个点进行搜索
if (maze(g, h)==0 && mark(g, h)==0)
{
mark(g, h) = 1;
temp.row = g;
temp.col = h;
temp.dir = d+1;
stk.push(temp);
i = g;
j = h;
d = _S;//对一下个点进行搜索
}
else d++;
}
}
return false;
}

void Migong::Solve()
{
issolved = GetPath();
if (issolved)
{
pathlength = stk.size();
result = new item[pathlength];
for (int i=0;i<pathlength;i++)
{
*(result+i) = stk.top();
stk.pop();
// cout<<"("<<(*(result+i)).row<<","<<(*(result+i)).col<<")"<<endl;
}
}
while (!stk.empty())
stk.pop();
}

void Migong::Release()
{
if (iscreate)
{
maze.Release();
mark.Release();
row=col=0;
if (result)
delete [] result;
result = 0;
while (!stk.empty())
stk.pop();
}
iscreate = false;
issolved = false;
pathlength = 0;
}

void Migong::OutputMaze()
{
if (!iscreate) return;
maze.Show();
}

bool Migong::IsInPath(int r, int c)
{
if (!iscreate || !issolved)
return false;

item temp;
for (int i=0;i<pathlength;i++)
{
temp = *(result+i);
if ((temp.row==r) && (temp.col==c))
return true;
}

return false;
}

void Migong::ShowSolve(char blk='#',char s='o')
{
if (!iscreate) return;
if (!issolved)
{
cout<<"无解"<<endl;
}
else
{
int i, j;
for (i=0;i<row+2;i++)
{
for (j=0;j<col+2;j++)
{
if ((i==1 && j==1) || (i==desr && j==desc))
{
cout<<s;
}
else if (maze(i, j) == 1)
{
cout<<blk;
}else
{
if (IsInPath(i, j))
cout<<s;
else
cout<<' ';
}
}
cout<<endl;
}
}
}

//////////////////////
//////穷举所有路径////
//////////////////////
offsets move[4]={ {1, 0}, {0, 1},
{-1, 0}, {0, -1}};

struct node
{
int row,col;
};

vector<node> path;
int count;
bool IsReachable( Matrix& maze, Matrix& mark, node beg, node des)
{
if (beg.row==des.row&&beg.col==des.col)
{//如果达到的话那么显示路径
count++;
cout<<"第"<<count<<"条路径:"<<endl;
for (int i=0;i<path.size();i++)
cout<<"("<<path[i].row<<","<<path[i].col<<")";
cout<<"("<<des.row<<","<<des.col<<")";
cout<<endl;
return false;
}
if (maze(beg.row, beg.col)==1 || mark(beg.row, beg.col)==1)
{
return false;
}

path.push_back(beg);
mark(beg.row, beg.col) = 1;

node nextnode;

for (int i=_S;i<_W+1;i++)
{
nextnode.row = beg.row + move[i].a;
nextnode.col = beg.col + move[i].b;

IsReachable(maze, mark, nextnode, des);
}

path.resize(path.size()-1);
mark(beg.row, beg.col) = 0;

return false;//如果不是穷举的话应该根据for循环的结果重新设置返回值
}

/*
参数maze,mark为迷宫长宽均加二的矩阵
desr,desc为出口点
*/
void FindAllPath( Matrix& maze, Matrix& mark, int desr, int desc)
{
node first, last;
first.row = 1;
first.col = 1;
last.row = desr;
last.col = desc;

IsReachable(maze, mark, first, last);

path.clear();
}

/*
m迷宫矩阵数据
r,c行和列的大小
desr,desc目标位置
*/
void ShowAllPath(int* m, int r, int c, int desr=-1, int desc=-1)
{
Matrix maze, mark;
maze.Create(r+2, c+2);
mark.Create(r+2, c+2);

if (desr==-1 || desc==-1)
{
desr = r;
desc = c;
}

int i, j;

for (i=0;i<r+2;i++)
{
for (j=0;j<c+2;j++)
{
if (j==0 || j==c+1 || i==0 || i==r+1)
{
mark(i, j) = maze(i, j) = 1;

}else{
mark(i, j) = 0;
maze(i, j) = m[((i-1)*c+j-1)];
}
}
}

count = 0;
FindAllPath(maze, mark, desr, desc);

maze.Release();
mark.Release();
}
#endif

③ 如何用C语言编写一个迷宫程序

#include<stdio.h>
#include<stdlib.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(d<4) //试探东南西北各个方向
{
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");
}

④ 数据结构C语言版迷宫问题

刚学都这样，想当初我学习的时候连一个单链表的逆置，都要理解半天。编程就是把实际问题给抽象成数学或非数学模型，结合数据的表示，再找到解决的方法。别忘了，学习数据结构是为了更好的操作数据。
思路：
首先，迷宫如何用计算机语言表示？一般用二维数组。0表示墙，1表示路。
其次，其次就是如何从迷宫中走出来了。结合堆栈，进行搜索。
你可以尝试着对问题进行分层，然后逐步细化来解决。

如果你要解决一个别人给的走迷宫的问题，同样还是要这样，首先把别人给的迷宫在计算机中表示出来，其次结合数据结构所学的知识，找到通路，（关于结合数据结构的知识就看你自己的了，关键是对堆栈的了解）。

关于你说的，先看别人的程序，找到思路后自己才能编程问题。我看你是操之过急了，你得明白，知识的学习，首先就是会模仿，等你对整个课程有了系统的认识，你才会有自己的解题思路。创新是在有基础的前提下进行的。别人的东西，试着理解，毕竟许多东西单凭我们自己是不太可能想出来的，就像kmp算法一样（你应该马上就会学到）。
第一章说过，研究数据间的关系的目的是为了更好的操作数据，迷宫问题，可以说是一类“搜索”问题，更强调的是算法，即在精通堆栈的基础上想出一个利用堆栈对迷宫进行搜索的办法。而堆栈，则是基础，堆栈的操作就那么几个，学完马上就会用。关键是如何运用三种程序设计方法再结合某些数据结构设计出一个算法。一步一步来吧。
对了，给你一个问题考虑考虑，“不用任何辅助变量”编写一个程序，逆置一个字符串试试。只给你一个参数：该参数就是指向字符串的指针。

你的最后问题问的就有点没头绪了，学习的过程并不是你想的那样的，不见得数据结构学完之后就能编写高质量程序，写程序和看程序是相辅相成的，写而不学则怠，学而不写则罔。可以尝试的写写，自己找不到思路可以看看别人是怎么想的，自己多做做总结。

⑤ c语言程序设计的迷宫

这个可行的
/*4.3.3源程序*/
#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找到，0没找到*/
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-2&&y==N-2)/*人工控制找成功的话*/
yes=1;
/*如果成功标志为1*/
}
void
WayCopy(int
(*oldmap)[N],int
(*map)[N])/*拷贝迷宫数组
*/
{
int
i,j;
for(i=0;i<N;i++)
for(j=0;j<N;j++)
oldmap[i][j]=map[i][j];
}
int
FindWay(int
(*map)[N],int
i,int
j)/*递归找路*/
{
if(i==N-2&&j==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;i<N;i++)
{
for(j=0;j<N;j++)
{
if(i==0||i==N-1||j==0||j==N-1)/*最外面一圈为墙壁*/
map[i][j]=1;
else
if(i==1&&j==1||i==N-2&&j==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;i<N;i++)
for(j=0;j<N;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语言 老鼠走迷宫

可以给你点提示：迷宫 可用个二维数组表示。求解方法是：从入口出发，顺某个方向走，若能过去，继续；否则，沿着原路返回，换方向继续走，直到所有可能的通路都被找到为止。为保证在任何位置上都能沿原路退回，需要一个先进后出的栈结构保存从入口到当前位置的路径。这里，给个算法的思想，不实现图形界面了。假设迷宫数据存放在一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<stdio.h>
#include<conio.h>
intmigong[10][10]=//设置迷宫，最外围1为墙里边0为可走路径1为障碍
{
{1,1,1,1,1,1,1,1,1,1},
{1,0,0,0,0,0,0,1,1,1},
{1,0,1,1,1,1,1,0,0,1},
{1,0,1,0,0,0,0,0,0,1},
{1,0,0,0,1,0,1,1,1,1},
{1,1,1,1,0,0,1,1,1,1},
{1,0,0,0,0,1,1,1,1,1},
{1,0,1,1,0,0,1,1,1,1},
{1,0,0,0,0,0,0,0,0,1},
{1,1,1,1,1,1,1,1,1,1}
};
intnum;
struct
{
	intx,y,d;
}lj[100];//x,y分别为垂直和水平方向

voidstart()
{
	inttop=0,x,y,d,find;//d为设置方向，上下左右。find为设置找不找得到路
	lj[top].x=1;
	lj[top].y=1;
	migong[1][1]=-1;
	find=0;d=-1;
	
	while(top>-1){
		if(lj[top].x==8&&lj[top].y==8)
		{
			printf("迷宫路径如下：
");
			printf("start->");
			for(x=0;x<=top;x++)
			{
				printf("(%d,%d)->",lj[x].x,lj[x].y);//把找到的路径输出
				num++;
				if(num%8==0)
					printf("
");
			}
			printf("->end!
");
		}
		
		while(d<4&&find==0){
			d++;
			switch(d){
			case0:x=lj[top].x-1;y=lj[top].y;break;//方向为上
			case1:x=lj[top].x;y=lj[top].y+1;break;//方向为右
			case2:x=lj[top].x+1;y=lj[top].y;break;//方向为下
			case3:x=lj[top].x;y=lj[top].y-1;}//方向为左
			if(migong[x][y]==0)
				find=1;
		}
		
		if(find==1){//判断是否找得到
			lj[top].d=d;
			top++;
			lj[top].x=x;
			lj[top].y=y;
			d=-1;find=0;//重新调整方向
			migong[x][y]=-1;}
		else{
			migong[lj[top].x][lj[top].y]=0;
			top--;d=lj[top].d;//找不到的话退栈
		}
	}
}

voidmain()
{
	start();
	getch();
}

⑧ C语言迷宫问题

给你一个我以前的课程设计注释比较详细希望对你有所帮助！
#include<stdio.h>
#include<stdlib.h>
#define STACK_INI_SIZE 100
#define STACKINCREMENT 50
#define NULL 0
typedef struct
{
int *top;
int *base;
int length;
int stacksize;
}sqstack;
int mg[25][25];
int m=1,n=1,x,y;
/*********************************************/
main()
{
void initstack(sqstack *s);/*初始化栈*/
void stackpush(sqstack *s,int);/*增加栈顶*/
void stackpop(sqstack *s);/*撤销栈顶*/
void stackinput(sqstack *s);/*输出栈*/
int mgway(sqstack *s);/*迷宫路径*/
void destorystack(sqstack *s);/*撤销栈S*/
void makemg(sqstack *s);/*制造迷宫*/
sqstack s;
int i,flag1=1,flag2=1,flag3=1;
char ch;
srand((unsigned)time(NULL));
while(flag1)
{
initstack(&s);
flag2=1;
makemg(&s);
i=mgway(&s);
if(i==0)
printf("此迷宫没有通路\n");
else
stackinput(&s);
destorystack(&s);
printf("还继续么?");
fflush(stdin);
scanf("%c",&ch);
while(flag2)
{
if(ch=='n'||ch=='N')
{
flag1=0;
flag2=0;
}
else if(ch=='y'||ch=='Y')
{
flag1=1;
flag2=0;
}
else
{
printf("输入错误请重新输入");
fflush(stdin);
scanf("%c",&ch);
}
}

}
}
/*********************************************/
void initstack(sqstack *s)/*初始化栈*/
{
s->top=s->base=(int *)malloc(STACK_INI_SIZE*sizeof(int));
if(!s->base)
exit(1);
s->stacksize=STACK_INI_SIZE;
*(s->base)=0;
s->top++;
*(s->top)=101;
s->top++;
s->length=2;
}
/*********************************************/
void stackpush(sqstack *s,int i)/*增加栈顶*/
{
if(s->length>=s->stacksize)
{
printf("路过");
s->base=(int *)realloc(s->base,(STACK_INI_SIZE+STACKINCREMENT)*sizeof(int));
if(!s->base)
exit(1);
s->top=s->base+s->length;
s->stacksize+=STACKINCREMENT;
stackinput(s);
}
if(s->length==0)
{
*(s->base)=i;
s->top++;
s->length++;
}
else
{
*(s->top)=i;
s->top++;
s->length++;
}
}
/*********************************************/
void stackpop(sqstack *s)/*删除栈顶*/
{
if(s->length==0)
printf("栈空 无法删除");
if(s->length==1)
{
s->top--;
*(s->top)=*(s->base)=NULL;
s->length=0;
}
else
{
s->top--;
*(s->top)=NULL;
s->length--;
}
}
/*********************************************/
void stackinput(sqstack *s)/*迷宫栈的输出*/
{
int w,x,y,z,i=0,*p;
p=s->base;
p++;
printf("迷宫正确路径\n");
while(p!=s->top)
{
printf("(%d%d,%d%d)",x=*p/1000,y=*p/100%10,z=*p%100/10,w=*p%10);
p++;
i++;
if(i==7)
{
printf("\n");
i=0;
}
}
}
/*********************************************/
int mgway(sqstack *s)/*迷宫路径*/
{
int gudge(sqstack *s,int);/*判断是否能通行*/
int homing(sqstack *s);/*退栈后I所对应的方向*/
int i=1,j,k;
while(s->top!=s->base)
{
if(i<5)
j=gudge(s,i);
if(j==1&&i<5)
{
k=m*100+n;
stackpush(s,k);
if(m==y-2&&n==x-2)
{
return(1);
}
else
i=1;
}
else
{

if(m==0&&n==0)
return(0);
else if(i==4||i==5)
{
i=homing(s);
stackpop(s);
i++;
}
else
i++;
}
}
return(0);
}
/*********************************************/
int gudge(sqstack *s,int i)/*退栈后i所对应的方向*/
{
int echo(sqstack *s);
if(i==1)
n++;
if(i==2)
m++;
if(i==3)
n--;
if(i==4)
m--;
if((mg[m][n]==0||mg[m][n]==2)&&echo(s))
return(1);
else
{
if(i==1)
n--;
if(i==2)
m--;
if(i==3)
n++;
if(i==4)
m++;
return(0);
}
}
/*********************************************/
int echo(sqstack *s)
{
int i,*p,*q;
i=m*100+n;
p=s->top;
q=s->base;
q++;
p--;
while(p!=q&&*p!=i)
p--;
if(*p==i)
return(0);
else
return(1);
}
/*********************************************/
int homing(sqstack *s)/*i退位后所对应的方向*/
{
int a,b,c,d,*q;
q=s->top;
q--;
a=(*q)/100;
b=(*q)%100;
q--;
c=(*q)/100;
d=(*q)%100;
m=(*q)/100;
n=(*q)%100;
if(a==c)
{
if(d-b==1)
return(3);
else if(d-b==-1)
return(1);
}
else if(b==d)
{
if(c-a==1)
return(4);
else if(c-a==-1)
return(2);
}
return(0);
}
void destorystack(sqstack *s)
{
if(*(s->base)!=NULL)
free(s->base);
s->length=0;
}
/*********************************************/
void makemg(sqstack *s)/*创建迷宫及输出迷宫图的函数*/
{
int mgway(sqstack *s);
void clearstack(sqstack *s);
int flag=1,flag2=1,i,j,k;
char ch;
while(flag)
{
printf("请输入迷宫的长宽(长度范围2-15,宽范围2-15)\n");
printf("输入长");
fflush(stdin);
scanf("%d",&y);
printf("输入宽");
fflush(stdin);
scanf("%d",&x);
if(x<16&&x>3&&y>3&&y<16)
flag=0;
if(flag==0)
printf("自动筛选能通过的迷宫需要一段时间,请耐心等待,如20秒后无法显示出迷宫样本请重试... ...\n");
}
flag=1;
while(flag2)
{
m=1;
n=1;
for(i=0;i<x;i++)
for(j=0;j<y;j++)
mg[i][j]=rand()%3;
i=0;
for(j=0;j<y;j++)
{
mg[i][j]=1;
mg[j][i]=1;
}
i=y-1;
for(j=0;j<x;j++)
mg[j][i]=1;
i=x-1;
for(j=0;j<y;j++)
mg[i][j]=1;
mg[1][1]=0;
mg[x-2][y-2]=0;
k=mgway(s);
if(k==1)
flag2=0;
else
clearstack(s);
}
printf(" ");
for(i=0;i<y;i++)
printf("%2d",i);
printf("\n ");
for(i=0;i<y;i++)
printf("↓");
printf("\n");
for(i=0;i<x;i++)
{
printf("%2d→",i);
for(j=0;j<y;j++)
{
if(mg[i][j]==2)
printf("0 ");
else
printf("%d ",mg[i][j]);
}
printf("\n");
}
}
/*********************************************/
void clearstack(sqstack *s)/*清空栈对于此程序而言*/
{
s->top=s->base;
*(s->base)=0;
s->top++;
*(s->top)=101;
s->top++;
s->length=2;
}

⑨ C语言数据结构 老鼠走迷宫问题

/* 迷宫矩阵
1 1 1 1 1 1 1 1 1 1
1 0 0 0 0 1 0 0 0 1
1 1 1 0 0 1 0 1 0 1
1 0 0 0 1 0 0 0 0 1
1 0 0 0 0 1 0 1 0 1
1 1 0 1 0 0 0 0 0 1
1 0 0 1 1 1 0 1 1 1
1 1 0 0 0 1 0 0 0 1
1 1 1 1 1 1 1 1 1 1
*/
#include<stdio.h>
#define m 7
#define n 8
void path()
{
int maze[m+2][n+2] ;
int move[4][2]={ {0,-1},{-1,0},{0,1},{1,0} };
int s[54][3];
int top=0;
int i,j,k,f=0;
int g,h,p;
for(i=0;i<m+2;++i)
for(j=0;j<n+2;++j)
scanf("%d",&maze[i][j]);
maze[1][1]=2;
s[top][0]=1;
s[top][1]=1;
s[top][2]=0;
++top;
while(top!=0&&f==0)
{
--top;
i=s[top][0];
j=s[top][1];
k=s[top][2];
while(k<4)
{
g=i+move[k][0];
h=j+move[k][1];
if(g==m&&h==n&&maze[g][h]==0)
{
for(p=0;p<top;++p)
printf("%3d,%d\n",s[p][0],s[p][1]);
printf("%3d,%d\n",i,j);
printf("%3d,%d\n",m,n);
f=1;
}//if
if(maze[g][h]==0)
{
maze[g][h]=2;
s[top][0]=i;
s[top][1]=j;
s[top][2]=k;
++top;
i=g;
j=h;
k=0;
}//if
k=k+1;
}//while
}//while
if(f==0)
printf("no path\n");
}//pathvoid main()
{
path();
}