数据结构试验——老鼠走迷宫实验报告（最短路径、完整实现、详细注释）C语言

于 2021-04-08 11:09:43 发布
阅读量3.7k 收藏 49
点赞数 5
分类专栏： 算法 文章标签： 数据结构 深度搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yyxapp/article/details/115511061
版权

数据结构试验二   老鼠走迷宫

 

  • 实验思路：

 

用深度优先搜索实现，使用堆栈存储老鼠走过的路径。最终实现最短路径的的求解。

 

我用一个二维数组map[10][12]来表示地图。其元素有三种取值：0代表无墙、没走过；1代表墙；2代表无墙、已走过。

首先输入start点坐标（即为其在数中的行列坐标），若输入不合法（越界，或start在墙中）则需重新输入。

 

1.先判断start是否有后继。这里我做的比较繁琐，是把每种情况都判断了。其实可以在地图外再包一层墙，这样就可以所有点用一种方式来判断了。

若start点无问题，则把它压入栈s。

 

  1. 定义一个栈minPath用来存放最短路径
  2. 用FillStack函数填充s。若失败则无出口。
  3. 若填充成功，判断路径长度。若为2，则已经是最短路径，直接输出。
  4. 若其它情况，则先把s的内容赋给minPath作为起始最小路径，对s修改方向后再进行填充。若填充后的路径更小，则更新minPath。重复上述操作直至遍历全部路径。
  5. 释放空间

 

具体细节见注释

 

 

 

  • 心得：

 

  1. 堆栈不能直接复制，比如s1 = s2这样。要用一个额外的栈，把s2的内容输出到额外栈，额外栈此时倒序存放复制的内容，再将额外栈输出到s1和s2（注意这里也要输出到s2，否则s2就是空的了）。
  2. 用栈来代表路径。栈中元素就是地图上的一个点
  3. 我觉得我做的比较好的一个地方是提炼了FillStack和RidirectStack这两个函数。

FillStack的起始条件是一条路径，然后这个函数它会填充这条路径，如果能找到出口，则返回true，如果找不到出口，则返回false。

  RidirectStack的作用是修改路径。起始条件是一条路径，它拿出路径的最后一个节点，并修改最后一个节点的方向。如果这个节点不能再进行修改了，则删除该点，再倒数第二个，修改方向.....依次直到拿出了起始点。如果起始点也不能修改方向了，则是空栈。

这个函数还是比较关键的，在填充路径和求取最小路径时都有用到

4.在FillStack里用dowhile循环是因为，循环截止的条件start点也可能满足，所以要先执行一次。

5.地图上的点需要有三种表示：有墙，无墙走过，无墙没走过。如果没有标记已经走过的路径，当地图有形如：

1 1 0 0 0 0 0 1

1 1 0 1 1 1 0 1

1 1 0 0 0 0 0 1

这样的圈时，就停不下来了。

6.很多地方各种边界条件都要卡（比如判断下一个点的方向时，回退修改路径时等等），有时候一个地方忘记限制了（比如没卡数组边界，起始点要单独拿出来讨论）程序就跑半天跑不完了*崩溃*。还是要细致一点。

 

 

#include <iostream>

enum direction {
    UP, RIGHT, DOWN, LEFT
};

typedef struct {
    int x;
    int y;
    enum direction dir;
} Elem;

typedef struct Node {
    Elem data;
    struct Node *next;
} Node;

typedef Node *Stack;

void InitStack(Stack *s) {
    *s = (Node *) malloc(sizeof(Node));
    (*s)->next = nullptr;
}

bool StackEmpty(Stack s) {
    if (s->next == nullptr)
        return true;
    else
        return false;
}

void Push(Stack s, Elem e) {
    Node *t = (Node *) malloc(sizeof(Node));
    t->data = e;
    t->next = s->next;
    s->next = t;
}

void Pop(Stack s) {
    if (StackEmpty(s))
        return;
    Node *t = s->next;
    s->next = t->next;
    free(t);
}

Elem Top(Stack s) {
    return s->next->data;
}

void DeleteStack(Stack s) {
    while (s != nullptr) {
        Node *t = s;
        s = s->next;
        free(t);
    }
}

void ClearStack(Stack s) {
    while (!StackEmpty(s)) {
        Pop(s);
    }
}

int getStackLength(Stack s) {
    int num = 0;
    while (s->next != nullptr) {
        num += 1;
        s = s->next;
    }
    return num;
}

