C++处理迷宫问题（创建，dfs寻路，bfs寻路）

已于 2023-07-19 12:25:19 修改
阅读量419 收藏 3
点赞数 3
文章标签： c++ 数据结构 课程设计
于 2023-07-15 10:34:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/beijieyu/article/details/131736053
版权 
#include<iostream>
#include<algorithm>
#include<cstring>
#include<math.h>
#include<stdio.h>
#include<stdlib.h>
#include<Windows.h>
#include<conio.h>
#include<graphics.h>
#include <random>
#include <functional>
#define MaxSize 10010
#define side 101

using namespace std;
typedef struct
{
    int x, y, la;
}position;
typedef struct {
    position data[MaxSize];
    int front, rear;
}Queue;
char maze[side][side] = {};
char maze1[side][side] = {};
int dy[4] = { 1,0,-1,0 };
int dx[4] = { 0,1,0,-1 };
bool fi[side][side] = { };
int m, n;
int way_proportion = 70;
bool find_ = true;
void create_Maze();//创建迷宫
void  print_maze();//输出迷宫
void reduction_maze();//还原迷宫/赋值副本
void initialize_maze();//初始化墙
void  initQueue(Queue& que);
void enQueue(Queue& q, position d);
void deQueue(Queue& q);
void dfs_find_way(int x, int y);
void bfs_find_way();
void getsize();//获取m,n
void create_maze_dfs(int x,int y);
void dfs_create(int row, int col);
void  mgpath(int xi, int yi, int xe, int ye);

struct Node {
    int x; // 当前节点的 x 坐标
    int y; // 当前节点的 y 坐标
    int dir; // 下一个坐标方向
    Node* next; // 指向下一个节点的指针
};

class LinkedStack {
private:
    Node* top; // 栈顶节点指针

public:
    LinkedStack() {
        top = nullptr;
    }

    bool isEmpty() {
        return top == nullptr;
    }

    void push(int x, int y, int dir) {
        Node* newNode = new Node;
        newNode->x = x;
        newNode->y = y;
        newNode->dir = dir;
        newNode->next = top;
        top = newNode;
    }

    void pop() {
        if (isEmpty()) {
            return;
        }
        Node* temp = top;
        top = top->next;
        delete temp;
    }

