数据结构--迷宫问题

项目场景：

以一个MxN的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计一个程序，对任意设定的迷宫，判断有无通路。如果有通路，求出一条从入口到出口的通路

---

问题描述

在输出栈s中所有迷宫路径时会出现输出将终点坐标输出为起点坐标

void print_Path(Seqstack* s)
//输出栈中所有迷宫路线
{
    int i = 0;
    printf("迷宫路线为：\n");
    for (i=0; i <s->top; i++)
    {
        printf("(%d,%d)%d->", s->data[i].x, s->data[i].y, s->data[i].d);
    }
    printf("(%d,%d)%d\n", s->data[i].x, s->data[i].y, s->data[i].d);
    display();
}

---

原因分析

因为int i = 0;已经被定义，在for (i=0; i <s->top; i++)循环中起点坐标会被输出两次，最后一次，将终点坐标覆盖

---

解决方案：

我们只需要将在for (i=0; i <s->top; i++)改成在for (; i <s->top; i++)就可以了

全部代码：

#include<stdio.h>
#include<stdlib.h>
#define M 8     //定义迷宫行数
#define N 8        //定义迷宫列数
#define MAXLEN 100        //定义顺序栈的最大容量
typedef struct  //定义坐标
{
    int x;
    int y;
}item;
typedef struct //定义坐标和方向
{
    int x;
    int y;
    int d;
}dataType;//定义顺序栈的类型
typedef struct
{
    dataType data[MAXLEN];
    int top;
}Seqstack;
item move[8];//8领域试探方向数组
int maze[M + 2][N + 2] =
{
    {1,1,1,1,1,1,1,1,1,1},
    {1,0,0,1,0,0,0,1,0,1},
    {1,0,0,1,0,0,0,1,0,1},
    {1,0,0,0,0,1,1,0,0,1},
    {1,0,1,1,1,0,0,0,0,1},
    {1,0,0,0,1,0,0,0,0,1},
    {1,0,1,0,0,0,1,0,0,1},
    {1,0,1,1,1,0,1,1,0,1},
    {1,1,0,0,0,0,0,0,0,1},
    {1,1,1,1,1,1,1,1,1,1}
};//构造地图
void print_Path(Seqstack* s);
Seqstack* InitSeqstack()
//该函数初始化一个空栈，并返回指针指向该栈的存储单元首地址
{
    Seqstack* s;
    s = new Seqstack;//分配站空间
    s->top = -1;
    return s;
}
int Push(Seqstack* s, dataType x)
{
    if (s->top == MAXLEN - 1)//栈满
    {
        return 0;
    }
    else //入栈操作
    {
        s->top++;
        s->data[s->top] = x;
        return 1;
    }
}
int StackEmpty(Seqstack* s)
//该函数判断栈是否为空，若为空，则返回结果1，否则返回0
{
    if (s->top == -1)//栈为空
    {
        return 1;
    }
    else
    {
        return 0;
    }
}
int Pop(Seqstack* s, dataType* x)
//将栈顶元素出站，放入x所指的存储单元中，若出栈返回结果为1，否则返回0
{
    if (StackEmpty(s))//栈空
    {
        return 0;
    }
    else//出栈
    {
        *x = s->data[s->top];
        s->top--;
        return 1;
    }
}
void display()
{
    int k, t;
    printf("\n\n图像表示:\n");
    for (t = 0; t < 10; t++) {
        printf("\t\t");
        for (k = 0; k < 10; k++) {
            if (maze[t][k] == 1) {
                printf("#");
            }
            else if (maze[t][k] == 0) {
                printf(" ");
            }
            else {
                printf("o");
            }
        }
        if (k == 10) {
            printf("\n");
        }
    }
    printf("\n此时，o所代表的图标为迷宫行走路径!!!\n");
}
void init_move(item move[8])
//初始化8领域方向
{
    move[0].x = 0;
    move[0].y = 1;
    move[1].x = 1;
    move[1].y = 1;
    move[2].x = 1;
    move[2].y = 0;
    move[3].x = 1;
    move[3].y = -1;
    move[4].x = 0;
    move[4].y = -1;
    move[5].x = -1;
    move[5].y = -1;
    move[6].x = -1;
    move[6].y = 0;
    move[7].x = -1;
    move[7].y = 1;
}
void printS(dataType temp)
{
    int static i = 0;
    printf("第%d次入栈元素为：", ++i);
    printf("(%d,%d)%d\n", temp.x, temp.y, temp.d);
}
int find_Path(int maze[M + 2][N + 2], item move[8])
//在迷宫maze二维数组中按maze的/领域方向探测迷宫路线，存在返回1，否则返回0
{
    Seqstack* s = InitSeqstack();
    dataType temp;
    int x, y, d, i, j;
    temp.x = 1;
    temp.y = 1;
    temp.d = -1;//初始化入口坐标和方向
    Push(s, temp);
    while (!StackEmpty(s))
    {
        Pop(s, &temp);//当前位置和方向
        x = temp.x;
        y = temp.y;
        d = temp.d + 1;
        while (d <8)//沿8方向试探是否有路可以通过
        {
            i = x + move[d].x;
            j = y + move[d].y;
            if (maze[i][j] == 0)//当前位置可以到达
            {
                temp.x = x;
                temp.y = y;
                temp.d = d;
                Push(s, temp);//坐标和方向入栈
                printS(temp);
                x = i;
                y = j;
                maze[x][y] = -1;//该位置已经到达
                if (x == M && y == N)//已经到达出口
                {
                    print_Path(s);//按栈反方向输出迷宫路线
                    return 1;
                }
                else
                {
                    d = 0;//重新初始化探测方向
                }
            }
            else { d++; }//探测下一个方向
        }
    }
    return 0;
}

void print_Path(Seqstack* s)
//输出栈中所有迷宫路线
{
    int i = 0;
    printf("迷宫路线为：\n");
    for (; i <s->top; i++)
    {
        printf("(%d,%d)%d->", s->data[i].x, s->data[i].y, s->data[i].d);
    }
    printf("(%d,%d)%d\n", s->data[i].x, s->data[i].y, s->data[i].d);
    display();
}
void main()
{
    init_move(move);//初始化迷宫探测方向数组
    
    if (!find_Path(maze, move))
    {
        printf("迷宫不存在");
    }
}