c语言数字迷宫
Ⅰ 随即产生50个1-50之间的不重复的数用c语言如何编写程序
#include <stdio.h>
#include <stdlib.h>
#define M 50
int main()
{
int x[M],i,k;
srand(time(NULL));/*要先设置种子*/
for(i=0;i<M;i++)
{
x[i]=1+rand()%48; /*这样只做告能得到1..48之间的数,修改x[i]=1+rand()%50;*/
for(k=i-1;k>=0;k--)
{
if(x[i]=x[k]) /*比较要用if(x[i] == x[k])*/
{
i--;
break;
}
}
}
for(i=0;i<M;i++)
printf("x[%d]=%d\n",i,x[i]);
return 0;
}
换一种思路：先将1..50排好,然后随机交换50次，效率比较高
#include <stdio.h>销迅
#include <纯斗明stdlib.h>
#define M 50
int main()
{
int x[M],k;
int tmp;
for(i=0;i<M;i++) x[i]=i+1;/*顺序赋值*/
srand(time(NULL));/*设置种子，这个很重要，不然每次运行，结果都相同*/
for(i=0;i<50;i++)
{
k = rand()%50;/*产生一个0..49的随机数*/
tmp = x[k];x[k]=x[i];x[i]=tmp;/*交换x[i],x[k]*/
}
for(i=0;i<M;i++) printf("x[%d]=%d\n",i,x[i]);
return 0;
}
Ⅱ 数据结构迷宫问题（c语言）
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAXLEN 10//迷宫包括外墙最大行列数目
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;
#define STACK_INIT_SIZE 100 //存储空间初始分配量
typedef struct{
int r,c;
} PosType;//迷宫中r行c列的位置
typedef struct MazeType{
int r;
int c;
char arr[MAXLEN][MAXLEN];//可取' ''*' '@' '#'
}MazeType; //迷宫类型
typedef struct{
int step; // 当前位置在路径上的“序号”
PosType seat; //当前的坐标位置
int di; //往下一坐标位置的方向
}SElemType;
typedef struct NodeType{
SElemType data;
NodeType *next;
}NodeType,*LinkType;//结点类型
typedef struct SqStack{
LinkType top;
int stacksize;
}SqStack; //栈类型
PosType start;
PosType end;
MazeType maze;
bool found;
Status InitStack(SqStack &S){
S.top=(LinkType)malloc(sizeof(NodeType));
S.top->next=NULL;
S.stacksize=0;
return OK;
}//InitStack;
Status Push(SqStack &S,SElemType &e){
LinkType p;
p=(NodeType*)malloc(sizeof(NodeType));
if(!p) return ERROR;
p->data=e;
p->next=S.top;
S.top=p;
S.stacksize++;
//S.top=S.base+S.stacksize;
//S.top->data=e;
return OK;
}//Push
Status StackEmpty(SqStack S){
if(S.top->next==NULL) return OK;
return ERROR;
}//StackEmpty
Status Pop(SqStack &S,SElemType &e){
LinkType p;
if(StackEmpty(S)) return ERROR;
p=S.top;
e=p->data;
S.top=S.top->next;
S.stacksize--;
free(p);
return OK;
// 栈顶元素出栈
}//Pop
Status DestroyStack(SqStack &S){//销毁栈S,
LinkType p;
while(S.top!=NULL){
p=S.top;
S.top=S.top->next;
free(p);
}//while
if(S.top==NULL) return OK;
else return ERROR;
}//DestroyStack
Status MarkPrint(MazeType &maze,PosType curpos){
maze.arr[curpos.r][curpos.c]='@';//"@"表示曾走过但不通
return OK;
}//Markprint曾走过但不是通路标记并返回OK
Status FootPrint(MazeType &maze,PosType curpos){
maze.arr[curpos.r][curpos.c]='*';//"*"表示可通
return OK;
}//FootPrint
PosType NextPos(PosType &curpos,int i){
PosType cpos;
cpos=curpos;
switch(i){ //1.2.3.4分别表示东,南,西,北方向
case 1 : cpos.c+=1; break;
case 2 : cpos.r+=1; break;
case 3 : cpos.c-=1; break;
case 4 : cpos.r-=1; break;
default: exit(ERROR);
}//switch
return cpos;
}//Nextpos
Status Pass(MazeType &maze, PosType curpos){
/*for(int i=0;i<10;i++){
for(int j=0;j<10;j++){
printf("%4c",maze.arr[i][j]);
}
printf("\n");
}*/
//char a=' ';
//printf("%4d",a);
//printf("%d,%d",curpos.r,curpos.c);
//printf("%4c",maze.arr[1][1]);
if(maze.arr[curpos.r][curpos.c]==' '){//当前位置可通
//printf("go");
return TRUE;
}//if
else{
//printf("go");
return FALSE;
}//else
}//Pass
void InitMaze(MazeType &maze, char a[MAXLEN][MAXLEN], int row, int col){
//printf("go");
maze.r=row;
maze.c=col;
//printf("%d,%d",row,col);
for(int i=0;i<=col+1;i++){a[0][i]='1';a[row+1][i]='1';}
//printf("go");
for(i=0;i<=row+1;i++){a[i][0]='1';a[i][col+1]='1';}
//printf("go");
/*for(i=0;i<10;i++){
for(int j=0;j<10;j++){
printf("%4c",a[i][j]);
}
printf("\n");
}
*/
for(i=0;i<=maze.r+2;i++){
for(int j=0;j<maze.c+2;j++){
if(a[i][j]=='1') maze.arr[i][j]='#';
//if(a[i][j]==0) maze.arr[i][j]=' ';
else maze.arr[i][j]=' ';
}//for
}//for
}//InitMaze
Status MazePath(MazeType &maze,PosType start,PosType end)
{//求解迷宫maze中，从入口start到出口end的一条路径，
//若存在则返回TRUE,否则返回FALSE
PosType curpos;
int curstep;
SqStack S;
SElemType e;
InitStack(S);
curpos=start;//设定“当前位置”为“入口位置”
curstep=1; //探索第一步
found=false;
do{
if(Pass(maze,curpos))
{
//当前位置可以通过，即是未曾走到过的通道块留下足迹
FootPrint(maze,curpos);//做可以通过的标识
e.step=curstep;
e.seat=curpos;
e.di=1;//为栈顶元素赋值
if(Push(S,e)!=OK) return ERROR;
if(curpos.r==end.r && curpos.c==end.c) found=true;//如果到达终点返回true
else{
curpos=NextPos(curpos,1);//下一位置是当前位置的东邻
curstep++;//探索下一步
}//else
}//if
else
if(StackEmpty(S)!=1)
{
Pop(S,e);
while(e.di==4 && !StackEmpty(S))
{
MarkPrint(maze,e.seat);
Pop(S,e);
curstep--;
}//while
if(e.di<4)
{
e.di++;
Push(S,e);//换下个方向探索
curpos=NextPos(e.seat,e.di);
}//if
}//if
}while(StackEmpty(S)!=1&&!found);
DestroyStack(S);
if(found)
return true;
else
return false;//没有找到路径
}//MazePath
void PrintMaze(MazeType &maze){
//将标记路径信息的迷宫输出到终端(包括外墙)
for(int i=0;i<=maze.r+2;i++){
for(int j=0;j<=maze.c+2;j++){
printf("%4c",maze.arr[i][j]);//输出迷宫
}//for
printf("\n");
}//for
}//PrintMaze
void Initialization(){
system("cls");
printf("********************************************************");
printf("\n*CreatMaze--c MazePath--m PrintMaze--p Quit--q*");
printf("\n********************************************************");
}//Initialization
void ReadCommand(char &cmd){
do{
if(cmd=='c'||cmd=='C'){
printf("\n********************************************************");
printf("\n*Enter a operation :m或M *");
printf("\n*退出--Enter a operation :q或Q *");
printf("\n********************************************************");
}//if
else if(cmd=='m'||cmd=='M'){
printf("\n********************************************************");
printf("\n*Enter a operation :p或P *");
printf("\n*退出--Enter a operation :q或Q *");
printf("\n********************************************************");
}//else if
else if(cmd=='0'){
printf("\n********************************************************");
printf("\n*Enter a operation :c或P *");
printf("\n*退出--Enter a operation :q或Q *");
printf("\n********************************************************");
}
printf("\n\n Operration:-");
cmd=getchar();
}while(!(cmd=='c'||cmd=='C'||cmd=='m'||cmd=='M'||cmd=='p'||cmd=='P'||cmd=='q'||cmd=='Q'));
}//ReadCommand
void Interpre(char cmd){
//MazeType maze;//开始的时候定义在这个地方，不是全局的，调用出现了问题。
//PosType start;//开始的时候定义在这个地方，不是全局的，调用出现了问题。
//PosType end;//开始的时候定义在这个地方，不是全局的，调用出现了问题。
switch(cmd){
case 'C':
case 'c':{
int rnum, cnum, i=0,m=1,n=1;
char a2[MAXLEN][MAXLEN];
char input[1];
char data[100000];
printf("\n请输入迷宫数据文件名！\n");
//printf("go");
scanf("%s",input);
FILE *fp;
fp=fopen(input,"r");
//printf("go");
if(!fp){
printf("\n不能打开文件\n");
break;
}//if
//printf("go");
while(!feof(fp)){
fscanf(fp,"%s",&data[i]);
if(i==0){rnum=(int)data[i]-(int)'0';/*printf("%d",rnum);*/}
if(i==1){cnum=(int)data[i]-(int)'0';/*printf("%d",rnum);*/}
if(i>=2){
if(n>cnum){m++;n=1;}
a2[m][n]=data[i];
//printf("%d",a2[m][n]);
n++;
}//if
i++;
}//while
fclose(fp);
//printf("go");
InitMaze(maze, a2, rnum, cnum);
printf("\n迷宫建立完成！！\n");
//PrintMaze(maze);
break;
}//case
case 'M':
case 'm':{
printf("\n请输入迷宫入口的坐标，以空格为间隔:--");
scanf("%d %d",&start.r,&start.c);
printf("\n请输入迷宫出口的坐标，以空格为间隔:--");
scanf("%d %d",&end.r,&end.c);
//printf("%d,%d,%d,%d",start.r,start.c,end.r,end.c);
//PrintMaze(maze);
MazePath(maze, start, end);
//PrintMaze(maze);
break;
}//case
case 'P':
case 'p':{
if(found){
printf("\n求解迷宫的结果如下--\n");
PrintMaze(maze);
}//if
else{
printf("\n找不到路径！\n");
}//else
}//case
}//switch
}//Interpre
void main(){
char cmd='0';
Initialization();
//cmd=getchar();
do{
ReadCommand(cmd);
Interpre(cmd);
}while(cmd!='q'&&cmd!='Q');
}//main
Ⅲ 用c++写一个迷宫程序
#include<iostream>
using namespace std;
class T //定义描述迷宫中当前位置的结构类型
{
public:
int x; //x代表当前位置的行坐标
int y; //y代表当前位置的列坐标
int dir; //0:无效,1:东,2:南,3:西,4:北
};
class LinkNode //链表结点
{
friend class Stack;
public:
T data;
LinkNode *next;
};
class Stack
{
private:
LinkNode *top; //指向第一个结点的栈顶指针
public:
Stack(); //构造函数，置空栈
~Stack(); //析构函数
void Push(T e); //把元素data压入栈中
T Pop(); //使栈顶元素出栈
T GetPop(); //取出栈困蔽顶元素
void Clear(); //把栈清空
bool empty(); //判断栈是否为空，如果为空则返回1，否则返回0
};
Stack::Stack() //构造函数，置空栈
{
top=NULL;
}
Stack::~Stack() //析构函昌友数汪迅州
{
}
void Stack::Push(T e) //把元素x压入栈中
{
LinkNode *P;
P=new LinkNode;
P->data=e;
P->next=top;
top=P;
}
T Stack::Pop() //使栈顶元素出栈
{
T Temp;
LinkNode *P;
P=top;
top=top->next;
Temp=P->data;
delete P;
return Temp;
}
T Stack::GetPop() //取出栈顶元素
{
return top->data;
}
void Stack::Clear() //把栈清空
{
top=NULL;
}
bool Stack::empty() //判断栈是否为空，如果为空则返回1，否则返回0
{
if(top==NULL) return 1;
else return 0;
}
int move[4][2]={{0,1},{1,0},{0,-1},{-1,0}}; //定义当前位置移动的4个方向
bool Mazepath(int **maze,int m,int n);
//寻找迷宫maze中从（0，0）到（m,n）的路径
//到则返回true,否则返回false
void PrintPath(Stack p); //输出迷宫的路径
void Restore(int **maze,int m,int n); //恢复迷宫
int** GetMaze(int &m,int &n); //获取迷宫
//返回存取迷宫的二维指针
int main()
{
int m=0,n=0; //定义迷宫的长和宽
int **maze; //定义二维指针存取迷宫
maze=GetMaze(m,n); //调用GetMaze(int &m,int &n)函数，得到迷宫
if(Mazepath(maze,m,n)) //调用Mazepath(int **maze,int m,int n)函数获取路径
cout<<"迷宫路径探索成功!\n";
else cout<<"路径不存在!\n";
return 0;
}
int** GetMaze(int &m,int &n)//返回存取迷宫的二维指针
{
int **maze; //定义二维指针存取迷宫
int i=0,j=0;
cout<<"请输入迷宫的长和宽:";
int a,b;cin>>a>>b; //输入迷宫的长和宽
cout<<"请输入迷宫内容:\n";
m=a;
n=b; //m,n分别代表迷宫的行数和列数
maze=new int *[m+2]; //申请长度等于行数加2的二级指针
for(i= 0;i<m+2;i++) //申请每个二维指针的空间
{
maze[i]=new int[n+2];
}
for(i=1;i<=m;i++) //输入迷宫的内容，0代表可通，1代表不通
for(j=1;j<=n;j++)
cin>>maze[i][j];
for(i=0;i<m+2;i++)
maze[i][0]=maze[i][n+1]=1;
for(i=0;i<n+2;i++)
maze[0][i]=maze[m+1][i]=1;
return maze; //返回存贮迷宫的二维指针maze
};
bool Mazepath(int **maze,int m,int n)//寻找迷宫maze中从（0，0）到（m,n）的路径
//到则返回true,否则返回false
{
Stack q,p; //定义栈p、q,分别存探索迷宫的过程和存储路径
T Temp1,Temp2;
int x,y,loop;
Temp1.x=1;
Temp1.y=1;
q.Push(Temp1); //将入口位置入栈
p.Push(Temp1);
maze[1][1]=-1; //标志入口位置已到达过
while(!q.empty()) //栈q非空，则反复探索
{
Temp2=q.GetPop(); //获取栈顶元素
if(!(p.GetPop().x==q.GetPop().x&&p.GetPop().y==q.GetPop().y))
p.Push(Temp2);
//如果有新位置入栈，则把上一个探索的位置存入栈p
for(loop=0;loop<4;loop++) //探索当前位置的4个相邻位置
{
x=Temp2.x+move[loop][0]; //计算出新位置x位置值
y=Temp2.y+move[loop][1]; //计算出新位置y位置值
if(maze[x][y]==0) //判断新位置是否可达
{
Temp1.x=x;
Temp1.y=y;
maze[x][y]=-1; //标志新位置已到达过
q.Push(Temp1); //新位置入栈
}
if((x==(m))&&(y==(n))) //成功到达出口
{
Temp1.x=m;
Temp1.y=n;
Temp1.dir=0;
p.Push(Temp1); //把最后一个位置入栈
PrintPath(p); //输出路径
Restore(maze,m,n); //恢复路径
return 1; //表示成功找到路径
}
}
if(p.GetPop().x==q.GetPop().x&&p.GetPop().y==q.GetPop().y)
//如果没有新位置入栈，则返回到上一个位置
{
p.Pop();
q.Pop();
}
}
return 0; //表示查找失败，即迷宫无路经
}
void PrintPath(Stack p) //输出路径
{
cout<<"迷宫的路径为\n";
cout<<"括号内的内容分别表示为(行坐标,列坐标,数字化方向,方向)\n";
Stack t; //定义一个栈，按从入口到出口存取路径
int a,b;
T data;
LinkNode *temp;
temp=new LinkNode; //申请空间
temp->data=p.Pop(); //取栈p的顶点元素，即第一个位置
t.Push(temp->data); //第一个位置入栈t
delete temp; //释放空间
while(!p.empty()) //栈p非空，则反复转移
{
temp=new LinkNode;
temp->data=p.Pop(); //获取下一个位置
//得到行走方向
a=t.GetPop().x-temp->data.x; //行坐标方向
b=t.GetPop().y-temp->data.y; //列坐标方向
if(a==1) temp->data.dir=1; //方向向下，用1表示
else if(b==1) temp->data.dir=2; //方向向右，用2表示
else if(a==-1) temp->data.dir=3; //方向向上，用3表示
else if(b==-1) temp->data.dir=4; //方向向左，用4表示
t.Push(temp->data); //把新位置入栈
delete temp;
}
//输出路径，包括行坐标，列坐标，下一个位置方向
while(!t.empty()) //栈非空，继续输出
{
data=t.Pop();
cout<<'('<<data.x<<','<<data.y<<','<<data.dir<<","; //输出行坐标，列坐标
switch(data.dir) //输出相应的方向
{
case 1:cout<<"↓)\n";break;
case 2:cout<<"→)\n";break;
case 3:cout<<"↑)\n";break;
case 4:cout<<"←)\n";break;
case 0:cout<<")\n";break;
}
}
}
void Restore(int **maze,int m,int n) //恢复迷宫
{
int i,j;
for(i=0;i<m+2;i++) //遍历指针
for(j=0;j<n+2;j++)
{
if(maze[i][j]==-1) //恢复探索过位置，即把-1恢复为0
maze[i][j]=0;
}
}
示例输出：
测试1：
请输入迷宫的长和宽:5 5
请输入迷宫内容:
0 1 1 0 0
0 0 1 1 0
1 0 0 1 1
1 0 0 1 0
1 1 0 0 0
迷宫的路径为
括号内的内容分别表示为(行坐标,列坐标,数字化方向,方向)
(1,1,1,↓)
(2,1,2,→)
(2,2,1,↓)
(3,2,1,↓)
(4,2,2,→)
(4,3,1,↓)
(5,3,2,→)
(5,4,2,→)
(5,5,0,)
迷宫路径探索成功!
测试2：
请输入迷宫的长和宽:9 8
请输入迷宫内容:
0 0 1 0 0 0 1 0
0 0 1 0 0 0 1 0
0 0 0 0 1 1 0 1
0 1 1 1 0 0 1 0
0 0 0 1 0 0 0 0
0 1 0 0 0 1 0 1
0 1 1 1 1 0 0 1
1 1 0 0 0 1 0 1
1 1 0 0 0 0 0 0
迷宫的路径为
括号内的内容分别表示为(行坐标,列坐标,数字化方向,方向)
(1,1,1,↓)
(2,1,1,↓)
(3,1,1,↓)
(4,1,1,↓)
(5,1,2,→)
(5,2,2,→)
(5,3,1,↓)
(6,3,2,→)
(6,4,2,→)
(6,5,3,↑)
(5,5,2,→)
(5,6,2,→)
(5,7,1,↓)
(6,7,1,↓)
(7,7,1,↓)
(8,7,1,↓)
(9,7,2,→)
(9,8,0,)
迷宫路径探索成功!
Ⅳ 数据结构算法（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语言数据结构 老鼠走迷宫问题
/* 迷宫矩阵
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();
}
Ⅵ 数据结构迷宫问题，程序有错，请问下面的程序应该怎么修改，急！！！
php">#include<stdio.h>
#include物春<malloc.h>
#include<conio.h>
typedefstructpos/*描述迷宫当前位置和方向*/
{
intx;
inty;
intway;/*0:无效,1:左,2:下,3:右,4:上*/
}P;
typedefstructLinkNode/*链表结构,用于栈的元素类型*/
{
Ppos;
structLinkNode*next;
}LinkNode;
typedefstructstack/*链式栈,用于存储迷宫路径信息*/
{
LinkNode*head;/*头指针*/
}Stack;
introw=0;/*迷宫的行数*/
intline=0;/*迷宫的列数*/
voidInitStack(Stack*s)/*栈置空*/
{
s->head=NULL;
}
voidPush(Stack*s,Pp)/*数据入栈*/
{
LinkNode*LN=(LinkNode*)malloc(sizeof(LinkNode));
LN->pos=p;
LN->next=s->head;
s->head=LN;
}
PPop(Stack*s)/*栈顶元素出栈*/
{
Ppos;
LinkNode*LN;
LN=s->head;
s->head=s->head->next;
pos=LN->pos;
deleteLN;
returnpos;
}
PGetPop(Stacks)/*读取栈顶元素*/
{
returns.head->pos;
}
intEmpty(Stacks)/*判空*/
{
if(s.head==NULL)
return1;
else
return0;
}
int**InitMaze()/*返回迷宫的二维指针*/
{
int**maze=NULL;
inti;
intj;
printf("请输入迷宫的告唤行跟列(x,y):");
scanf("%d,%d",&row,&line);/*输入迷宫的行和列*/
maze=(int**)malloc((row+2)*sizeof(int*));
for(i=0;i<row+2;i++)
{
maze[i]=(int*)malloc(sizeof(int)*(line+2));
}
printf("请输入迷宫 ");/*输入迷宫,1代表路障,0代表通行*/
for(i=1;i<=row;i++)
for(j=1;j<=line;j++)
scanf("%d",&maze[i][j]);
for(i=0;i<line+2;i++)/*将迷宫的四周都变为1*/
maze[0][i]=1;
for(i=0;i<line+2;i++)
maze[row+1][i]=1;
for(i=0;i<row+2;i++)
maze[i][0]=1;
for(i=0;i<row+2;i++)
maze[i][line+1]=1;
for(i=0;i<row+2;i++)/*输出迷宫*/
{
for(j=0;j<line+2;j++)
printf("%3d",maze[i][j]);
printf(" ");
}
罩友耐returnmaze;
}
voidPrintWay(Stackp)/*输出路径*/
{
Ppos;
Stackt;/*临时栈,用于存储从入口到出口的路径*/
LinkNode*temp;
inta,b;
InitStack(&t);
temp=(LinkNode*)malloc(sizeof(LinkNode));
temp->pos=Pop(&p);/*取栈顶元素,即出口*/
Push(&t,temp->pos);/*入栈*/
free(temp);
while(!Empty(p))
{
temp=(LinkNode*)malloc(sizeof(LinkNode));
temp->pos=Pop(&p);/*获取下一个元素*/
a=GetPop(t).x-temp->pos.x;/*左:a=0,b=1;下:a=1,b=0*/
b=GetPop(t).y-temp->pos.y;/*右:a=0,b=-1上:a=-1,b=0;*/
if(b==1)
temp->pos.way=1;
elseif(a==1)
temp->pos.way=2;
elseif(b==-1)
temp->pos.way=3;
elseif(a==-1)
temp->pos.way=4;
Push(&t,temp->pos);/*新位置入栈*/
free(temp);
}
printf("迷宫的路径为: ");
printf("前两个数字表示位置,最后一个数字表示方向 ");
printf("1表示向左,2表示向下,3表示向右,4表示向上,0表示无方向 ");
while(!Empty(t))/*输出路径*/
{
pos=Pop(&t);
printf("%3d,%3d,%3d ",pos.x,pos.y,pos.way);
}
}
intFindMaze(int**maze,intr,intl)/*寻找路径,找到返回1,没找到返回0*/
{
Stackp,q;/*栈p,q分别表示探索迷宫的路径和过程*/
Ptemp1,temp2;
inta,b;
InitStack(&p);
InitStack(&q);
temp1.x=1;
temp1.y=1;//
maze[1][1]=-1;/*标记已经走过*/
Push(&p,temp1);
Push(&q,temp1);
while(!Empty(q))
{
temp2=GetPop(q);
if(!(GetPop(p).x==GetPop(q).x
&&GetPop(p).y==GetPop(q).y))
Push(&p,temp2);/*若有新元素入栈,就把q的栈顶元素存入p中*/
a=temp2.x;
b=temp2.y+1;/*当前位置左方向相邻的方块*/
if(maze[a][b]==0)
{
temp1.x=a;
temp1.y=b;
maze[a][b]=-1;/*标记已走过*/
Push(&q,temp1);
}
if(a==r&&b==l)/*到达出口*/
{
temp1.way=0;
Push(&p,temp1);
PrintWay(p);
return1;
}
a=temp2.x+1;
b=temp2.y;/*当前位置下方向相邻的方块*/
if(maze[a][b]==0)
{
temp1.x=a;
temp1.y=b;
maze[a][b]=-1;/*标记已走过*/
Push(&q,temp1);
}
if(a==r&&b==l)/*到达出口*/
{
temp1.way=0;
Push(&p,temp1);
PrintWay(p);
return1;
}
a=temp2.x;
b=temp2.y-1;/*当前位置右方向相邻的方块*/
if(maze[a][b]==0)
{
temp1.x=a;
temp1.y=b;
maze[a][b]=-1;/*标记已走过*/
Push(&q,temp1);
}
if(a==r&&b==l)/*到达出口*/
{
temp1.way=0;
Push(&p,temp1);
PrintWay(p);
return1;
}
a=temp2.x-1;
b=temp2.y;/*当前位置上方向相邻的方块*/
if(maze[a][b]==0)
{
temp1.x=a;
temp1.y=b;
maze[a][b]=-1;/*标记已走过*/
Push(&q,temp1);
}
if(a==r&&b==l)/*到达出口*/
{
temp1.way=0;
Push(&p,temp1);
PrintWay(p);
return1;
}
if(GetPop(p).x==GetPop(q).x
&&GetPop(p).y==GetPop(q).y)/*若四个方向都走不通,则数据出栈,退回一格*/
{
Pop(&p);
Pop(&q);
}
}
return0;/*探索迷宫失败*/
}
voidmain()
{
int**maze=InitMaze();/*初始化迷宫*/
if(FindMaze(maze,row,line))/*探索路径*/
printf("路径探索成功! ");
else
printf("路径探索失败! ");
getch();
}
Ⅶ c语言，用二维数组解决迷宫问题。来段完整的代码吧。
好的，以下是使用二维数组解决迷宫问题的C语言代码示例：
Copy code
#include <stdio.h>
#define ROW 6 // 迷宫行数
#define COL 6 // 迷宫列数
int maze[ROW][COL] = { // 迷宫地图 1表兄银碰示障碍，0表示通路
{1, 1, 1, 1, 1, 1},
{1, 0, 0, 1, 0, 1},
{1, 0, 0, 1, 0, 1},
{1, 0, 0, 0, 0, 1},
{1, 0, 1, 1, 0, 1},
{1, 1, 1, 1, 1, 1},
};
int result[ROW][COL]; // 存放走迷宫的结果
int dfs(int row, int col) {
if (row == ROW - 1 && col == COL - 1) { // 到达终点
result[row][col] = 1;
return 1;
}
if (maze[row][col] == 0) { // 当前位置是通路
result[row][col] = 1;
if (row < ROW - 1 && dfs(row + 1, col)) { // 向下走有解
return 1;
}
if (col < COL - 1 && dfs(row, col + 1)) { // 向右走有解
return 1;
}
result[row][col] = 0; // 标记走过的路
}
return 0; // 返回无解羡谈
}
void print_result() {
printf("走迷宫的结果：\n");
for (int i = 0; i < ROW; i++) {
for (int j = 0; j < COL; j++) {
printf("%d ", result[i][j]);
}
printf("\n");
}
}
int main() {
if (dfs(0, 0)) { // 从起点开始走迷宫
print_result();
} else {
printf("无法走出迷宫！\n");
}
return 0;
}
上述搏碰代码中，我们使用了一个二维数组 maze 来表示迷宫地图，其中 1 表示障碍，0 表示通路；另一个二维数组 result 用来存储走迷宫的结果，其中 1 表示该位置走通了， 0 表示该位置没有走通。
我们使用 dfs 函数来进行深度优先搜索，从起点 (0, 0) 开始往下、往右走，直到走到终点 (ROW-1, COL-1)，如果存在通路，则将路径标记在 result 数组中，并返回 1，否则返回 0 表示无解。
最后，我们在 main 函数中调用 dfs 函数，判断是否能从起点走出迷宫，如果有解，则输出走迷宫的结果；否则，输出 "无法走出迷宫" 的提示。