    Node* getTop() {
        return top;
    }
};
//寻路8
void mgpath(int startX, int startY, int endX, int endY) {
   
    LinkedStack stack;
    stack.push(startX, startY, 0);
    maze1[startX][startY] =maze1[endX][endY]= ' ';
    bool foundPath = false;

    while (!stack.isEmpty()) {
        Node* top = stack.getTop();
        int x = top->x;
        int y = top->y;
        int dir = top->dir;
        // 到达终点
        if (x == endX && y == endY) {
            // 打印路径
            maze1[1][1] = 'S';
            maze1[m - 2][n - 2] = 'E';
            print_maze();
            cout << "路径: ";
            while (!stack.isEmpty()) {
                Node* node = stack.getTop();
                cout << "(" << node->x << "," << node->y << ") ";
                stack.pop();
            }
            cout << endl;
            foundPath = true;
            break;
        }
        bool found = false;
        // 尝试四个方向的移动：右、下、左、上
        for (int i = dir; i < 4; i++) {
            if (i == 0 && y + 1 < n && maze1[x][y + 1] == ' ') {
                stack.push(x, y + 1, 0); // 向右走
                maze1[x][y + 1] = '@';
                found = true;
                break;
            }
            else if (i == 1 && x + 1 < m && maze1[x + 1][y] == ' ') {
                stack.push(x + 1, y, 0); // 向下走
                maze1[x + 1][y] = '@';
                found = true;
                break;
            }
            else if (i == 2 && y - 1 >= 0 && maze1[x][y - 1] == ' ') {
                stack.push(x, y - 1, 0); // 向左走
                maze1[x][y - 1] = '@';
                found = true;
                break;
            }
            else if (i == 3 && x - 1 >= 0 && maze1[x - 1][y] == ' ') {
                stack.push(x - 1, y, 0); // 向上走
                maze1[x - 1][y] = '@';
                found = true;
                break;
            }
        }
        if (!found) {
            // 如果四个方向都不能移动，回溯
            stack.pop();
            maze1[x][y] = 'V';
        }
        else {
            // 更新下一个坐标方向
            top->dir = dir + 1;
        }
        HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
        // 设置控制台窗口缓冲区大小
        COORD bufferSize = { 120, 120 };
        SetConsoleScreenBufferSize(hOut, bufferSize);
        print_maze();
    }
    if (!foundPath) {
        // 没有找到路径
        cout << "没有找到路径" << endl;
    }
}
//改比例
void change_way_proportion()
{
    while (1)
    { cout << "请输入路径比例" << endl;
        cin >> way_proportion;
        if (way_proportion <= 0 || way_proportion > 99)
        {
            cout << "数值不规范" << endl;
            continue;
        }
        break;
    }
    create_Maze();
    print_maze();
    return;
}
//初始化
void initialize_maze()//初始化
{
    for (int i = 0;i < m;i++)
    {
        for (int j = 0;j < n;j++)
        {
            maze[i][j] = '#';
        }
    }
    maze[1][1] = 'S';
    maze[m - 2][n - 2] = 'E';
}//初始化迷宫
int IsHaveNeighbor(int X_index, int Y_index)//判断是否有邻居
{
        if ((X_index >= 3 && maze[X_index - 2][Y_index] == '#') || (X_index < m - 3 && maze[X_index + 2][Y_index] == '#') || (Y_index >= 3 && maze[X_index][Y_index - 2] == '#') || (Y_index < n - 3 && maze[X_index][Y_index + 2] == '#'))
            return 1;//有邻居
        return 0;      
}
void dfs_create(int X_index, int Y_index){
    int rand_position, x, y, flag = 0;
    x = X_index;
    y = Y_index;
    //如果四个方向都没有了，返回上一步的xy，否则，继续
    while (1)
    {
        flag = IsHaveNeighbor(X_index, Y_index);
        if (flag == 0)
        {
            return;//返回该函数的上一条
        }
        else
        {
            maze[X_index][Y_index] =' ';
            while (1)
            {
                rand_position = rand() % 4;
                if (rand_position == 0 && X_index >= 3 && maze[X_index - 2][Y_index] == '#')//上
                {
                    X_index = X_index - 2;
                }
                else if (rand_position == 1 && X_index < m- 3 && maze[X_index + 2][Y_index] == '#')//下
                {
                    X_index = X_index + 2;
                }
                else if (rand_position == 2 && Y_index >= 3 && maze[X_index][Y_index - 2] == '#')//左
                {
                    Y_index -= 2;
                }
                else if (rand_position == 3 && Y_index < n - 3 && maze[X_index][Y_index + 2] == '#')//右
                {
                    Y_index += 2;
                }
                maze[(x + X_index) / 2][(y + Y_index) / 2] =' ';//当前位置，移动后位置中间位置打通，表示路径
                maze[X_index][Y_index] = ' ';
                dfs_create(X_index, Y_index);
                break;
            }
        }
    }
}
void create_maze_dfs(int rows,int columns)
{
    initialize_maze();
    random_device rd;
    mt19937 generator(rd());

    int start_row = generator() % rows;
    int start_col = generator() % columns;

    dfs_create( start_row, start_col); // 调用DFS算法生成迷宫
    maze[1][2] = ' ';
    maze[2][1] = ' ';
    maze[m-2][n-3] = ' ';
    maze[m-3][n-2] = ' ';
    maze[1][1] = 'S';
    print_maze();
}
void deQueue(Queue& q)
{
    q.front++;
}
void enQueue(Queue& q, position d)
{
    q.data[q.rear] = d;
    q.rear++;
}
void  initQueue(Queue& que) {
    que.front = que.rear = 0;
}
void reduction_maze()
{
    for (int i = 1; i < m - 1; ++i) {
        for (int j = 1; j < n - 1; ++j)
        {
            maze1[i][j] = maze[i][j];
        }
    }
    print_maze();
}
void  print_maze()
{
    Sleep(20);
    system("cls");
    int i = 0, j = 0;
    for (i = 0; i < m; i++)
    {
        for (j = 0; j < n; j++)
        {
            if (maze1[i][j] == 'S'|| maze1[i][j] == 'E')
            {
                SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_BLUE);
                cout << "█ ";
            }
            else if (maze1[i][j] == '#')
            {
                SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_RED);
                cout << "█ ";
            }
            else if (maze1[i][j] == ' ')
            {
                SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_GREEN);
                cout << "█ ";
            }
            else if (maze1[i][j] == 'V')
            {
                SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN);
                cout << "█ ";
            }
            else if (maze1[i][j] == '@')
            {
                SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_BLUE);
                cout << "█ ";
            }
          // cout << maze1[i][j] << " ";
        }
        cout << endl;
    }
    cout<< "***********星树***************" << endl
        << "*  输入1重新随机生成迷宫     *" << endl
        << "*  输入2生成基于DFS迷宫      *" << endl
        << "*  输入3还原迷宫             *" << endl
        << "*  输入4深搜                 *" << endl
        << "*  输入5广搜                 *" << endl
        << "*  输入6修改迷宫大小         *" << endl
        << "*  输入7修改可行路径比例     *" << endl
        << "*  输入8非递归寻路           *" << endl
        << "*  输入q退出                 *" << endl
        << "******************************" << endl;
    //system("pause");
}
void create_Maze() {
    // 初始化迷宫为墙
    initialize_maze();
    // 随机生成路径
    srand(time(NULL));
    for (int i = 1; i < m - 1; i++) {
        for (int j = 1; j < n - 1; j++) {

            // 生成0~99之间的随机数
            int randomNumber = rand() % 100;
            if (randomNumber < way_proportion&& maze[i][j]=='#') {  // 50%的概率生成路径
                maze[i][j] = ' ';
            }
        }
    }
   
   
    for (int i = 0; i < m; ++i) {
        for (int j = 0; j < n; ++j)
        {
            maze1[i][j] = maze[i][j];
        }
    }
}
void dfs_find_way(int x, int y)
{
    if (find_)
    {
        return;
    }
    else {
        for (int i = 0;i < 4;i++)
        {

            int nextx = x + dx[i], nexty = y + dy[i];
            if (maze1[nextx][nexty] == 'E')
            {
                find_ = true;
                return;
            }
            if (maze1[nextx][nexty] == ' ' && !fi[nextx][nexty] && !find_)
            {
                maze1[nextx][nexty] = '@';

                HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
                // 设置控制台窗口缓冲区大小
                COORD bufferSize = { 120, 120 };
                SetConsoleScreenBufferSize(hOut, bufferSize);

                print_maze();
                fi[nextx][nexty] = true;
                dfs_find_way(nextx, nexty);
                if (!find_)
                    maze1[nextx][nexty] = 'V';
            }

       }
    }
}
void bfs_find_way()
{
    reduction_maze();
    Queue que;
    position d;
    d.x = 1;
    d.y = 1;
    d.la = 0;
    initQueue(que);
    enQueue(que, d);
    while (que.front != que.rear)
    {
        auto fr = que.data[que.front];
        for (int i = 0;i < 4;i++)
        {
            d.x = fr.x + dx[i];
            d.y = fr.y + dy[i];
            if (maze1[d.x][d.y] == ' ')
            {
                d.la = que.front;
                enQueue(que, d);
                maze1[d.x][d.y] = 'V';
            }
            if (maze1[d.x][d.y] == 'E')
            {
                int  lt = que.front;
                while (que.data[lt].la != 0) {
                    maze1[que.data[lt].x][que.data[lt].y] = '@';
                    lt = que.data[lt].la;
                }

                maze1[que.data[lt].x][que.data[lt].y] = '@';

                HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
                // 设置控制台窗口缓冲区大小
                COORD bufferSize = { 120, 120 };
                SetConsoleScreenBufferSize(hOut, bufferSize);


                print_maze();
                cout << "已找到路径" << endl;
                return;
            }
        }
        HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
        // 设置控制台窗口缓冲区大小
        COORD bufferSize = { 120,120 };
        SetConsoleScreenBufferSize(hOut, bufferSize);
        print_maze();
        deQueue(que);
    }
    cout << "无路径" << endl;
    return;
}
void getsize()
{
    while (1)
    {
        cout << "请输入迷宫的长（5-100)：" << endl;
        cin >> m;
        cout << "请输入迷宫的宽（5-100)：" << endl;
        cin >> n;
        if (m <=4 || n <=4)
        {
            cout << "迷宫太小了";
            continue;
        }
        if (m >= 100 || n >= 100)
        {
            cout << "迷宫太大了";
            continue;
        }
        break;
    }
}
int main()
{ 
    while (1)
    {
        getsize();
        create_Maze();
        print_maze();
        while (true)
        {
            char c;
            cin >> c;
            switch (c)
            {
            case '1'://重新生成迷宫
                create_Maze();
                print_maze();
                break;
            case'2'://dsf生成     
                create_maze_dfs(m,n);
                reduction_maze();
                break;
            case'3'://还原迷宫
                reduction_maze();
                break;
            case'4'://dfs
                reduction_maze();
                find_ = false;
                memset(fi, false, sizeof(fi));
                dfs_find_way(1, 1);
                if (!find_)
                    cout << "无路径" << endl;
                else
                    cout << "已找到路径" << endl;
                break;
            case'5'://bfs
                bfs_find_way();
                break;
            case'6'://改尺寸
                getsize();
                create_Maze();
                print_maze();
                break;
            case'7'://改比例
                change_way_proportion();
                create_Maze();
                break;
            case'8':
                reduction_maze();
                mgpath(1,1,m - 2, n - 2);
                break;
            case'q'://退出
                return 0;
            default:
                string error_in;
                cin >> error_in;
                cout << "输入错误" << endl;
                break;
            }
        }
    }
}

