程序2.1:非递归方法实现迷宫

重新编玩上一程序，想把以前学的迷宫又实现了一遍， 只不过这次编的感受很不同。

这个程序为前述迷宫的非递归实现，是在将前述栈实现的基础上进行少许更改实现的(此处的更改也即上述程序的一些不足)

问题： C语言中传送二位数组的方式. 开始一直出错，最后经测试格式应为 char array[][agru]; //agru为数组的列数

//迷宫的实现方式如下

//主程序

/*
*	文件名: main.cpp
*	功能: 主函数检测实现结果
*	作者: shaofeng5000
*	时间: 2011/4/3
*/
////////////////////////////////////////
#include <stdio.h>
#include "stack.h"
#include "maze.h"

//迷宫矩阵
char maze[15][15];

int main()
{
//创建用来存放路径的栈
PSTACK path;
path = STACK_Create();
if (NULL == path)
{
printf("迷宫初始化失败!");
}
//迷宫大小选定
//初始默认为12 此处固定为12是为了简化测试
int n;
n = 12;

//初始化迷宫，此处迷宫是由文件读入
int i, j;
char ch;
FILE *file = fopen("maze.txt", "r");
if (NULL == file)
{
printf("迷宫初始化失败!");
return 0;
}
for (i = 0; i < n; i++)
{
for (j = 0; j < n; j++)
{
fread(&maze[i][j], 1, 1, file);
}
fread(&ch, 1, 1, file);	//换行符
}

//打印原始迷宫迷宫
for (i = 0; i < n; i++)
{
for (j = 0; j < n; j++)
{
printf("%c ", maze[i][j]);
}
printf("/n");
}

//查找迷宫路径(本测试程序的主题部分)
MAZENODE curNode;	//栈中路径顶的节点
MAZENODE nextNode;	//栈顶节点的试探信息
//让入口位置入栈
curNode.dir = RIGHT;
curNode.i = 1;
curNode.j = 0;
maze[1][0] = SEEK;	//将迷宫此处改为已找到路径
STACK_Push(path, curNode);	//压入栈中

BOOL bPath = FALSE;		//试探方向是否为可走路径
BOOL bNew = TRUE;	//位置是否为第一次到达
BOOL bFind = FALSE;	//是否找到路径
while (TRUE)
{
if (TRUE == bNew)	//第一次到达位置初始化试探方向
{
BeginStepDir(curNode, &nextNode);
}
else	//转入下一方向
{
NextStepDir(curNode, &nextNode);
}

bPath = CheckPath(maze, nextNode);	//检测此位置是否可走
if (TRUE == bPath)	//可走
{
STACK_Push(path, nextNode);	//将此位置压入路径战中
maze[nextNode.i][nextNode.j] = SEEK;	//将此位置标志为路径
//更该当前节点
curNode.dir = nextNode.dir;
curNode.i = nextNode.i;
curNode.j = nextNode.j;

if (n - 2 == curNode.i && n - 1 == curNode.j)	//到达出口
{
bFind = TRUE;	//标示找到
break;
}
else if (1 == curNode.i && 0 == curNode.j)	//回到入口
{
bFind = FALSE;	//标示未找到
break;
}

bNew = TRUE;	//此位置第一次到达
}
else
{
if (TOP == nextNode.dir)	//所有方向已试探不可
{
maze[curNode.i][curNode.j] = DEAD;	//此位置为死路

STACK_Pop(path, NULL);	//弹出死位置
STACK_GetTop(path, &curNode);	//更改当前位置
//将试探位置改为当前位置 (这样的结果是此位置比较了两次)
nextNode.dir = curNode.dir;
nextNode.i = curNode.i;
nextNode.j = curNode.j;
}

bNew = FALSE;
}
}
printf("////////////////////////////////////n");
for (i = 0; i < n; i++)
{
for (j = 0; j < n; j++)
{
if (maze[i][j] != SEEK)
{
printf("%c ", maze[i][j]);
}
else
{
printf("  ");	//将找到的路径标志为空
}
}
printf("/n");
}

return 0;
}

//迷宫头文件

/*
*	文件名: maze.h
*	功能: 迷宫相关操作
*	作者: shaofeng5000
*	时间: 2011/4/3
*/
////////////////////////////////////////
#ifndef _MAZE_H
#define _MAZE_H
//默认格式定义
#define BOOL int
#define TRUE 1
#define FALSE 0
//属性
#define	BRICK '='	//砖块
#define PASS  'o'	//通道
#define	DEAD  '+'	//死路
#define SEEK  'p'	//找到的路径
//方向声明
enum DIRECTION
{
RIGHT,	//右方
BOTTOM, //下方
LEFT,	//左方
TOP		//上方
};
//迷宫的数据结构
typedef struct _MAZENODE
{
int i;
int j;
int dir;
}MAZENODE;

//迷宫操作
//开始走
void BeginStepDir(MAZENODE curNode, MAZENODE *nextNode);
//下一方向
void NextStepDir(MAZENODE curNode, MAZENODE *nextNode);
//检测路径
BOOL CheckPath(char maze[][15], MAZENODE nextNode);

#endif

//迷宫操作实现文件

/*
*	文件名: maze.h
*	功能: 迷宫相关操作
*	作者: shaofeng5000
*	时间: 2011/4/3
*/
////////////////////////////////////////
#include "maze.h"

/*
功能: 开始试探可走方向
参数: curNode 查找路径最顶端得节点
nextNode 试探方向
返回值: NULL
*/
void BeginStepDir(MAZENODE curNode, MAZENODE *nextNode)
{
//顶端节点向右为第一试探方向
nextNode->dir = RIGHT;
nextNode->i = curNode.i;
nextNode->j = curNode.j + 1;
}

