求简单迷宫的路径

简单迷宫

---

1. 设置一个简单迷宫。(6*6)
   

2. 定义迷宫入口。
     迷宫入口要求:必须是边界。
   
   3.开始走迷宫
     a. 走当前步： 当前步入栈，将当前步标记为2
     b. 判断当前栈顶元素是否是出口（是边界却不是入口），如果是就返回，若不是之星下一步。
     c.取栈顶元素为当前步：
     d.走下一步：
       假设优先顺序为上,左，右，下。
     上：（横坐标减1，纵坐标不变）
        判断是否是通路（即此处是否是1）
          如果是通路，则走此步 ，此步入栈，将当前步标为2。
     左：（纵坐标减1，横坐标不变）
        判断是否是通路（即此处是否是1）
          如果是通路，则走此步 ，此步入栈，将当前步标为2。
     右：（纵坐标加1，横坐标不变）
       判断是否是通路（即此处是否是1）
         如果是通路，则走此步 ，此步入栈，将当前步标为2。
     下：（横坐标减1，纵坐标不变）
       判断是否是通路（即此处是否是1）
         如果是通路，则走此步 ，此步入栈，将当前步标为2。
   如果上下左右均不是通路，则证明此步走错。应该回退到上一步重新找路径（栈顶元素出栈）。循环执行b，c，d直至遇到出口为止。

---

迷宫具体分析：

---

  我们需要一个存放路径的栈，由于此栈存放的是路径，路径有横纵坐标，所以也需要一个结构体去实现。

//横纵坐标的值
typedef struct position
{
    int x;
    int y;
}position;

//静态栈，用于存储路径
typedef struct  stack
{
    position data[20];
    int top;
}stack;

---

                                整体代码：

.h文件

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<assert.h>

#define ROW  6
#define COL  6

//横纵坐标的值
typedef struct position
{
    int x;
    int y;
}position;

//静态栈，用于存储路径
typedef struct  stack
{
    position data[20];
    int top;
}stack;


//初始化栈
void InitStack(stack *s);

//走迷宫
void PassMaze(int Maze[ROW][COL],position enter,stack* s);

//打印迷宫
void print(int Maze[ROW][COL]);

//打印迷宫路径
void printStack(stack *s);

.c文件

#include"Maze.h"

//初始化栈
void InitStack(stack *s)
{
    assert(s);
    s->top = 0;
    memset(s->data, 0, 20 * sizeof(position));
}
//入栈
void  PushStack(stack *s, position cur)
{
    assert(s);
    s->data[s->top] = cur;
    s->top++;
}
//栈顶元素
position TopStack(stack *s)
{
    assert(s);
    return s->data[s->top - 1];
}
//栈顶元素出栈
void PopStack(stack *s)
{
    assert(s);
    s->top--;
}
//判断是入口吗？
int IsEnter(int Maze[ROW][COL], position enter)
{
    //边界
    if (enter.x == 0 || enter.x == ROW - 1 || enter.y == 0 || enter.y == COL - 1)
    {
        return 1;
    }
    else
        return 0;
}
//是通路吗？
int IsPass(int Maze[ROW][COL], position next)
{
    //1.坐标有效
    if (next.x >= 0 && next.x < ROW && next.y >= 0 && next.y < COL )
    {
        //2.是通路
        if (1 == Maze[next.x][next.y])
        {
            return 1;
        }
    }
    return 0;
}
//是出口吗？
int IsExit(int Maze[ROW][COL], position enter, position cur)
{
    if ((cur.x == 0 || cur.x == ROW - 1 || cur.y == 0 || cur.y == COL - 1) && (cur.x != enter.x || cur.y != enter.y))
    {
        return 1;
    }
    return 0;
}

//走迷宫
void PassMaze(int Maze[ROW][COL], position enter, stack* s)
{
    position cur;
    position next; 
    if (IsEnter(Maze, enter))
    {
        cur = enter;
        //入口入栈
        PushStack(s, cur);
        //为防止重复走，将走过的路标记
        Maze[cur.x][cur.y] = 2;
        //如果不是出口，继续。。。。
        while (!IsExit(Maze, enter,TopStack(s)))
        {
            //cur为当前的栈顶元素
            cur = TopStack(s);
            //上通，从上走，标记
            next = cur;
            next.x = cur.x - 1;
            if (IsPass(Maze, next))
            {
                PushStack(s, next);
                Maze[next.x][next.y] = 2;
                continue;
            }
            //左通，从左走，标记
            next = cur;
            next.y = cur.y - 1;
            if (IsPass(Maze, cur))
            {
                PushStack(s, next);
                Maze[next.x][next.y] = 2;
                continue;
            }
            //右通，从右走，标记
            next = cur;
            next.y = cur.y + 1;
            if (IsPass(Maze, next))
            {
                PushStack(s, next);
                Maze[cur.x][next.y] = 2;
                continue;
            }
            //下通，从下走，标记
            next = cur;
            next.x = cur.x + 1;
            if (IsPass(Maze, next))
            {
                PushStack(s, next);
                Maze[next.x][next.y] = 2;
                continue;
            }
            //若上左右下均不是通路，证明该步走错，回退，且标记
            //栈顶元素出栈
            PopStack(s);
            Maze[cur.x][cur.y] = 3;
        }
        }
}
//打印迷宫
void print(int Maze[ROW][COL])
{
    int i = 0;
    int j = 0;
    for (i = 0; i < ROW; i++)
    {
        for (j = 0; j < COL; j++)
        {
            printf("%d ", Maze[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

//打印迷宫路径
void printStack(stack *s)
{
    int i = 0;
    printf("迷宫路径为：\n");
    for (i = 0; i < s->top; i++)
    {
        printf("(%d,%d)  ", s->data[i].x,s->data[i].y);
    }
    printf("\n");
}

测试文件

#include"Maze.h"

void TestMaze()
{
    //设置一个地图的二位数组
    int Maze[ROW][COL] = { { 0, 0, 0, 0, 0, 0 },
                           { 0, 0, 1, 0, 0, 0 }, 
                           { 0, 0, 1, 0, 0, 0 },
                           { 0, 0, 1, 1, 1, 0 }, 
                           { 0, 0, 1, 0, 1, 1 },
                           { 0, 0, 1, 0, 0, 0 } };
    position enter;
    //定义栈，用于存放路径
    stack s;
    //打印迷宫
    print(Maze);
    //初始化栈
    InitStack(&s);
    //定义一个迷宫入口
    enter.x = 5;
    enter.y = 2;
    //走迷宫
    PassMaze(Maze, enter, &s);
    //打印迷宫
    print(Maze);
    //打印迷宫路径
    printStack(&s);
}

int main()
{
    TestMaze();
    system("pause");
    return 0;
}

运行：