数据结构课程设计的迷宫问题为什么要运用队和栈呢

看下我的程序,,要不是你要的.

#include <iostream>

#include <iomanip>

using namespace std

#define M 20

#define N 20

struct move{int dx,dy}

move mazemove[8]

char ma[M][N]

int False=0

void maze()

{int i,j,num

for(i=1i<M-1i++)

{for(j=1j<N-1j++)

{num=(800*(i+j)+1500)%327

if((num<156)&&(i!=M||j!=N))

ma[i][j]='1'

else

ma[i][j]='0'

}

}

ma[1][1]='0'

ma[M-2][N-2]='0'

for(i=0i<Mi++)

{for(j=0j<Nj++)

cout<<setw(3)<<ma[i][j]

cout<<endl

}

}

void inimove()

{mazemove[0].dx=0mazemove[0].dy=1

mazemove[1].dx=1mazemove[1].dy=1

mazemove[2].dx=1mazemove[2].dy=0

mazemove[3].dx=1mazemove[3].dy=-1

mazemove[4].dx=0mazemove[4].dy=-1

mazemove[5].dx=-1mazemove[5].dy=-1

mazemove[6].dx=-1mazemove[6].dy=0

mazemove[7].dx=-1mazemove[7].dy=1

}

void outpath()

{int i,j,x,y,k

i=1j=1k=0

while((i!=(M-2))||(j!=(N-2)))

{for(k=0k<8k++)

{x=i+mazemove[k].dx

y=j+mazemove[k].dy

if(ma[x][y]=='0'){k=0break}

}

if(k!=8)

{if(ma[i][j]=='8')ma[i][j]='2'

if(ma[i][j]=='0')ma[i][j]='>'

i=xj=y

}

else

{for(k=0k<8k++)

{x=i+mazemove[k].dx

y=j+mazemove[k].dy

if(ma[x][y]=='8')break

}

ma[i][j]='2'

i=xj=y

}

if((i==1)&&(j==1))

{False=0

break

}

else False=1

}

}

int main()

{int i,j

maze()

inimove()

outpath()

cout<<endl

if(False==0)

cout<<"无法走出该迷宫!"<<endl

else

{cout<<"走出迷宫的路径(用‘>’符号表示)为:"<<endl

ma[M-2][N-2]='>'

for(i=0i<Mi++)

{for(j=0j<Nj++)

{ {if(ma[i][j]=='2')ma[i][j]='>'

if(ma[i][j]=='0')ma[i][j]=' '

if(ma[i][j]=='1')ma[i][j]='*'

}

cout<<setw(3)<<ma[i][j]

}

cout<<endl

}

}

return 0

}

2、墙不可穿过代表，墙与周围的格子没有边。

3、规定一个时间t，若在t步之内没有走到粮仓，则输出无解。

4、这个简单，无非就是修改条件，从而修改整个图。

5、所用路径可以用深搜（回朔）来解决，最短路就用广搜来解决。最短路也可以用Dijstra算法、floyd算法等，但广搜是最简单的。

具体的程序你自己实现吧，如果写不出来，就去请教一下你们学校的ACMer，他们应该会比较熟悉。加油吧。

不是给你说风凉话，只是给你说句实话，真的，在这里别抱这么大幻想的

确实需要，而自己又真的不会的话，实在找不到，就去花钱找人帮你吧

这是我们老师给我们上数据结构课的课件

#include "stdio.h"

typedef int datatype

#define maxsize 1024

# define n 100

typedef char VEXTYPE

typedef float ADJTYPE

typedef struct

{ VEXTYPE vexs[n]

ADJTYPE arcs[n][n]

int num

}GRAPH

void GraphInit(GRAPH *L)

{

L->num=0

}

int GraphVexs(GRAPH *L)

{

return(L->num)

}

void GraphCreate(GRAPH *L)

{

int i,j

GraphInit(L)

printf("请输入顶点数目：")

scanf("%d",&L->num)

printf("请输入各顶点的信息(单个符号）：")

for(i=0i<L->numi++)

{

fflush(stdin)

scanf("%c",&L->vexs[i])

}

printf("请输入边权矩阵的信息：")

for(i=0i<L->numi++)

{

for(j=0j<L->numj++)

{

scanf("%f",&L->arcs[i][j])

}

}

printf("图已经创建完毕！")

}

void GraphOut(GRAPH L)

{

int i,j

printf("\n图的顶点数目为：%d",L.num)

printf("\n图的各顶点的信息为：\n")

for(i=0i<L.numi++)

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

printf("\n图的边权矩阵的信息为：\n")

for(i=0i<L.numi++)

{

for(j=0j<L.numj++)

{

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

}

printf("\n")

}

printf("图已经输出完毕！")

}

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

//从第qidian个点出发深度优先周游图g中能访问的各个顶点

{

int v1

mark[qidian]=1

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

for(v1=0v1<g.numv1++)

{

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

DFS(g,v1,mark)

}

}

void GraphDFS(GRAPH g)

//深度优先周游图g中能访问的各个顶点

{

int qidian,v,v1,mark[maxsize]

printf("\n深度周游：")

printf("\n请输入起点的下标：")

scanf("%d",&qidian)

for(v=0v<g.numv++)

{

mark[v]=0

}

for(v=qidianv<g.num+qidianv++)

{

//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

}

}

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=0v2<g.numv2++)

{

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

{

QueueIn(&q,v2)

mark[v2]=1

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

}

}

}

}

void GraphBFS(GRAPH g)

//深度优先周游图g中能访问的各个顶点

{

int qidian,v,v1,mark[maxsize]

printf("\n广度周游：")

printf("\n请输入起点的下标：")

scanf("%d",&qidian)

for(v=0v<g.numv++)

{

mark[v]=0

}

for(v=qidianv<g.num+qidianv++)

{

v1=v%g.num

if(mark[v1]==0)

BFS(g,v1,mark)

}

}

void main()

{

GRAPH tu

GraphCreate(&tu)

GraphOut(tu)

GraphDFS(tu)

GraphBFS(tu)

}

迷宫类算法，用栈，队列来做。不过一般来队列，因为队列能够在较短时间内求出最短路径。

在网上搜下，很多的。。

你的要求很难达到。。。

（2）可以随意选择玩家的初始位置，也可以由计算机随机选择（在菜单中选择）。

（3）记录玩家的旅行记录，即每一次迷宫的碰壁次数，用了多少步走出迷宫等。

（4）设定悔步功能，即按指定键（自定）可以悔一步，连带的这一步的记录也将一并删除。