/*
功能: 试探下一方向
参数: curNode 查找路径最顶端得节点
nextNode 试探方向
返回值: NULL
*/
void NextStepDir(MAZENODE curNode, MAZENODE *nextNode)
{
switch (nextNode->dir)
{
case RIGHT:   //方向向下
{
nextNode->dir = BOTTOM;
nextNode->i = curNode.i + 1;
nextNode->j = curNode.j;
}
break;

case BOTTOM:	//方向向左
{
nextNode->dir = LEFT;
nextNode->i = curNode.i;
nextNode->j = curNode.j - 1;
}
break;

case LEFT:     //方向向上
{
nextNode->dir = TOP;
nextNode->i = curNode.i - 1;
nextNode->j = curNode.j;
}
}
}
/*
功能: 检查试探方向是否可走
参数: maze 迷宫
nextNode 试探方向
返回值: 试探方向可走返回TRUE,否则返回FALSE
*/
BOOL CheckPath(char maze[][15], MAZENODE nextNode)
{
switch (maze[nextNode.i][nextNode.j])
{
case BRICK:	//砖头 不可走
return FALSE;

case PASS:	//通道 可走
return TRUE;

case DEAD:	//死路 不可走
return FALSE;
}
}

//栈头文件

/*
文件名: stack.h
功能: 单链表实现简单的栈
作者: shaofeng5000
时间: 2011/4/3
*/
#ifndef _STACK_H
#define _STACK_H

#include "maze.h"
//默认格式定义
#define BOOL int
#define TRUE 1
#define FALSE 0
#define DATA_TYPE MAZENODE
//栈节点的数据结构
typedef struct _STACKNODE
{
DATA_TYPE data;
struct _STACKNODE *next;
}STACKNODE, *PSTACKNODE;
//栈的数据结构
typedef struct _STACK
{
PSTACKNODE head;	//栈顶指针
int height;	//栈的高度
}STACK, *PSTACK;
//////////////////////////////////
//栈的基本操作
//////////////////////////////////
//栈的创建
PSTACK STACK_Create();
//栈的销毁
void STACK_Destroy(PSTACK *stack);
//栈的清空
void STACK_Clear(PSTACK stack);
//得到栈顶
void STACK_GetTop(PSTACK stack, DATA_TYPE *getData);
//压栈操作
BOOL STACK_Push(PSTACK stack, DATA_TYPE pushData);
//弹栈操作
void STACK_Pop(PSTACK stack, DATA_TYPE *popData);

#endif

//栈实现文件

/*
*	文件名: stack.cpp
*	功能: 单链表实现简单的栈
*	作者: shaofeng5000
*	时间: 2011/4/3
*/
////////////////////////////////////////
#include <stdio.h>
#include <stdlib.h>
#include "stack.h"
/*
功能: 创建栈
参数: NULL
返回值: 指向创建栈的指针
*/
PSTACK STACK_Create()
{
PSTACK stack;
//分配栈结构空间
stack = (PSTACK)malloc(sizeof(STACK));
if (NULL == stack)
{
return NULL;
}
//初始化栈数据
stack->head = NULL;
stack->height = 0;

return stack;
}

/*
功能: 销毁一个栈
参数: stack 指向将要销毁栈的指针
返回值: NULL
*/
void STACK_Destroy(PSTACK *stack)
{
//有效性检验
if (NULL == *stack)
{
return ;
}
//清空栈内节点
STACK_Clear(*stack);
//销毁栈的数据结构
free(*stack);
*stack = NULL;
}

/*
功能: 清空站内节点
参数: stack 指向将要清空栈的指针
返回值: NULL
*/
void STACK_Clear(PSTACK stack)
{
//有效性检验
if (NULL == stack)
{
return ;
}

DATA_TYPE data;
//弹出所有的节点
while (stack->height != 0)
{
STACK_Pop(stack, &data);
}
}

/*
功能: 得到栈顶数据
参数: stack 指向将要操作的栈指针
返回值: NULL
*/
void STACK_GetTop(PSTACK stack, DATA_TYPE *getData)
{
//有效性检查
if (NULL == stack)
{
return ;
}
//得到数据
getData->dir = stack->head->data.dir;
getData->i = stack->head->data.i;
getData->j = stack->head->data.j;
}

/*
功能: 压入栈
参数: stack 指向将要操作的栈的指针
pushData 将要压入的数据
返回值: 压入成功返回TRUE，否则返回FALSE
*/
BOOL STACK_Push(PSTACK stack, DATA_TYPE pushData)
{
//有效性检验
if (NULL == stack)
{
return FALSE;
}

//分配新节点的内存
PSTACKNODE pNewNode;
pNewNode = (PSTACKNODE)malloc(sizeof(STACKNODE));
if (NULL == pNewNode)
{
return FALSE;
}
pNewNode->next = NULL;
//压入栈
pNewNode->data.dir = pushData.dir;
pNewNode->data.i = pushData.i;
pNewNode->data.j = pushData.j;
pNewNode->next = stack->head;
stack->head = pNewNode;

stack->height++;

return TRUE;
}

/*
功能: 弹出栈
参数: stack 将要操作栈的指针
popData 返回弹出栈的数据
返回值:	NULL

*/
void STACK_Pop(PSTACK stack, DATA_TYPE *popData)
{
//有效性检查
if (NULL == stack && stack->height != 0)
{
return ;
}
//弹栈操作
PSTACKNODE pNode;
pNode = stack->head;
stack->head = stack->head->next;

stack->height--;
//内存释放
free(pNode);
pNode = NULL;
}