数据结构迷宫代码（迷宫程序数据结构）

本篇文章给大家谈谈数据结构迷宫代码，以及迷宫程序数据结构对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、迷宫C语言源程序代码
• 2、数据结构算法 用C++ 迷宫最短路径
• 3、数据结构迷宫问题（c语言）
• 4、如何用数据结构创建一个20×20的迷宫，用空格和星花表示路和墙，求代码，十分感谢
• 5、数据结构中，求解迷宫问题的程序算法，，，
• 6、数据结构算法（c语言） 迷宫求解

迷宫C语言源程序代码

#includestdio.h

#includemalloc.h

int N;

int **maze;

int zx,zy;

void PrintMaze(int N){

int *l[2],i,j;

l[0]=(int*)malloc(sizeof(l)*N*N);

l[1]=(int*)malloc(sizeof(l)*N*N);

for(i=0;iN*N;i++){

l[0][i]=-1;

}

for(i=0;iN;i++){

for(j=0;jN;j++){

if(maze[i][j]1){

l[0][maze[i][j]-2]=i;

l[1][maze[i][j]-2]=j;

}

}

}for(i=0;iN*N;i++){

if(l[0][i]!=-1)printf("(%d,%d)\n",l[0][i]+1,l[1][i]+1);

else break;

}

}int SelMaze(int x,int y){

if(x9||y9||x0||y0)return(0);

return(!maze[x][y]);

}int FindMaze(int x,int y,int m){

if(x==zxy==zy){

maze[x][y]=m;

return(1);

}

if(SelMaze(x+1,y)){

maze[x][y]=m;

if(FindMaze(x+1,y,m+1))PrintMaze(N);

maze[x][y]=0;

}if(SelMaze(x,y+1)){

maze[x][y]=m;

if(FindMaze(x,y+1,m+1))PrintMaze(N);

maze[x][y]=0;

}if(SelMaze(x,y-1)){

maze[x][y]=m;

if(FindMaze(x,y-1,m+1))PrintMaze(N);

maze[x][y]=0;

}if(SelMaze(x-1,y)){

maze[x][y]=m;

if(FindMaze(x-1,y,m+1))PrintMaze(N);

maze[x][y]=0;

}

return(0);

}

int main(){

int x,y,i,j;

scanf("%d\n%d%d%d%d",N,x,y,zx,zy);

zx--;zy--;x--;y--;

maze=(int**)malloc(sizeof(int*)*N);

for(i=0;iN;i++){

maze[i]=(int*)malloc(sizeof(maze)*N);

for(j=0;jN;j++){

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

}

}

if(!FindMaze(x,y,2))printf("No");

return(0);

}

数据结构算法 用C++ 迷宫最短路径

一般迷宫寻路可以用递归的算法，或者用先进后出的栈数据结构实现

用的是深度优先的算法，可以寻找到走出迷宫的路径

但本题要求求出最短的路径，这就要使用广度优先的算法

一般在程序中需要用到先进先出的队列数据结构

下面是程序的代码，主要原理是用到

quei，quej和prep三个数组来构成队列

分别储存路径的行，列坐标和上一个节点在队列中的位置

大致算法如下，右三个嵌套的循环实现

首先是第一个节点进入队列

当队列不空（循环1）

｛

   遍历队列中每节点(循环2）

｛

       将八个方向能够走的节点加入队列（循环3）

｝

   旧的节点出列

｝

#includeiostream

#includectime 

using namespace std; 

#define MAXNUM 50

void main() 

{

int m,n,i,j,x;

cout"请输入迷宫大小"endl;

cinmn;

int maze[MAXNUM][MAXNUM];

srand((int)time(NULL));

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

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

if(i==0||j==0||i==m+1||j==n+1)

maze[i][j]=1;

else

{

x=rand()%1000;

if(x700){maze[i][j]=1;} //控制矩阵中1的个数，太多1迷宫很容易走不通

else{maze[i][j]=0;}

}

coutmaze[i][j]' ';

}

coutendl;

}

//以上是输入和迷宫生成，一下是走迷宫

    int move[8][2]={0,1,1,0,0,-1,-1,0,1,1,-1,1,-1,-1,1,-1};

int *quei=new int[m*n];//储存行坐标队列

int *quej=new int[m*n];//储存列坐标队列

int *prep=new int[m*n];//储存之前一步在队列中的位置

int head,rear,length;//队列头，队列尾，队列长度

head=0;rear=1;length=1;

quei[head]=1;quej[head]=1;prep[head]=-1;//入口位置进队列

int pos;//当前节点在队列中的位置，

int ii,jj,ni,nj;//当前节点的坐标，新节点的坐标

int dir;//移动方向

if(maze[1][1]==1)length=0;//第一点就不能通过

else maze[1][1]=1;

while(length)//队列非空继续

