一、c语言程序设计 迷宫问题

海龟作图行不。这是我大一时的C语言课程设计，我自已做的。

高级级语言课程设计实验报告

实验课程：课程设计年级：2004级实验成绩：

课程设计名称海龟作图姓名：

任课教师：学号：2004810025实验日期：

一、目的

通过编一些小程序，巩固和利用所学的知识，加强变成能力。

本课题涉及的知识内容：for循环嵌套，if语句，二维数组，文件创建与保存，自定义函数等高级语言内容。

二、内容与设计思想

1．设计内容

海龟爬行过程中，笔朝下纪录海龟爬行踪迹，笔朝上则不纪录并保存踪迹，

1表示笔朝上，2表示朝下，3右转弯，4左转弯，5，x向前走x格，6打印

9结束

2．主要代码结构

main()函数调用了两个函数

3．主要代码段分析。

譬如print函数，打印海龟踪迹并保存。Step函数当笔朝上时海龟走过的数组值加一

三、使用环境

本次上机实践所使用的平台和相关软件。

平台：Windows 2000

相关软件：VC++

四、调试过程

1．测试结果分析

经检验，运行结果正确

五、总结

1．设计中遇到的问题及解决过程

调试过程中出现一些逻辑和语法错误，但是语法错误容易纠正，而

逻辑错误则比较难纠正。有时会漏掉“，”，“;”，“}”等符号

2．设计体会和收获。

发现自己也能解决有点复杂的问题

六、附录

1．源代码

/*海龟作图，活动区域50*50，超出区域，海龟死亡游戏完*/

#include

void print(int [][49]);

void move(int [][49],int,int,int);

main()

{

int step[49][49];

int a,gostep,direct=1,record=1,i,j;

for(i=0;i<=49;i++)

for(j=0;j<=49;j++)

step[i][j]=0;

while(1)

{

scanf("%d,%d",&a,&gostep);

if(a==2) record=1;

if(a==1) record=0;

if(a==4)

{

direct++;

if(direct==5) direct=1;

continue;

}

if(a==3)

{

direct--;

if(direct==0) direct=4;

continue;

}

if(a==5)

{

move(step,gostep,direct,record);

continue;

}

if(a==6)

print(step);

if(a==9)

return 0;

}

}

/*打印海龟踪迹并保存*/

void print(int s[][49])

{

int i,j;

FILE*fp;

fp=fopen("D:\\step.txt","w");

for(i=0;i<=49;i++)

{

for(j=0;j<=49;j++)

{

printf(s[i][j]==0?"":"*");

fprintf(fp,s[i][j]==0?"":"*");

}

printf("\n");

}

fclose(fp);

}

void move(int t[][49],int i,int j,int k)