void PrintStack(Stack s) {
    Stack t;
    InitStack(&t);
    Elem temp_elem;
    while (!StackEmpty(s)) {
        temp_elem = Top(s);
        Pop(s);
        Push(t, temp_elem);
    }
    printf("START--");
    while (!StackEmpty(t)) {
        //
        temp_elem = Top(t);
        switch (temp_elem.dir) {
            case UP:
                printf("UP");
                break;
            case RIGHT:
                printf("RIGHT");
                break;
            case DOWN:
                printf("DOWN");
                break;
            case LEFT:
                printf("LEFT");
                break;
        }
        temp_elem = Top(t);
        Pop(t);
        Push(s, temp_elem);
        printf("--");
    }
    printf("Export");
}

void CopyStack(Stack s1, Stack s2) {
    Stack temp;
    InitStack(&temp);
    Elem elem;
    while (!StackEmpty(s2)) {
        elem = Top(s2);
        Pop(s2);
        Push(temp, elem);
    }
    Elem t;
    while (!StackEmpty(temp)) {
        elem = Top(temp);
        t = elem;
        Pop(temp);
        Push(s1, elem);
        Push(s2, t);
    }
}


int map[10][12] = {{1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1},
                   {1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1},
                   {0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1},
                   {1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1},
                   {1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0},
                   {1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1},
                   {1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1},
                   {1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1},
                   {1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1},
                   {1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1}};

void RedirectStack(Stack s) {
    bool flag_stop = false;
    Elem top, next;
    while (!StackEmpty(s) && !flag_stop) {
        top = Top(s);
        Pop(s);
        if (StackEmpty(s)) {
            switch (top.dir) {
                case UP:
                    if (top.y != 11 && !map[top.x][top.y + 1]) {
                        top.dir = RIGHT;
                        Push(s, top);
                        flag_stop = true;
                    } else if (top.x != 9 && !map[top.x + 1][top.y]) {
                        top.dir = DOWN;
                        Push(s, top);
                        flag_stop = true;
                    } else if (top.y != 0 && !map[top.x][top.y - 1]) {
                        top.dir = LEFT;
                        Push(s, top);
                        flag_stop = true;
                    }
                    break;
                case RIGHT:
                    if (top.x != 9 && !map[top.x + 1][top.y]) {
                        top.dir = DOWN;
                        Push(s, top);
                        flag_stop = true;
                    } else if (top.y != 0 && !map[top.x][top.y - 1]) {
                        top.dir = LEFT;
                        Push(s, top);
                        flag_stop = true;
                    }
                    break;
                case DOWN:
                    if (top.y != 0 && !map[top.x][top.y - 1]) {
                        top.dir = LEFT;
                        Push(s, top);
                        flag_stop = true;
                    }
                    break;
                case LEFT:
                    map[top.x][top.y] = 0;
                    break;
            }
        } else {
            next = Top(s);
            switch (top.dir) {
                case UP:
                    if (top.y != 11 && !map[top.x][top.y + 1] && next.dir != LEFT) {
                        top.dir = RIGHT;
                        Push(s, top);
                        flag_stop = true;
                    } else if (top.x != 9 && !map[top.x + 1][top.y] && next.dir != UP) {
                        top.dir = DOWN;
                        Push(s, top);
                        flag_stop = true;
                    } else if (top.y != 0 && !map[top.x][top.y - 1] && next.dir != RIGHT) {
                        top.dir = LEFT;
                        Push(s, top);
                        flag_stop = true;
                    }
                    break;
                case RIGHT:
                    if (top.x != 9 && !map[top.x + 1][top.y] && next.dir != UP) {
                        top.dir = DOWN;
                        Push(s, top);
                        flag_stop = true;
                    } else if (top.y != 0 && !map[top.x][top.y - 1] && next.dir != RIGHT) {
                        top.dir = LEFT;
                        Push(s, top);
                        flag_stop = true;
                    }
                    break;
                case DOWN:
                    if (top.y != 0 && !map[top.x][top.y - 1] && next.dir != RIGHT) {
                        top.dir = LEFT;
                        Push(s, top);
                        flag_stop = true;
                    }
                    break;
                case LEFT:
                    map[top.x][top.y] = 0;
                    break;
            }
        }
    }
}

