深度优先与广度优先搜索算法简单复习

paradox_1_0

于 2020-03-29 17:02:37 发布

阅读量140

点赞数

CC 4.0 BY-SA版权

分类专栏：【数据结构】【算法】

本文链接：https://blog.youkuaiyun.com/paradox_1_0/article/details/105181722

【算法】同时被 2 个专栏收录

114 篇文章

订阅专栏

【数据结构】

7 篇文章

订阅专栏

本文介绍了一种使用邻接矩阵表示的有向图，并通过C++代码展示了如何实现广度优先搜索（BFS）和深度优先搜索（DFS）。代码中详细解释了如何使用队列和集合来跟踪遍历过程，以及如何避免重复访问节点。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

测试有向图，代码表示使用邻接矩阵。

算法代码：

#include<Windows.h>
#include<stdio.h>
#include<stdlib.h>
#include<iostream>

/* stl */
#include<vector>
#include<algorithm>
#include<queue>
#include<deque>
#include<stack>
#include<list>
#include<map>

#include<unordered_map>
#include<unordered_set>

using namespace std;

// 使用邻接矩阵广度优先遍历
void my_bfs(const vector<vector<int>>& g, int start_)
{
        queue<int> q_;
        std::unordered_set<int> check_;

        q_.push(start_);
        check_.insert(start_);

        while (q_.size()) {

                int n = q_.front();
                cout << n << " ";

                for (int i = 0; i < g.size(); i++) {

                        if (g[n][i] > 0 && check_.find(i) == check_.end()) {

                                q_.push(i);
                                check_.insert(i);
                        }
                }
                q_.pop();
        }
}

// 使用邻接矩阵的深度优先遍历

std::unordered_set<int> check_;

void my_dfs(const vector<vector<int>>& g, int start_)
{
        cout << start_ << " ";
        check_.insert(start_);

        for (int i = 0; i < g.size(); i++) {

                if (g[start_][i] > 0 && check_.find(i) == check_.end())
                        my_dfs(g, i);
        }
}

int main(int argc, char* argv[])
{

        vector<vector<int>> g_{ {1,1,1,0,0},
                                {0,1,0,1,1},
                                {0,0,1,0,0},
                                {0,0,0,1,1},
                                {0,0,1,0,1} 
                              };

        //my_bfs(g_, 3);
        my_dfs(g_, 4);
	return 0;
}