‘#’为墙

‘@’为路径

‘S'E’分别为起点终点

‘V’为可到达的点

星夜下的琼瑶树
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
c++迷宫问题（bfs算法）
weixin_43500528的博客
04-12 6642
迷宫问题 问题描述： 定义一个二维数组： int maze[5][5] = { 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, }; 它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。 Inp...
c++深搜1-迷宫类问题
Mark1277的博客
06-11 3707
深搜-迷宫类问题
迷宫问题（C++）： 最短路径计算（队列）&& 路径输出（栈）（附一个易错点~）
最新发布
H13420972436的博客
04-07 512
回溯路径的原理：从出口开始，在re_bd（PS: re_bd[ i ][ j ]用来记忆从起点到第 i 行第 j 列的最短路径长度）里找周围八个方向中路径长度少1的点， 故一般情况可用以下代码非注释部分来判断。~都看到这啦， 你一定是个超级认真的友友，关注一下吧~ 😋ღ ʕ̡̢̡•̫͡•ʔ̢̡̢ ღ😋。”， 在re_bd == 1 时就结束寻找，在printf栈元素之前先print一下起点坐标。1.补充上面被注释掉的“if(org == 0) // 如果是起点”部分， 将起点。在于最短路径的回溯过程。
C++迷宫问题完全详解
weixin_42163707的博客
12-20 2145
深度优先搜索（DFS）和广度优先搜索（BFS）是两种常用的图遍历算法，适用于不同的问题和场景。广度优先使用的是Queue队列，队列是一种先进先出(First In First Out,FIFO)的数据结构，它有两个出口。这里使用了栈，stack是一种先进后出(First In Last Out,FILO)的数据结构，它只有一个出口。迷宫我们都玩过，有些复杂的看的眼花缭乱，但是有没有想过，让机器帮你完成这个工作，想着就很酷，好，在实际应用中，根据问题的特点和需求，选择合适的算法来进行图遍历是非常重要的。
【C++数据结构】 基于栈与深度优先搜索算法实现的迷宫问题
weixin_66397563的博客
12-07 1151
基于栈与深度优先搜索算法实现的迷宫问题：
C/C++实现dfs(迷宫问题 最短路径)超级详细
wfuzhuandaaliu的博客
01-02 8324
C/C++实现dfs(迷宫问题 最短路径)超级详细
迷宫问题，可以用队列找到所有路径么？c/c++描述
zhangzhangkeji的博客
06-14 1416
  本号最近总结过关于迷宫问题的多种解法，栈啊，递归啊，队列啊。深度优先啊，广度优先啊，最短路径和所有路径。我们知道用栈的方法是可以找到迷宫里从入口到出口的所有路径，用队列可以找到最短路径。那么用队列是否也能找到所有路径呢？   答案是可以的。以前我认为不可以，因为对比栈的查找所有路径，找到一条路径后，要进行退栈，回溯，同时把退栈的空格（迷宫由墙壁和空格组成，空格表示可以走的路径）改为可用，以遍别的路径能继续使用这些空格。同时考察路径中的空格是否有剩余的方向也是空格，是否可以加入栈，组成新路径。那么在队列里
