C数据结构与算法——队列 应用（C语言纯享版 迷宫）

最新推荐文章于 2024-03-24 12:04:50 发布
最新推荐文章于 2024-03-24 12:04:50 发布
阅读量338 收藏 2
点赞数 1
分类专栏： C 文章标签： c语言 开发语言 学习 经验分享 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55251408/article/details/131879470
版权

实验任务

(1) 掌握顺序循环队列及其C语言的表示；
(2) 掌握入队、出队等基本算法的实现；
(3) 掌握顺序循环队列的基本应用（求解迷宫通路）。

实验内容

  • 使用C语言实现顺序循环队列的类型定义与算法函数；
  • 编写main()函数并根据需要修改、补充相关的类型定义与函数，以实现“求解迷宫通路”问题：
  • 求解迷宫通路问题描述：
    • 给定一个M×N的迷宫图，指定一个入口与一个出口；
    • 规定行走规则为：按“上右下左”优先顺序向相邻空位移动1格，用（i，j）表示迷宫中的第i行第j列的一个方块
    • 在迷宫外围加上围墙；
  • 实现指定入口和出口的固定迷宫；
  • 实现随机入口和出口的固定迷宫；
  • 实现障碍、入口和出口都随机的迷宫。

实验源码

注意：必须在Dos窗口下运行，并且以管理员身份打开Dos窗口最佳

#include <stdio.h>
#include <time.h>
#include "windows.h"

#define MAXSIZE 1000
#define ROW 15
#define LINE 15
#define RATIO 0.6875 // 44/64的比例
#define COORDINATE -1 // 坐标默认 值
#define DISTOP 5 // 迷宫距离顶端距离格数

#define PASS 0 // 通路
#define WALL 1 // 墙
#define ENTRY 2 // 入口
#define EXIT 3 // 出口
#define DEAD 5 // 死路

// 延时设置
int walkDelay = 500;
int dirDelay = 1000;

typedef struct Box {
    int x;           // 点的横坐标（行）
    int y;           // 点的纵坐标（列）
    int pre;         // 上一个点的下标
} Box;

typedef struct {
    Box *base;
    int front;
    int rear;
} SqQueue;

void Map(int map[][LINE]); // 生成地图

void KnuthShuffle(int map[], int length); // 洗牌算法

void swapInt(int *a, int *b); // 辅助洗牌算法 交换

void PrintMap(int map[][LINE]); // 打印迷宫地图

boolean InitQueue(SqQueue *queue); // 循环队列的初始化

void Walk(SqQueue *queue, int in_x, int in_y, int map[][LINE]); // 移动迷宫

boolean EnQueue(SqQueue *queue, Box node); // 循环队列入队列

boolean IsFull(SqQueue *queue); // 判队满

boolean IsEmpty(SqQueue *queue); // 判队空

Box DeQueue(SqQueue *queue); // 循环队列出队列

void ShowPath(SqQueue *queue, int end); // 求解最短路径

void Color(short x); // 自定义函根据参数改变颜色

void DirTest(int map[][LINE], int dir, int j, int k); // 方向试探

void DeadPath(int j, int k); // 置为死路

void GotoXY(int x, int y); // 将光标移至屏幕 第x列，第y行 处

void DisplayQueue(SqQueue *queue); // 队列动态展示

void HideCursor(void); // 隐藏光标

/**
 * <h2>顺序队列实验</h2>
 * <h3>随机迷宫问题</h3>
 * <h3>注意：请在Dos窗口下运行</h3>
 * <h4>非循环队列，并不是真的退出队列</h4>
 * @return 0
 */