bool FillStack(Stack s) {

    bool has_export = true;
    Elem top = Top(s);

    do {
        Elem nextPosition;
        if (top.dir == UP) {
            nextPosition.x = top.x - 1;
            nextPosition.y = top.y;
        } else if (top.dir == RIGHT) {
            nextPosition.x = top.x;
            nextPosition.y = top.y + 1;
        } else if (top.dir == DOWN) {
            nextPosition.x = top.x + 1;
            nextPosition.y = top.y;
        } else {
            nextPosition.x = top.x;
            nextPosition.y = top.y - 1;
        }


        if (nextPosition.x == 0 || nextPosition.x == 9 || nextPosition.y == 0 || nextPosition.y == 11) {
            if (nextPosition.x == 0)
                nextPosition.dir = UP;
            else if (nextPosition.y == 11)
                nextPosition.dir = RIGHT;
            else if (nextPosition.x == 9)
                nextPosition.dir = DOWN;
            else
                nextPosition.dir = LEFT;
            Push(s, nextPosition);
            map[nextPosition.x][nextPosition.y] = 2;
        } else {
            if (!map[nextPosition.x - 1][nextPosition.y] && top.dir != DOWN) {
                //
                nextPosition.dir = UP;
                Push(s, nextPosition);
                map[nextPosition.x][nextPosition.y] = 2;
            } else if (!map[nextPosition.x][nextPosition.y + 1] && top.dir != LEFT) {
                //
                nextPosition.dir = RIGHT;
                Push(s, nextPosition);
                map[nextPosition.x][nextPosition.y] = 2;
            } else if (!map[nextPosition.x + 1][nextPosition.y] && top.dir != UP) {
                //
                nextPosition.dir = DOWN;
                Push(s, nextPosition);
                map[nextPosition.x][nextPosition.y] = 2;
            } else if (!map[nextPosition.x][nextPosition.y - 1] && top.dir != RIGHT) {
                //
                nextPosition.dir = LEFT;
                Push(s, nextPosition);
                map[nextPosition.x][nextPosition.y] = 2;
            } else {
                //
                RedirectStack(s);
            }
        }
        if (!StackEmpty(s))
            top = Top(s);
    } while (top.x != 0 && top.x != 9 && top.y != 0 && top.y != 11 && !StackEmpty(s));

    //
    if (StackEmpty(s))
        has_export = false;
    return has_export;
    //

}


int main() {

    //
    for (int i = 0; i < 10; i++) {
        for (int j = 0; j < 12; j++) {
            printf("%d ", map[i][j]);
        }
        printf("\n");
    }

    //
    Stack s;
    InitStack(&s);

    //
    int init_X, init_Y;
    printf("Please enter the position of the init point : x(0<=x<=9),y(0<=y<=11):");
    scanf_s("%d %d", &init_X, &init_Y);
    while (map[init_X][init_Y] || init_X < 0 || init_X > 9 || init_Y < 0 || init_Y > 11) {
        printf("Wrong!The init point should not in the wall or beyond the map!");
        printf("Please enter the position of the init point : x(0<=x<=9),y(0<=y<=11):");
        scanf_s("%d %d", &init_X, &init_Y);
    }
    Elem init_point;
    init_point.x = init_X;
    init_point.y = init_Y;

    //
    bool flag_init = true;
    if (init_X == 0 && init_Y == 0) {
        //
        if (map[1][0] + map[0][1] == 2)
            flag_init = false;
    } else if (init_X == 9 && init_Y == 0) {
        //
        if (map[8][0] + map[9][1] == 2)
            flag_init = false;
    } else if (init_X == 0 && init_Y == 11) {
        //
        if (map[0][10] + map[1][11] == 2)
            flag_init = false;
    } else if (init_X == 9 && init_Y == 11) {
        //
        if (map[9][10] + map[8][11] == 2)
            flag_init = false;
    } else if (init_X == 0) {
        //
        if (map[0][init_Y - 1] + map[1][init_Y] + map[0][init_Y + 1] == 3)
            flag_init = false;
    } else if (init_Y == 0) {
        //
        if (map[init_X - 1][0] + map[init_X][1] + map[init_X + 1][0] == 3)
            flag_init = false;
    } else if (init_X == 9) {
        //
        if (map[9][init_Y - 1] + map[8][init_Y] + map[9][init_Y + 1] == 3)
            flag_init = false;
    } else if (init_Y == 11) {
        //
        if (map[init_X - 1][11] + map[init_X][10] + map[init_X + 1][11] == 3)
            flag_init = false;
    } else {
        //
        if (map[init_X][init_Y - 1] + map[init_X - 1][init_Y] + map[init_X][init_Y + 1] + map[init_X + 1][init_Y] == 4)
            flag_init = false;
    }

    if (!flag_init) {
        printf("No Export!\n");
        exit(0);
    }

    //
    if (init_X - 1 >= 0 && map[init_X - 1][init_Y] == 0) {
        //
        init_point.dir = UP;
    } else if (init_Y + 1 <= 11 && map[init_X][init_Y + 1] == 0) {
        //
        init_point.dir = RIGHT;
    } else if (init_X + 1 <= 9 && map[init_X + 1][init_Y] == 0) {
        //
        init_point.dir = DOWN;
    } else {
        //
        init_point.dir = LEFT;
    }
    Push(s, init_point);
    Stack minPath;
    InitStack(&minPath);
    if (FillStack(s)) {
        printf("The min size path is:");
        if (getStackLength(s) == 2) {
            PrintStack(s);
            exit(0);
        } else {
            CopyStack(minPath, s);
            int minLength = getStackLength(s);
            int tempLength;
            while (!StackEmpty(s)) {
                RedirectStack(s);
                if (StackEmpty(s))
                    break;
                else {
                    if (FillStack(s)) {
                        tempLength = getStackLength(s);
                        if (tempLength < minLength) {
                            ClearStack(minPath);
                            CopyStack(minPath, s);
                            minLength = tempLength;
                        }
                    }
                }
            }
            PrintStack(minPath);
        }
    } else
        printf("NO EXPORT");

    DeleteStack(s);
    DeleteStack(minPath);

    return 0;

}

 