C++-VS2019-迷宫寻路BFS+DFS代码.zip
07-22
最终效果是实现了Prim随机生成迷宫，BFS&DFS路径显示、最短路长度显示、过程动态展示，主函数中有菜单，操作方便。 不仅可以用来读代码长知识、还可以用作算法演示。 附带第五版的exe文件，欢迎使用！
迷宫寻路问题C++源码
08-31
在IT领域，迷宫寻路问题是一个经典...通过分析和运行这段代码，我们可以深入理解C++如何处理复杂的问题，并掌握DFS、BFS以及可能的A*算法的实现细节。对于计算机科学的学生和程序员来说，这是提升算法技能的重要实践。
迷宫寻路，从起点寻路到出口
11-17
本文将深入探讨迷宫寻路问题，包括其基本概念、常见算法以及如何使用C和C++编程语言进行实现。 首先，迷宫寻路问题可以抽象为一个二维网格或图，其中每个节点代表一个位置，而边则表示相邻的位置。迷宫的起点和终点...
迷宫自动寻路mfc
11-09
DFS和BFS在解决迷宫问题时都能找到路径，但BFS通常能找到最短路径，因为它按照距离目标节点的顺序进行搜索。A*算法则更高效，它结合了BFS的全局最优性和DFS的局部搜索效率，通过启发式函数预估每个节点到达目标的...
C++迷宫问题的求解算法
12-20
本文实例为大家分享了C++实现迷宫的具体代码，供大家参考，具体内容如下 一、 实验目的： （1） 熟练掌握链栈的基本操作及应用。 （2） 利用链表作为栈的存储结构，设计实现一个求解迷宫的非递归程序。 二、实验内容： 【问题描述】 以一个m×n的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计一个程序，对信任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。 【基本要求】 首先实现一个链表作存储结构的栈类型，然后编写一个求解迷宫的非递归程序。求得的通路以三元组（i,j,d）的形式输出，其中：（i,j）指示迷宫中的一个坐标，d表示走到下一坐标的方向。如：对于下列数据的迷宫，输
迷宫求解输入一个任意大小的迷宫数据，求出一条走出迷宫的路径，并将路径输出。
06-12
迷宫求解 设计要求：输入一个任意大小的迷宫数据，求出一条走出迷宫的路径，并将路径输出。
迷宫c语言自动寻路并标记
12-26
对于迷宫问题，BFS通常比DFS更有效，因为它不会陷入死胡同。 在C语言中，我们首先定义迷宫数组，然后用两个指针（一个用于当前位置，一个用于记录前一个位置）来追踪路径。我们需要四个变量来记录方向：上、下、左...
C++迷宫寻路，利用顺序队，在迷宫中寻找一条从起点到终点的路。
weixin_51343683的博客
10-29 1618
C++迷宫寻路，利用顺序队，在迷宫中寻找一条从起点到终点的路。 因为用到队列解决问题，如果考虑到这个，必须要掌握队列的知识。所以关于队列的代码不多讲解。 迷宫寻路，算法的简单描述： 首先将起点保存到路类型的数组中，弹出起点路（因为不是环形队列，出队后仍在队列中（如果不明白可参考环形队列和顺序队的结构）），从起点开始上左下右的寻找路，找到可走的路之后保存到路类型的数组中，弹出最初找到的第一个路（非起点），然后寻找这个弹出的路的上左下右可走的路，然后保存到路类型的数组中，如此循环…如果这个弹出的路是终点，则触发
迷宫问题求解(C++非递归程序)
热门推荐
Wigou Lau
04-14 1万+
           　　　　　　　　迷宫问题求解(C++非递归程序)                一、【实验内容】【问题描述】      以一个m*n的长方阵表示迷宫，0，1分别表示迷宫中的通路和障碍。设计一个程序，对任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论，【基本要求】：首先实现一个以链表作存储结构的栈类型，然后编写一个求解迷宫的非递归的程序，求得的通