int main() {

    GotoXY(0, 0);
    Color(9);
    printf("  使用队列解决迷宫通路问题 \n");
    GotoXY(0, 1);
    printf("==============================\n");
    GotoXY(0, 2);
    Color(12);
    printf("Ｘ--走过的无效通路");
    Color(9);
    printf("  囚--起点\n");
    GotoXY(0, 3);
    Color(13);
    printf("Ｏ--走过的有效通路");
    Color(11);
    printf("  口--终点\n");
    GotoXY(0, 4);
    printf("------------------------------\n");

    srand(time(NULL));

    int map[ROW][LINE];
    Map(map);
    PrintMap(map);

    SqQueue queue;
    if (!(InitQueue(&queue))) {
        printf("队列初始化失败~~\n");
        return 0;
    }

    int in_x, in_y;
    for (int i = 0; i < ROW; i++) {
        for (int j = 0; j < LINE; j++) {
            if (map[i][j] == ENTRY) {
                in_x = i;
                in_y = j;
            }
        }
    }

    HideCursor();
    DisplayQueue(&queue);
    Walk(&queue, in_x, in_y, map);

    getchar();
}

void Map(int map[][LINE]) {
    int length = (ROW - 2) * (LINE - 2); // 8 * 8 内区域
    int randArr[length];
    for (int i = 0; i < length; i++) {
        if (i == 0) {
            randArr[i++] = ENTRY;
            randArr[i++] = EXIT;
        }
        if (i < (length * RATIO) + 2) {
            randArr[i] = PASS;
        } else {
            randArr[i] = WALL;
        }
    }
    KnuthShuffle(randArr, length); // 打乱 内区域
    // 赋值整张地图
    for (int i = 0; i < ROW; i++) {
        for (int j = 0; j < LINE; j++) {
            // 这里一个小技巧：只要前面四个表达式一个为假，说明未到边界赋值，保证Length不会越界
            if (i != 0 && i != ROW - 1 && j != 0 && j != LINE - 1 && length--) {
                map[i][j] = randArr[length];
            } else {
                map[i][j] = WALL;
            }
        }
    }
}

void KnuthShuffle(int map[], int length) {
    for (int i = length - 1; i >= 1; i--) {
        swapInt(&map[i], &map[rand() % (i + 1)]);
    }
}

void swapInt(int *a, int *b) {
    int t;
    t = *a;
    *a = *b;
    *b = t;
}

void PrintMap(int map[][LINE]) {
    for (int i = 0; i < ROW; i++) {
        for (int j = 0; j < LINE; j++) {
            GotoXY(j * 2, i + DISTOP);
            switch (map[i][j]) {
                case PASS:
                    printf("　");
                    break;
                case WALL:
                    Color(10);
                    printf("围");
                    break;
                case ENTRY:
                    Color(9);
                    printf("囚");
                    break;
                case EXIT:
                    Color(11);
                    printf("口");
                    break;
            }
        }
        printf("\n");
    }
    Sleep(3000);
}

boolean InitQueue(SqQueue *queue) {
    queue->base = (Box *) malloc(sizeof(Box) * MAXSIZE);
    if (!(queue->base)) {
        return FALSE;
    }
    queue->front = queue->rear = 0;
    return TRUE;
}