Yuxuan_Yue
关注
专栏目录
[数据结构]求解迷宫最短路径问题
xxpresent的博客
12-08 1万+
一、问题概述        之前，我们了解了如何实现迷宫问题（对于迷宫只有一个出口可以通的情况），事实上我们的迷宫有多个出口，对于每条路径来说，有长有短，所以在这里，我们讨论一下迷宫的最短路径，即迷宫路径的最优解问题。 二、解决方案        对于这样一个迷宫：        注：数字为0的表示可以通过，数字为1的表示不可
迷宫最短路径c语言程序,c语言，迷宫最短路径
weixin_39836860的博客
05-17 1916
#include #include #include #define MAX 30//迷宫最大30*30#define ENDS -2//端点位置标记为-2#define ROUT -1//入队的路径标记为-1#define SHORTESTPATH 2//将最终的最短路径标记为2//队列结构，保存进行广度优先搜索时的路径typedef struct QueueNode{int a[2];//记录...
数据结构迷宫问题试验报告
05-07
我的心血呀 熬夜的结果 希望对你有帮助 特别声明是能拿去应付老师哦
数据结构课程设计:老鼠走迷宫
03-13
二维数组和堆栈实现的C++迷宫老鼠，迷宫的自动寻径。 http://blog.csdn.net/wxg694175346/article/details/8659037
数据结构迷宫最短路径问题
03-21
描述： 设计一个算法找一条从迷宫入口到出口的最短路径。 输入： 迷宫的行和列m n 迷宫的布局 输出： 最短路径 输入样例： 请输入迷宫的行和列：6 8 请输入迷宫的布局: 0 1 1 1 0 1 1 1 1 0 1 0 1 0 1 0 0 1 0 0 1 1 1 1 0 1 1 1 0 0 1 1 1 0 0 1 1 0 0 0 0 1 1 0 0 1 1 0 输出样例： 最短路径为： （6,8）（5,7）（4,6） （4,5）（3,4） （3,3） （2,2）（1,1）
数据结构迷宫求解问题（实验报告）
04-24
数据结构，迷宫求解问题论文， 用战来实现迷宫的求解问题
数据结构迷宫问题实验报告
03-23
关于数据结构C的 严蔚敏般的 大二时做实验的 希望对你有帮助
迷宫问题【数据结构实验报告】
热门推荐
_
10-27 3万+
数据结构实验报告 实验名称：实验二 迷宫问题 学号：*** 姓名：gnosed 实验日期：2017.10.23   一、实验目的 1、了解回溯法在求解迷宫问题中的应用 2、进一步掌握栈的使用   二、实验具体内容 1、实验题目1： （1）题目 用回溯法求解迷宫问题，可以用一个栈保存探索的序列。并且在该迷宫的行走中，站在一点可以有八个方向选择。 比如如下的迷宫 Ente...
【数据结构算法】迷宫的最短路径 - BFS
UESTC_201722的博客
08-05 903
题目 给定一个大小为N*M的迷宫，由通道(’.’)和墙壁(’#’)组成，其中通道S表示起点，通道G表示终点，每一步移动可以达到上下左右中不是墙壁的位置。试求出起点到终点的最小步数。（本题假定迷宫是有解的） 解题思路 是BFS和队列的结合应用 结合代码看，更容易理解 从起点开始，先将其加入队列，设置距离为0 从队列首端取出位置，将从这个位置能够到达的位置加入队列，并且让这些位置的距离为上一个位置的...
走迷宫（一）：最短路径
weixin_30906671的博客
11-29 208
题目链接：http://acm.nyist.net/JudgeOnline/problem.php?pid=58 有关深搜广搜知识的PPT讲解链接（1）http://wenku.baidu.com/link?url=uuVluDfJP-gW6FiV0F8J4s4VuEOU__uqW1nFjuOO-id9ntGdqXLLvwDN0eR3akZMKP_iBmA0xPGAE-SOwdWyN21HJoX...
迷宫问题实验报告
04-28
迷宫问题。
迷宫问题的最短路径C语言实现（栈实现）
04-28
迷宫问题最短路径C语言printf("最短路径如下:\n"); printf("长度: %d\n",minlen); printf("路径: "); for(k=0;k;k++) printf("(%d,%d) ",Path[k].i,Path[k].j); printf("\n"); return 0;
找到一个给定的迷宫最短路径.zip_matlab 迷宫路径_matlab走迷宫_最短路径_用matlab走迷宫_迷宫最短路径
07-14
在matlab虚拟环境，找到迷宫的最短路径
C语言实现数据结构迷宫实验
01-01
本文实例为大家分享了C语言实现简单的数据结构迷宫实验，供大家参考，具体内容如下 分析：迷宫实验主要有两部分操作，其一是对迷宫的生成，其二是寻路使用栈的操作。 步骤： 一、.h文件 1、首先是迷宫的生成，可以...
数据结构实验迷宫问题实验报告
11-18
数据结构实验迷宫问题实验报告 本实验报告主要是关于数据结构实验中的迷宫问题，通过设计数据结构存储迷宫、设计存储结构保存从入口到出口的通路、设计算法完成迷宫问题的求解，并分析算法的时间复杂度。 首先，...
迷宫问题--队列实现
weixin_42107106的博客
11-10 2795
利用队列求解迷宫最短路径问题。 输入： 3 //代表迷宫行数 4 //代表迷宫列数 0 1 1 0  1 0 0 1  1 0 1 0 //代表迷宫 输出： 迷宫路径（用坐标点表示） 3 4  2 3  2 2  1 1  输入输出样例：1组 #1 样例输入： 3 4 0 1 1 0 1 0 0 1 1 0 1 0 样例输出： 3 4 2 3 2...
基于栈的数据结构实现走迷宫最短路径（java）
ran_kuroba的博客
03-27 2351
基于栈的数据结构实现走迷宫的最短路径 语言：JAVA 开发平台：Eclipse 目的 一个迷宫如图所示，它有一个入口和出口，其中白色单元表示通路，黑色单元表示路不通。寻找一条从入口到出口的路径，每步只能从一个白色单元走到相邻的白色单元，直至出口。使用栈实现走迷宫的功能，演示走迷宫的过程。 数据结构设计 用ArrayList 作为栈的数据结。ArrayList是java中Collection集合中...
数据结构之迷宫最短路径求解
mignatian的博客
05-17 3534
上一篇我们讲了求解迷宫是否有出路的问题，这篇我们在迷宫有多条路的情况下怎么求出最短路径 我们的思路是建立两个栈，一个当前路径栈，一个最短路径栈，最开始的时候最短路径栈是空，我们把一条迷宫路径的所有节点都入栈，然后与最短路经比较，如果小于那么，就将当前路径的栈赋值给最短路径栈，其中包括重新申请大小等。 下面是具体代码实现 #include "maze.h" #include "seqsta...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值