{

static int x=0,y=0;

int xmove,ymove,num;

if(j==1)

{

xmove=1;ymove=0;}

if(j==2)

{

xmove=0;ymove=-1;

}

if(j==3)

{

xmove=-1;ymove=0;

}

if(j==4)

{

xmove=0;ymove=1;

}

for(num=0;num

{

t[0][0]=1;

x+=xmove;

y+=ymove;

if(x<0||x>49||y<0||y>49)

{

printf("the place is danger,you are died");

exit();

}

t[y][x]+=k;

}

}

二、c语言,用二维数组解决迷宫问题。来段完整的代码吧。

好的，以下是使用二维数组解决迷宫问题的C语言代码示例：

Copy code

#include

#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函数，判断是否能从起点走出迷宫，如果有解，则输出走迷宫的结果；否则，输出"无法走出迷宫"的提示。

三、c语言做的迷宫问题

#include

#include

#includestruct node

{

int sign;//标识,0什么都不在,1在open中,2在closed中

int flag;//标志位 0/1,0可以走,1不可以走

int f,g,h;//判断函数

int x,y;//坐标

int old;//是否old节点,0非,1是

};struct link

{

node fnode;

link*next;

link*pri;

};link*open,*closed,*bestnode,*successor,*p,*q,*r,*s;int maze_flag[7][7]={{0,1,0,0,0,0,0},

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

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

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

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

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

{0,0,0,0,0,1,0}};//表示迷宫的数组,0可以走,1不可以走node maze[7][7];int judge(node n)//判断函数,判断n节点是否可以走

{

if(n.flag==1)

return(1);

else

return(0);

}void in_open(node n)//将n节点放入open表

{

p=open;

while(p->next!=open)

{

if(n.f>=p->fnode.f)

{

p->next->pri=(link*)malloc(sizeof(link));

p->next->pri->pri=p;

p=p->next;

p->pri->next=p;

p->pri->pri->next=p->pri;

p=p->pri;

p->fnode.flag=n.flag;

p->fnode.f=n.f;

p->fnode.g=n.g;

p->fnode.h=n.h;

p->fnode.x=n.x;

p->fnode.y=n.y;

p->fnode.old=n.old;

p->fnode.sign=n.sign=1;

}

else

p=p->next;

}

open->pri=(link*)malloc(sizeof(link));

open->pri->pri=p;

open->pri->next=open;

p->next=open->pri;

p=p->next;

p->fnode.flag=n.flag;

p->fnode.f=n.f;

p->fnode.g=n.g;

p->fnode.h=n.h;

p->fnode.x=n.x;

p->fnode.y=n.y;

p->fnode.old=n.old;

p->fnode.sign=n.sign=1;

}void out_open(node n)//将n节点从open表中移出

{

p=open;

while(p->next!=open)

{

if(n.f=p->fnode.f)

{

link*p1;

p1=p->next;

p->next=p->next->next;

p->next->pri=p;

free(p1);

n.sign=0;

}

else

p=p->next;

}

}void in_closed(node n)//将n节点放入closed表

{

while(q->next!=closed)

{

if(n.f>=q->fnode.f)

{

q->next->pri=(link*)malloc(sizeof(link));

q->next->pri->pri=q;

q=q->next;

q->pri->next=p;

q->pri->pri->next=q->pri;

q=q->pri;

q->fnode.flag=n.flag;

q->fnode.f=n.f;

q->fnode.g=n.g;

q->fnode.h=n.h;

q->fnode.x=n.x;

q->fnode.y=n.y;

q->fnode.old=n.old;

q->fnode.sign=n.sign=2;

}

else

q=q->next;

}

closed->pri=(link*)malloc(sizeof(link));

closed->pri->pri=q;

closed->pri->next=closed;

q->next=closed->pri;

q=q->next;

q->fnode.flag=n.flag;

q->fnode.f=n.f;

q->fnode.g=n.g;

q->fnode.h=n.h;

q->fnode.x=n.x;

q->fnode.y=n.y;

q->fnode.old=n.old;

q->fnode.sign=n.sign=2;

}void out_closed(node n)//将n节点从closed表中移出

{

q=closed;

while(q->next!=closed)

{

if(n.f=q->fnode.f)

{

link*q1;

q1=q->next;

q->next=q->next->next;

q->next->pri=q;

free(q1);

n.sign=0;

}

else

q=q->next;

}

}void in_bestnode(node n)//将n节点设为bestnode节点

{

while(r->next!=bestnode)

{

if(n.f>=r->fnode.f)

{

r->next->pri=(link*)malloc(sizeof(link));

r->next->pri->pri=r;

r=r->next;

r->pri->next=r;

r->pri->pri->next=r->pri;

r=r->pri;

r->fnode.flag=n.flag;

r->fnode.f=n.f;

r->fnode.g=n.g;

r->fnode.h=n.h;

r->fnode.x=n.x;

r->fnode.y=n.y;

r->fnode.old=n.old;

}

else

r=r->next;

}

bestnode->pri=(link*)malloc(sizeof(link));

bestnode->pri->pri=r;

bestnode->pri->next=bestnode;

r->next=bestnode->pri;

r=r->next;

r->fnode.flag=n.flag;

r->fnode.f=n.f;

r->fnode.g=n.g;

r->fnode.h=n.h;

r->fnode.x=n.x;

r->fnode.y=n.y;

r->fnode.old=n.old;

}void out_bestnode(node n)//将n节点的bestnode去掉

{

r=bestnode;

while(r->next!=bestnode)

{

if(n.f=p->fnode.f)

{

link*r1;

r1=r->next;

r->next=r->next->next;

r->next->pri=r;

free(r1);

}

else

r=r->next;

}

}void in_successor(node n)//将n节点设置为successor节点

{

s=successor;

while(s->next!=successor)

{

if(n.f>=s->fnode.f)

{

s->next->pri=(link*)malloc(sizeof(link));

s->next->pri->pri=s;

s=p->next;

s->pri->next=s;

s->pri->pri->next=s->pri;

s=s->pri;

s->fnode.flag=n.flag;

s->fnode.f=n.f;

s->fnode.g=n.g;

s->fnode.h=n.h;

s->fnode.x=n.x;

s->fnode.y=n.y;

s->fnode.old=n.old;

}

else

s=s->next;

}

successor->pri=(link*)malloc(sizeof(link));

successor->pri->pri=s;

successor->pri->next=successor;

s->next=successor->pri;

s=s->next;

s->fnode.flag=n.flag;

s->fnode.f=n.f;

s->fnode.g=n.g;

s->fnode.h=n.h;

s->fnode.x=n.x;

s->fnode.y=n.y;

s->fnode.old=n.old;

}void out_successor(node n)//将n节点的successor去掉

{

s=successor;

while(s->next!=successor)

{

if(n.f=p->fnode.f)

{

link*s1;

s1=s->next;

s->next=s->next->next;

s->next->pri=s;

free(s1);

}

else

s=s->next;

}

}void print(link*n)//输出link类型的表n

{

link*forprint;

forprint=n;

printf("the key is");

while(forprint->next!=n)

printf("(%d,%d)\n",forprint->fnode.x,forprint->fnode.y);

}int main()

{

//初始化部分

//这部分的功能是将二维的整形数组赋值给node型的二维数组

int i=0,j=0;

for(i=0;i<7;i++)

for(j=0;j<7;j++)

{

maze[i][j].x=i;

maze[i][j].y=j;

maze[i][j].flag=maze_flag[i][j];

if(maze[i][j].flag==0)

{

maze[i][j].h=6-i+6-j;

maze[i][j].sign=maze[i][j].f=maze[i][j].g=maze[i][j].old=0;

}

else

maze[i][j].h=-1;

}

for(i=0;i<7;i++)//输出迷宫示意图

{

for(j=0;j<7;j++)

{

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

}

printf("\n");

}

//这部分的功能是将open,closed,bestnode表初始化,都置为空表

p=open=(link*)malloc(sizeof(link));

open->next=open;

open->pri=open;

q=closed=(link*)malloc(sizeof(link));

closed->next=closed;

closed->pri=closed;

r=bestnode=(link*)malloc(sizeof(link));

bestnode->next=bestnode;

bestnode->pri=bestnode;

//将第一个元素即(0,0)节点放入open表,开始算法

in_open(maze[0][0]);

maze[0][0].f=maze[0][0].h;

link*s2;

s2=successor;

if(open->next!=open)//open表为空时则失败退出

{

while(1)

{

in_bestnode(open->fnode);//将open表的第一个元素放入bestnode中

in_closed(maze[open->fnode.x][open->fnode.y]);//将open表的第一个元素放入closed中

maze[open->fnode.x][open->fnode.y].g++;//将open表的第一个元素的g值加一,表示已经走了一步

out_open(maze[open->fnode.x][open->fnode.y]);//将open表的第一个元素删除 if(bestnode->fnode.x==6&&bestnode->fnode.y==6)//若bestnode是目标节点,则成功退出

{

printf("succes!!\nthen print the key:\n");

print(closed);

break;

}

else//若bestnode不是目标节点,则扩展其临近可以走的节点为successor

{

if(i==0||j==0||i==6||j==6)

{

if(i==0&&j==0)//若为(0,0),则判断右边和下边的元素

{

if(judge(maze[i][j+1])==0)

in_successor(maze[i][j+1]);

if(judge(maze[i+1][j])==0)

in_successor(maze[i+1][j]);

}

else if(i==0&&j==6)//若为(0,6),则判断左边和下边的元素

{

if(judge(maze[i-1][j])==0)

in_successor(maze[i-1][j]);

if(judge(maze[i+1][j])==0)

in_successor(maze[i+1][j]);

}

else if(i==6&&j==0)//若为(6,0),则判断左边和上边的元素

{

if(judge(maze[i-1][j])==0)

in_successor(maze[i-1][j]);

if(judge(maze[i][j-1])==0)

in_successor(maze[i][j-1]);

}

else if(i==6&&j==6)//若为(6,6),则判断左边和上边的元素

{

if(judge(maze[i-1][j])==0)

in_successor(maze[i-1][j]);

if(judge(maze[i][j-1])==0)

in_successor(maze[i][j-1]);

}

else if(i==0)//若为第一行的元素(不在角上),则判断左边,下边和右边

{

if(judge(maze[i][j+1])==0)

in_successor(maze[i][j+1]);

if(judge(maze[i][j-1])==0)

in_successor(maze[i][j-1]);

if(judge(maze[i+1][j])==0)

in_successor(maze[i+1][j]);

}

else if(i==6)//若为第七行的元素(不在角上),则判断左边,上边和右边

{

if(judge(maze[i][j+1])==0)

in_successor(maze[i][j+1]);

if(judge(maze[i][j-1])==0)

in_successor(maze[i][j-1]);

if(judge(maze[i-1][j])==0)

in_successor(maze[i-1][j]);

}

else if(j==0)//若为第一列的元素(不在角上),则判断右边,下边和上边

{

if(judge(maze[i+1][j])==0)

in_successor(maze[i+1][j]);

if(judge(maze[i-1][j])==0)

in_successor(maze[i-1][j]);

if(judge(maze[i][j+1])==0)

in_successor(maze[i][j+1]);

}

else if(j==6)//若为第七列的元素(不在角上),则判断左边,上边和上边

{

if(judge(maze[i+1][j])==0)

in_successor(maze[i+1][j]);

if(judge(maze[i-1][j])==0)

in_successor(maze[i-1][j]);

if(judge(maze[i][j-1])==0)

in_successor(maze[i][j-1]);

}

}

else//若为中将的元素,则判断四个方向的节点

{

if(judge(maze[i][j-1])==0)

in_successor(maze[i][j-1]);

if(judge(maze[i][j+1])==0)

in_successor(maze[i][j+1]);

if(judge(maze[i-1][j])==0)

in_successor(maze[i-1][j]);

if(judge(maze[i+1][j])==0)

in_successor(maze[i+1][j]);

}

}

while(s2->next!=successor)//对所有的successor节点进行下列操作

{

maze[s2->fnode.x][s2->fnode.y].g=bestnode->fnode.g+bestnode->fnode.h;//计算g(suc)=g(bes)+h(bes,suc)

if(s2->fnode.sign==1)//若在open表中,则置为old,记下较小的g,并从open表中移出,放入closed表中

{

s2->fnode.old=1;

if(s2->fnode.gfnode.x][s2->fnode.y].g)

{

maze[s2->fnode.x][s2->fnode.y].g=s2->fnode.g;

maze[s2->fnode.x][s2->fnode.y].f=maze[s2->fnode.x][s2->fnode.y].g+maze[s2->fnode.x][s2->fnode.y].h;

out_open(maze[s2->fnode.x][s2->fnode.y]);

in_closed(maze[s2->fnode.x][s2->fnode.y]);

maze[s2->fnode.x][s2->fnode.y].old=0;

}

else

continue;

}

else if(s2->fnode.sign==2)//若在closed表中,则置为old,记下较小的g,并将old从closed表中移出,将较小的g的节点放入closed表中

{

s2->fnode.old=1;

if(s2->fnode.gfnode.x][s2->fnode.y].g)

{

maze[s2->fnode.x][s2->fnode.y].g=s2->fnode.g;

maze[s2->fnode.x][s2->fnode.y].f=maze[s2->fnode.x][s2->fnode.y].g+maze[s2->fnode.x][s2->fnode.y].h;

out_closed(maze[s2->fnode.x][s2->fnode.y]);

in_closed(maze[s2->fnode.x][s2->fnode.y]);

maze[s2->fnode.x][s2->fnode.y].old=0;

}

else

continue;

}

else//若即不再open表中也不在closed表中,则将此节点放入open表中,并计算此节点的f值

{

in_open(maze[s2->fnode.x][s2->fnode.y]);

maze[s2->fnode.x][s2->fnode.y].f=maze[s2->fnode.x][s2->fnode.y].g+maze[s2->fnode.x][s2->fnode.y].h;

}

s2=s2->next;

}

s2=successor;

}

}

else

printf("error!!This maze does not have the answer!");

return(0);

}