void Walk(SqQueue *queue, int in_x, int in_y, int map[][LINE]) {
    // 起点先入队列
    Box node; // 生成当前位置(起点)
    node.x = in_x;
    node.y = in_y;
    node.pre = COORDINATE; // 起点位置下标 -1

    EnQueue(queue, node); // 起点入队列

    while (!(IsEmpty(queue))) { // 无路可走的情况，回到起点
        node = DeQueue(queue); // 取出队头位置 队头指针front++

        if (map[node.x][node.y] == EXIT) { // 判断当前位置是否是终点
            ShowPath(queue, queue->front);
            return;
        }
        int dir; // 装方向
        Box tNode; // 生成下一个位置
        for (dir = 0; dir < 4; dir++) { // 判断当前位置各个方向是否可走
            switch (dir) {
                case 0:
                    tNode.x = node.x - 1;
                    tNode.y = node.y;
                    DirTest(map, dir, node.x, node.y);
                    break;
                case 1:
                    tNode.x = node.x;
                    tNode.y = node.y + 1;
                    DirTest(map, dir, node.x, node.y);
                    break;
                case 2:
                    tNode.x = node.x + 1;
                    tNode.y = node.y;
                    DirTest(map, dir, node.x, node.y);
                    break;
                case 3:
                    tNode.x = node.x;
                    tNode.y = node.y - 1;
                    DirTest(map, dir, node.x, node.y);
                    break;
            }
            if (map[tNode.x][tNode.y] == PASS || map[tNode.x][tNode.y] == EXIT) { // 判断这个方向 是否可走
                tNode.pre = queue->front - 1; // 把节点位置的下标给 新位置
                EnQueue(queue, tNode); // 入队
                if (map[tNode.x][tNode.y] == PASS) {
                    map[tNode.x][tNode.y] = DEAD;
                    DeadPath(tNode.x, tNode.y);

                }
            }
        }
    }
    // 这里加二号条件的原因是：此程序使用的是终点出队列即停止，但是也不排除 到终点即为空
    if (IsEmpty(queue) && map[node.x][node.y] != EXIT) {
        GotoXY(0, ROW + DISTOP + 2);
        Color(12);
        printf("\t无路可走，死翘翘了~~\n");
    }
}

boolean EnQueue(SqQueue *queue, Box node) {
    if (IsFull(queue)) {
        return FALSE;
    }
    queue->base[queue->rear] = node; // 新元素插入队尾
    queue->rear = queue->rear + 1; // 队尾指针加 1
    DisplayQueue(queue);
    return TRUE;
}

boolean IsFull(SqQueue *queue) {
    return queue->rear + 1 == queue->front; // 非循环队列
}

boolean IsEmpty(SqQueue *queue) {
    return queue->rear == queue->front;
}

Box DeQueue(SqQueue *queue) {
    Box box = queue->base[queue->front++];
    DisplayQueue(queue);
    return box; // 取出队头元素，并把其出队列
}

void ShowPath(SqQueue *queue, int end) {
    int i, tmp;
    for (i = end - 1; i >= 0;) {
        tmp = queue->base[i].pre;
        queue->base[i].pre = COORDINATE;
        i = tmp;
    }
    int count = 0, ti;
    for (i = 1; i < end; i++) { // i = 1, 保证不是终点即可
        if (queue->base[i].pre == COORDINATE) {
            if (count == 0) {
                GotoXY(LINE * 2 + 35, DISTOP - 1);
                printf("↓ 路径打印 ↓");
                GotoXY(LINE * 2 + 35, DISTOP);
                printf("|__i__j__pre__|");
            }
            count++;
            GotoXY(LINE * 2 + 35, DISTOP + count);
            printf("|_____________|\n");
            Color(11);
            GotoXY(LINE * 2 + 35 + 3, DISTOP + count);
            printf("%d", queue->base[i].x);
            GotoXY(LINE * 2 + 35 + 7, DISTOP + count);
            printf("%d", queue->base[i].y);
            GotoXY(LINE * 2 + 35 + 10, DISTOP + count);
            printf("%d", queue->base[i].pre);
            if (count == 1) {
                ti = i;
                continue;
            }
            GotoXY(queue->base[ti].y * 2, queue->base[ti].x + DISTOP);
            Color(15);
            if (queue->base[i].x - queue->base[ti].x == -1 &&
                queue->base[i].y - queue->base[ti].y == 0) {
                printf("↑");
            } else if (queue->base[i].x - queue->base[ti].x == 0 &&
                       queue->base[i].y - queue->base[ti].y == 1) {
                printf("→");
            } else if (queue->base[i].x - queue->base[ti].x == 1 &&
                       queue->base[i].y - queue->base[ti].y == 0) {
                printf("↓");
            } else {
                printf("←");
            }
            ti = i;
        }
    }
}