（C++）数据结构实验二——迷宫问题
Lemon_CHA的博客
11-11 1423
BFS算法迷宫 #include <iostream> #include <string> //#include <queue> #include "QueueBottom.h" #include <fstream> using namespace std; #include <iomanip> #include <Windows.h> #include <time.h> clock_t start,finish;
迷宫问题——回溯法（栈）C++
weixin_45887823的博客
05-31 1505
迷宫问题——回溯法（栈）C++ #include <iostream> #include <stack> using namespace std; //栈节点 typedef struct node { int x; //迷宫数组横坐标 int y; //迷宫数组纵坐标 int c; //前进方向 }StackNode; //linkstack top[n1*n2]; //初始化迷宫数组 const
回溯法写迷宫(C++编写)
weixin_41019383的博客
07-16 1069
回溯法写迷宫 迷宫规则： 唯一出口和入口，本次规定入口为左上角，出口为右下角 如下图所示，红色方块为墙，不能走，白色区域可以走 红色方块标志为1，白色区域标志为0 迷宫矩阵大小可以自己定义，如下定义的是5*5矩阵 要求找到最短路径并且输出路径坐标 回溯法 回溯法思路： 是将问题转化为树或者图的形式，然后利用深度优先搜索进行遍历，然后再遍历过程中记录所有可执行解和最优解 回溯法的实现方式：递...
用c++创建图并用DFS和BFS搜索
05-05
好的，下面是C语言实现的图的创建、DFS和BFS搜索的示例代码： ```c #include <stdio.h> #include <stdlib.h> #define MAX_VERTEX_NUM 100 // 最大顶点数 typedef struct ArcNode { // 边表节点 int adjvex; // 邻接点下标 struct ArcNode *next; // 指向下一个节点的指针 } ArcNode; typedef struct VNode { // 顶点表节点 int data; // 顶点数据 ArcNode *firstarc; // 边表头指针 } VNode, AdjList[MAX_VERTEX_NUM]; typedef struct { // 图 AdjList vertices; // 顶点表 int vexnum, arcnum; // 顶点数和边数 } Graph; // 创建图 void CreateGraph(Graph *G) { int i, j, k; ArcNode *p; printf("请输入图的顶点数和边数：\n"); scanf("%d%d", &G->vexnum, &G->arcnum); printf("请输入各个顶点的数据：\n"); for (i = 0; i < G->vexnum; i++) { scanf("%d", &G->vertices[i].data); G->vertices[i].firstarc = NULL; } printf("请输入各个边的两个顶点的下标：（如0 1，表示边<0,1>）\n"); for (k = 0; k < G->arcnum; k++) { scanf("%d%d", &i, &j); p = (ArcNode *)malloc(sizeof(ArcNode)); p->adjvex = j; p->next = G->vertices[i].firstarc; G->vertices[i].firstarc = p; p = (ArcNode *)malloc(sizeof(ArcNode)); p->adjvex = i; p->next = G->vertices[j].firstarc; G->vertices[j].firstarc = p; } } // DFS搜索 void DFS(Graph G, int v, int visited[]) { ArcNode *p; visited[v] = 1; printf("%d ", G.vertices[v].data); for (p = G.vertices[v].firstarc; p; p = p->next) { if (!visited[p->adjvex]) { DFS(G, p->adjvex, visited); } } } // BFS搜索 void BFS(Graph G, int v, int visited[]) { int queue[MAX_VERTEX_NUM], front = -1, rear = -1; ArcNode *p; visited[v] = 1; printf("%d ", G.vertices[v].data); queue[++rear] = v; while (front != rear) { v = queue[++front]; for (p = G.vertices[v].firstarc; p; p = p->next) { if (!visited[p->adjvex]) { visited[p->adjvex] = 1; printf("%d ", G.vertices[p->adjvex].data); queue[++rear] = p->adjvex; } } } } int main() { Graph G; int visited[MAX_VERTEX_NUM] = {0}; CreateGraph(&G); printf("DFS搜索结果为："); DFS(G, 0, visited); printf("\nBFS搜索结果为："); BFS(G, 0, visited); printf("\n"); return 0; } ``` 在上述代码中，我们使用了邻接表来表示图，其中`VNode`表示顶点表节点，`ArcNode`表示边表节点，`AdjList`是一个由`VNode`组成的数组，即邻接表。在创建图时，我们先输入顶点数和边数，然后输入各个顶点的数据和各个边的两个顶点的下标，根据下标构建边表。 接着，我们分别实现了DFS和BFS搜索。在DFS搜索中，我们先访问当前节点，并将其标记为已访问，然后遍历所有邻接点，若邻接点未被访问，则递归访问它。在BFS搜索中，我们使用队列来实现搜索。从起始节点开始，先访问该节点，并将其入队。然后从队列中依次取出节点，遍历其所有邻接点，若邻接点未被访问，则访问它并将其入队。 最后，在`main`函数中，我们调用`CreateGraph`函数创建图，并分别调用`DFS`和`BFS`函数进行搜索。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值