{

for(pos=head;poshead+length;pos++)//寻找这一层所有节点

{

ii=quei[pos];jj=quej[pos];//当前位置坐标

if(ii==mjj==n)break;

for(dir=0;dir8;dir++)//寻找8个方向

{

ni=ii+move[dir][0];nj=jj+move[dir][1];//新坐标

if(maze[ni][nj]==0)//如果没有走过

{

quei[rear]=ni;quej[rear]=nj;prep[rear]=pos;//新节点入队

rear=rear+1;

maze[ni][nj]=1;//标记已经走过

}

}

}

if(ii==mjj==n)break;

head=head+length;

length=rear-head;//这一层节点出列

}

if(ii==mjj==n)

{

while(pos!=-1)

{

cout'('quei[pos]','quej[pos]')';

pos=prep[pos];

if (pos!=-1)cout',';

}

}

else

{

cout"THERE IS NO PATH."endl;

}

delete []quei;

delete []quej;

delete []prep;

}

数据结构迷宫问题（c语言）

#includestdio.h

#includestring.h

#includestdlib.h

#includetime.h

int m,n,num,map[101][101],f[101][101],a[101],b[101],d[2][4]={0,-1,0,1,-1,0,1,0},ans,flag;

void maze()

{

int i,j;

time_t t;

srand(time(t));

for(i=0;im;i++)

for(j=0;jn;j++)

{

map[i][j]=rand()%2;

if(map[i][j])

num++;

}

if(numm*n/2)

{

for(i=0;im;i++)

for(j=0;jn;j++)

if(!map[i][j])

map[i][j]+=rand()%2;

}

map[0][0]=1;

map[m-1][n-1]=1;

}

void print()

{

int i,j;

for(i=0;im;i++)

for(j=0;jn;j++)

{

printf("%d ",map[i][j]);

if(j==n-1)puts("");

}

}

void dfs(int x,int y)

{

int i,tx,ty;

if(!flag)

return;

for(i=0;i4;i++)

{

tx=x+d[0][i];

ty=y+d[1][i];

if(!f[tx][ty]tx=0ty=0txmtynmap[tx][ty])

{

f[tx][ty]=1;

a[ans]=tx;

b[ans++]=ty;

if(tx+ty==0)

{

printf("(%d,%d)\n",m,n);

for(flag=i=0;ians;i++)

printf("(%d,%d)\n",a[i]+1,b[i]+1);

return;

}

dfs(tx,ty);

f[tx][ty]=0;

ans--;

}

}

}

int main()

{

while(scanf("%d%d",m,n),m+n)

{

memset(f,0,sizeof(f));

num=ans=0;

flag=1;

maze();

print();

dfs(m-1,n-1);

if(flag)

puts("There is no path");

}

return 0;

}

如何用数据结构创建一个20×20的迷宫，用空格和星花表示路和墙，求代码，十分感谢

如图是我修改他人代码得到的。因为C画面的墙和路都要占同样1格。

如果画偶数宽高则会有路径浪费，所以还是画奇数宽高的好。

部分代码如下:(完整代码请追问)

int main()

{

    int i,j;

    system("color 2b");

 srand((unsigned)time(NULL));  /*初始化随即种子*/

 hidden();    /*隐藏光标*/

 for(i=0;i=Height+1;i++)

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

   if(i==0||i==Height+1||j==0||j==Width+1)   /*初始化迷宫*/

map[i][j]=Road;

   else map[i][j]=Wall;

 create(2*(rand()%(Height/2)+1),2*(rand()%(Width/2)+1));  /*从随机一个点开始生成迷宫*/

 for(i=0;i=Height+1;i++)    /*边界处理*/

 {

  map[i][0]=Wall;            

  map[i][Width+1]=Wall;   

 }

 for(j=0;j=Width+1;j++)   /*边界处理*/

 {

  map[0][j]=Wall;     

  map[Height+1][j]=Wall;

 }

//★百度知道“q839219286”修订，多画一格避免宽高为偶数时没有墙

 { int pH_even= (Height/2)*2, pW_even=(Width/2)*2; //宽高偶数化

    map[2][1]=Start;     /*给定入口*/

map[pH_even][Width]=End;   /*给定出口*/

for(i=1;i=pH_even+1;i++)  /*画出迷宫*/

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

paint(i,j);

 }

    game();   /*开始游戏*/

 return 0;

}

数据结构中，求解迷宫问题的程序算法，，，

// test_03.cpp : 定义控制台应用程序的入口点。

//

#include "stdafx.h"

#includeiostream

using namespace std;

struct PosType /* 迷宫坐标位置类型 */

{

int x; /* 行值 */

int y; /* 列值 */

};

int Maze[5][5] =

{

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

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

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

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

{0, 0, 0, 0, 0}

};

#define MAXLENGTH 5

int curstep=1;

int a[MAXLENGTH];

int b[MAXLENGTH];

struct SElemType/* 栈的元素类型 */

{

int ord; /* 通道块在路径上的＂序号＂ */

PosType seat; /* 通道块在迷宫中的＂坐标位置＂ */

int di; /* 从此通道块走向下一通道块的＂方向＂(0～3表示东～北) */

};

#define STACK_INIT_SIZE 10 /* 存储空间初始分配量 */

#define STACKINCREMENT 2 /* 存储空间分配增量 */