void Color(short x) {
    if (x >= 0 && x <= 15) { // 参数在0-15的范围颜色
        SetConsoleTextAttribute( // 调用设置控制台文本属性函数(调用获取句柄函数(不理解), 不理解)
                GetStdHandle(STD_OUTPUT_HANDLE), x);    // 只有一个参数，改变字体颜色
    } else { // 默认的颜色白色
        SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7);
    }
}

void DirTest(int map[][LINE], int dir, int j, int k) {
    GotoXY(k * 2, j + DISTOP);
    Color(15);
    switch (dir) {
        case 0:
            printf("↑");
            break;
        case 1:
            printf("→");
            break;
        case 2:
            printf("↓");
            break;
        case 3:
            printf("←");
            break;
    }
    Sleep(dirDelay);
    GotoXY(k * 2, j + DISTOP);
    Color(13);
    switch (map[j][k]) {
        case ENTRY:
            Color(9);
            printf("囚");
            break;
        case DEAD:
            Color(12);
            printf("Ｘ");
            break;
    }
}

void DeadPath(int j, int k) {
    GotoXY(k * 2, j + DISTOP);
    Color(12);
    printf("Ｘ");
    Sleep(walkDelay);
}

void GotoXY(int x, int y) {
    COORD pos = {x, y}; // 坐标
    HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE); // 获取句柄（标准输出句柄）
    SetConsoleCursorPosition(hOut, pos); // 设置控制台光标位置
}

void DisplayQueue(SqQueue *queue) {
    int len = ROW - 1;
    Color(12);
    GotoXY(LINE * 2 + 10, DISTOP);
    printf("|__i__j__di__| <- top");
    for (int j = 1; j <= len; j++) {
        GotoXY(LINE * 2 + 10, DISTOP + j);
        printf("|____________|\n");
    }
    int length = queue->rear;
    for (int i = 0; i < length; i++, len--) {
        if (len == 0) {
            len = ROW - 1;
            for (int j = 1; j <= len; j++) {
                GotoXY(LINE * 2 + 10, DISTOP + j);
                printf("|____________|\n");
            }
        }
        Color(11);
        GotoXY(LINE * 2 + 10 + 3, DISTOP + len);
        printf("%d", queue->base[i].x);
        GotoXY(LINE * 2 + 10 + 7, DISTOP + len);
        printf("%d", queue->base[i].y);
        GotoXY(LINE * 2 + 10 + 10, DISTOP + len);
        printf("%d", queue->base[i].pre);
    }
}

void HideCursor(void) {
    CONSOLE_CURSOR_INFO cursor_info = {1, 0};
    SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cursor_info);
}

实验结果

在这里插入图片描述

小丶象
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构，迷宫问题C语言版源代码
04-02
数据结构中，关于迷宫问题的源代码（C语言）。课程作业是解决迷宫求解的问题，从入口出发，顺某一方向向前探索，若能走通，则继续往前走；否则沿原路退回，换一个方向再继续探索，直至所有可能的通路都探索到为止。为了保证在任何位置上都能沿原路退回，所以需要用一个后进先出的结构来保存从入口到当前位置的路径。因此，在求迷宫通路的算法中要应用“栈”的思想假设“当前位置”指的是“在搜索过程中的某一时刻所在图中某个方块位置”，则求迷宫中一条路径的算法的基本思想是：若当前位置“可通”，则放入“当前路径”，并继续朝“下一位置”探索，即切换“下一位置”为“当前位置”，如此重复直至到达出口；若当前位置“不可通”，则应顺着“
C语言 队列解决迷宫问题
m0_61913190的博客
10-22 2309
对迷宫八个方向逐一搜索，若可通行这入队，并将已经通行的位置赋值1（避免重复搜索）迷宫为8方向搜索，即可斜着走。
C语言队列解决迷宫问题（所有路径）
最新发布
2301_80163948的博客
03-24 738
if (i0 >= 1 && j0 >= 1 && i0
【算法】（BFS/DFS）迷宫路径问题（C语言）
weixin_51450101的博客
05-01 7126
题目：现有一迷宫如下图所示，蓝色部分为墙壁，白色部分为通路，入口在左上角（1,1）处，出口在右下角（8,8）处，试找出一条路径以通过该迷宫（路径不能重叠）。
随机生成迷宫&寻找最短路径（C语言版）
有朋自远方来，不亦乐乎。
09-28 3091
【代码】随机生成迷宫&寻找最短路径（C语言版）
C语言处理迷宫问题（如何用一个函数来寻找路径）
qq_48600934的博客
08-28 1510
C语言处理迷宫问题迷宫问题分析问题寻找路径 迷宫问题 问题描述：在一组m行n列的数据中’1’表示墙，'0’表示路；左上角第二行第二列为起点，同理右下角第二行第二列为为终点。你需要编写一个代码来寻找路径。 分析问题 首先对于这个问题，我们需要1.获取迷宫；2.寻找路径；3.打印路径； 其中获取迷宫和打印路径比较简单，本文不作详细分析，因个人技术有限此部分代码较为繁琐，仅供参考。其他代码只要能读入迷宫数据即可。 #include<stdio.h> char a[1007][1007]={0},b[1
C语言使用广度优先搜索算法解决迷宫问题（队列）
08-29
主要介绍了C语言使用广度优先搜索算法解决迷宫问题,结合迷宫问题分析了C语言队列广度优先搜索算法的相关使用技巧,需要的朋友可以参考下
c语言数据结构与算法 5天培训原码与笔记
12-02
c语言数据结构与算法 5天培训原码与笔记，gcc编译器下直接执行 包含 堆栈、数据结构、链表、二叉树、排序、老鼠迷宫等知识点。
数据结构与算法全集（C源代码+详细注释）
11-27
全集内容结构如下： ├─图 │ ├─关键路径（有向无环图及其应用2） │ │ 1.txt │ │ ALGraph.cpp │ │ ALGraph.h │ │ CriticalPath.cpp │ │ CriticalPath.h │ │ InfoType.cpp │ │ InfoType.h │ │ ...
C语言利用队列求解迷宫问题
m0_49119161的博客
10-17 3152
利用队列求解迷宫问题
C++进行迷宫问题求解
热门推荐
m0_51765966的博客
11-19 1万+
利用栈和队列两种数据结构实现迷宫求解一. 迷宫问题的描述二. 迷宫问题求解1.使用队列进行深度优先搜索C++代码实现2. 使用栈进行深度优先搜索C++代码实现3.代码运行结果三.迷宫问题小实验总结 一. 迷宫问题的描述 有一张地图，0表示没有障碍物，1表示有障碍物，给你一幅地图、一个起始位置和一个目标位置，请判断是否能够从起始位置出发到达目标位置，可以的话将走过的路径用8进行标记 二. 迷宫问题求解 1.使用队列进行深度优先搜索 查找路径思路： 将起点位置存入队列中； 每次访问队头元素，让队头元素出队，标
队列完成迷宫路径搜索（C语言）
sugfight的博客
11-16 2310
使用队列完成迷宫题目概述问题分析算法设计初始化地图搜索迷宫路径完整代码 题目概述 迷宫问题。假设迷宫由m行n列构成，有一个入口和一个出口，入口坐标为（1，1），出口坐标为（m，n），试设计并验证以下算法：找出一条从入口通往出口的路径，或报告一个“无法通过”的信息。 (1) 用C语言实现顺序存储结构上队列的基本操作，然后利用该队列的基本操作找出迷宫的一条最短路径。 (2) 设计一个二维数组MAZE[m+2][n+2]表示迷宫，数组元素为0表示该位置可以通过，数组元素为1表示该位置不可以通行。MAZE[1][1
迷宫问题（C语言实现）（牛客网百度笔试真题）
originalHSL的博客
07-01 614
1.定义一个二维数组表示迷宫，其中 0 表示可以通过的路，1 表示障碍物。3.使用深度优先搜索或广度优先搜索算法在迷宫中搜索路径，记录经过的路径。4.如果搜索到终点，则返回路径，否则返回无解。2.定义起点和终点坐标。
用队列实现迷宫问题（C语言,数据结构）
qq_61959524的博客
04-30 7717
用队列求迷宫路径
数据结构（C语言版）”栈与队列“章节迷宫求解问题的思路与实现
u010676110的博客
05-11 1万+
迷宫求解问题来源自”数据结构（C语言版）“一书第50页的例题。该例题要求在不使用递归（因为暂时还没讲到），只能通过使用诸如入栈出栈的方式获取一条可以走出迷宫的路径。     在看完文字提示后，我就没有看后面的伪代码实现了（对于我来说，本书的所有伪代码的组织就像一团乱麻，反而更加没有头绪）。在理解文字说明的基础上我试图通过独立思考解决，以下就是我的思考过程。 1.迷宫求解问题的规则有哪些？
迷宫求解(使用队列
sanqima的专栏
10-01 9539
在迷宫中，从入口到出口往往有一条或者多条最短路径。可以使用队列来求解迷宫的最短路径，使用队列时，搜索路径是一层一层向前推进，第一次找到出口是搜索的层数最少，这种搜索方法与广度优先算法类似。 　　使用队列Qu记录走过的方块，该队列的结构如下：struct{ int i; //方块的行号 int j; //方块的列号 int pre; //前一方块在队列中的下标 }Qu
数据结构课设：迷宫问题（队列求解）
qq_63855497的博客
09-26 2092
Step3：对队头进行东、南、西、北四个方向进行扩展，再对待扩展的结点进行判断，如果待扩展的结点不为墙，并且在当前路径中没有出现过，即为满足条件的点，可加入队列，并记录结点属性，如此即可通过队列求得所有满足条件的路径。Step2：取出队头元素，并将其从队列中删除，判断其是否为终点，如果是，则保存路径，根据pre逆向获取路径，并保存至stk数组中，以便使用。给定一个n*m的迷宫，0表示迷宫中的通路，1表示迷宫中的墙壁，给定起点和终点，求解从起点到终点的所有通路，或者没有找到通路的结论。2、可视化显示迷宫。
C++迷宫问题完全详解
weixin_42163707的博客
12-20 1508
深度优先搜索（DFS）和广度优先搜索（BFS）是两种常用的图遍历算法，适用于不同的问题和场景。广度优先使用的是Queue队列，队列是一种先进先出(First In First Out,FIFO)的数据结构，它有两个出口。这里使用了栈，stack是一种先进后出(First In Last Out,FILO)的数据结构，它只有一个出口。迷宫我们都玩过，有些复杂的看的眼花缭乱，但是有没有想过，让机器帮你完成这个工作，想着就很酷，好，在实际应用中，根据问题的特点和需求，选择合适的算法来进行图遍历是非常重要的。
数据结构c语言版课程设计走迷宫
05-14
在数据结构c语言版课程设计中，走迷宫是一个非常经典的案例。走迷宫涉及到许多数据结构的应用，如队列、栈、图等。在这个案例中，我们需要设计一个程序，实现自动走迷宫的功能。 具体实现步骤如下： 首先，需要将迷宫的地图读取进来，并将其转化为一个二维数组。在程序中，通过一个二维数组来存储迷宫的地图。其中，0表示可以通过的通道，1表示不可通过的障碍物，2表示起点，3表示终点。 然后，我们需要利用广度优先搜索算法来找到从起点到终点的最短路径。在广度优先搜索算法中，需要用到队列来存储待处理的节点。 接着，我们需要将搜索到的路径打印出来，使得用户可以看到从起点到终点的路径。 最后，我们需要将代码进行测试，确保程序的正确性。在测试中，需要考虑各种情况，如迷宫地图的大小、迷宫的难易程度等。 通过这个案例，我们可以更好地掌握数据结构和算法的应用，同时也可以提高编程的能力和代码的可读性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小丶象

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值