struct SqStack //SqStack

{

SElemType *base; /* 在栈构造之前和销毁之后，base的值为NULL */

SElemType *top; /* 栈顶指针 */

int stacksize; /* 当前已分配的存储空间，以元素为单位 */

}; /* 顺序栈 */

bool InitStack(SqStack *S)

{ /* 构造一个空栈S */

(*S).base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));

if(!(*S).base)

{

exit(1); /* 存储分配失败 */

}

(*S).top=(*S).base;

(*S).stacksize=STACK_INIT_SIZE;

return true;

}

bool Push(SqStack *S,SElemType e)

{ /* 插入元素e为新的栈顶元素 */

if((*S).top-(*S).base=(*S).stacksize) /* 栈满，追加存储空间 */

{

(*S).base=(SElemType *)realloc((*S).base,((*S).stacksize+STACKINCREMENT)*sizeof(SElemType));

if(!(*S).base)

{

exit(1); /* 存储分配失败 */

}

(*S).top=(*S).base+(*S).stacksize;

(*S).stacksize+=STACKINCREMENT;

}

*((*S).top)++=e;

return true;

}

bool StackEmpty(SqStack S)

{ /* 若栈S为空栈，则返回TRUE，否则返回FALSE */

if(S.top==S.base)

return true;

else

return false;

}

bool Pop(SqStack *S,SElemType *e)

{ /* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */

if((*S).top==(*S).base)

return false;

*e=*(--(*S).top);

return true;

}

bool Pass(PosType b)

{ /* 当迷宫m的b点的序号为1(可通过路径)，return true, 否则，return false */

if(Maze[b.x][b.y]==1)

return true;

else

return false;

}

void FootPrint(PosType a)

{ /* 使迷宫m的a点的序号变为足迹(curstep) */

Maze[a.x][a.y]=curstep;

}

PosType NextPos(PosType c,int di)

{ /* 根据当前位置及移动方向，返回下一位置 */

PosType direc[4]={{0,1},{1,0},{-1,0},{0,-1}};

/* 移动方向,依次为东南西北 */

c.x+=direc[di].x;

c.y+=direc[di].y;

return c;

}

void MarkPrint(PosType b)

{ /* 使迷宫m的b点的序号变为-1(不能通过的路径) */

Maze[b.x][b.y]=-1;

}

void Print(int x,int y)

{ /* 输出迷宫的解 */

int i,j;

for(i=0;ix;i++)

{

for(j=0;jy;j++)

cout"\t"Maze[i][j];

coutendl;

}

}

bool MazePath(PosType start,PosType end)

{

SqStack S;

SElemType e;

InitStack(S);

a[0]=start.x;

b[0]=start.y;

PosType curpos=start;

do

{

if(Pass(curpos))

{ /* 当前位置可以通过，即是未曾走到过的通道块 */

FootPrint(curpos); /* 留下足迹 */

a[curstep]=curpos.x;

b[curstep]=curpos.y;

e.di=0;

e.ord=curstep;

e.seat.x=curpos.x;

e.seat.y=curpos.y;

Push(S,e);

// printf("PUSH1 %d,%d,%d,%d \n",e.seat.x,e.seat.y,e.di,e.ord);

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

return true;

curpos=NextPos(curpos,e.di);

curstep++;

}

else

{ /* 当前位置不能通过 */

if(!StackEmpty(S))

{

Pop(S,e); /* 退栈到前一位置 */

// printf("POP1 %d,%d,%d,%d \n",e.seat.x,e.seat.y,e.di,e.ord);

curstep--;

while((e.di==3) (!StackEmpty(S)))

{

MarkPrint(e.seat);

Pop(S,e);

printf("POP2 %d,%d,%d,%d \n",e.seat.x,e.seat.y,e.di,e.ord);

curstep--;

}

if(e.di3) /* 没到最后一个方向(北) */

{

e.di++;

// e.seat.x=curpos.x;

// e.seat.y=curpos.y;

Push(S,e);

// printf("PUSH2 %d,%d,%d,%d \n",e.seat.x,e.seat.y,e.di,e.ord);

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

curstep++;

}

}

}

}while(!StackEmpty(S));

return false;

}

int _tmain(int argc, _TCHAR* argv[])

{

PosType begin,end;

begin.x = 1;

begin.y = 1;

end.x = 3;

end.y = 3;

if(MazePath(begin,end)) /* 求得一条通路 */

{

cout"此迷宫从入口到出口的一条路径如下:"endl;

Print(5,5); /* 输出此通路 */

for(int i=1;icurstep;i++)

{

cout"("a[i]","b[i]")""-";

}

cout"("a[curstep]","b[curstep]")"endl;

}

else

{

cout"此迷宫没有从入口到出口的路径"endl;

}

system("pause");

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");

}

测试数据，算法复杂度你就自己来写吧，如果你连这都不自己做，那你一定是在应付作业。劝你还是自己运行测试一下吧，免得答辩时老师问你，什么都不知道，那你就悲剧了。祝你好运！！

关于数据结构迷宫代码和迷宫程序数据结构的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。