[Algorithms] Graph Traversal (BFS and DFS)
Graph is an important data structure and has many important applications. Moreover, grach traversal is key to many graph algorithms. There are two systematic ways to traverse a graph, breadth-first search (BFS) and depth-frist search (DFS).
Before focusing on graph traversal, we first determine how to represent a graph. In fact, there are mainly two ways to represent a graph, either using adjacency lists or adjacency matrix.
An adjacency list is an array of lists. Each list corresponds to a node of the graph and stores the neighbors of that node.
For example, for the (undirected) graph above, its representation using adjacency lists can be:
0: 1 -> 3 -> NULL
1: 0 -> 2 -> NULL
2: 1 -> NULL
3: 0 -> 4 -> 5 -> NULL
4: 3 -> 5 -> 6 -> NULL
5: 3 -> 4 -> 6 -> 7 -> NULL
6: 4 -> 5 -> 7 -> NULL
7: 5 -> 6 -> NULL
An adjacency matrix is a matrix of size m by m (m is the number of nodes in the graph) and the (i, j)-the element of the matrix represents the edge from node i to node j.
For the same graph above, its representation using adjacency matrix is:
0 1 0 1 0 0 0 0
1 0 1 0 0 0 0 0
0 1 0 0 0 0 0 0
1 0 0 0 1 1 0 0
0 0 0 1 0 1 1 0
0 0 0 1 1 0 1 1
0 0 0 0 1 1 0 1
0 0 0 0 0 1 1 0
In this passage, we use adjacency lists to represent a graph. Specifically, we define the node of the graph to be the following structure:
struct GraphNode {
int label;
vector<GraphNode*> neighbors;
GraphNode(int _label) : label(_label) {}
};
Now let's move on to BFS and DFS.
As suggested by their names, BFS will first visit the current node, then its neighbors, then the non-visited neighbors of its neighbors... and so on in a breadth-first manner while DFS will try to move as far as possible from the current node and backtrack when it cannot move forward any more (all the neighbors of the current node has been visited).
The implementation of BFS requries the use of the queue data structure while the implementation of DFS can be done in a recursive manner.
For more details on BFS and DFS, you may refer to Introduction to Algorithms or these two nice videos: BFS video and DFS video.
In my implementation, BFS starts from a single node and visits all the nodes reachable from it and returns a sequence of visited nodes. However, DFS will try to start from every non-visited node in the graph and starts from that node and obtains a sequence of visited nodes for each starting node. Consequently, the function bfs returns a vector<GraphNode*> while the function dfs returns a vector<vector<GraphNode*> >.
I also implement a function read_graph to input the graph manually. For the above graph, you first need to input its number of nodes and number of edges. Then you will input each of its edge in the form of "0 1" (edge from node 0 to node 1).
The final code is as follows.
#include <iostream>
#include <vector>
#include <queue>
#include <unordered_set> using namespace std; struct GraphNode {
int label;
vector<GraphNode*> neighbors;
GraphNode(int _label) : label(_label) {}
}; vector<GraphNode*> read_graph(void) {
int num_nodes, num_edges;
scanf("%d %d", &num_nodes, &num_edges);
vector<GraphNode*> graph(num_nodes);
for (int i = ; i < num_nodes; i++)
graph[i] = new GraphNode(i);
int node, neigh;
for (int i = ; i < num_edges; i++) {
scanf("%d %d", &node, &neigh);
graph[node] -> neighbors.push_back(graph[neigh]);
graph[neigh] -> neighbors.push_back(graph[node]);
}
return graph;
} vector<GraphNode*> bfs(vector<GraphNode*>& graph, GraphNode* start) {
vector<GraphNode*> nodes;
queue<GraphNode*> toVisit;
unordered_set<GraphNode*> visited;
toVisit.push(start);
visited.insert(start);
while (!toVisit.empty()) {
GraphNode* cur = toVisit.front();
toVisit.pop();
nodes.push_back(cur);
for (GraphNode* neigh : cur -> neighbors) {
if (visited.find(neigh) == visited.end()) {
toVisit.push(neigh);
visited.insert(neigh);
}
}
}
return nodes;
} bool visitAllNeighbors(GraphNode* node, unordered_set<GraphNode*>& visited) {
for (GraphNode* n : node -> neighbors)
if (visited.find(n) == visited.end())
return false;
return true;
} void dfs_visit(vector<GraphNode*>& graph, GraphNode* node, \
unordered_set<GraphNode*>& visited, vector<GraphNode*>& tree, \
vector<vector<GraphNode*> >& forest) {
visited.insert(node);
tree.push_back(node);
if (visitAllNeighbors(node, visited)) {
forest.push_back(tree);
tree.clear();
return;
}
for (GraphNode* neigh : node -> neighbors)
if (visited.find(neigh) == visited.end())
dfs_visit(graph, neigh, visited, tree, forest);
} vector<vector<GraphNode*> > dfs(vector<GraphNode*>& graph) {
vector<GraphNode*> tree;
vector<vector<GraphNode*> > forest;
unordered_set<GraphNode*> visited;
for (GraphNode* node : graph)
if (visited.find(node) == visited.end())
dfs_visit(graph, node, visited, tree, forest);
return forest;
} void graph_test(void) {
vector<GraphNode*> graph = read_graph();
// BFS
printf("BFS:\n");
vector<GraphNode*> nodes = bfs(graph, graph[]);
for (GraphNode* node : nodes)
printf("%d ", node -> label);
printf("\n");
// DFS
printf("DFS:\n");
vector<vector<GraphNode*> > forest = dfs(graph);
for (vector<GraphNode*> tree : forest) {
for (GraphNode* node : tree)
printf("%d ", node -> label);
printf("\n");
}
} int main(void) {
graph_test();
system("pause");
return ;
}
If you input the above graph to it as follows (note that you only need to input each edge exactly once):
The output will be as follows:
BFS: DFS:
You may check it manually and convince yourself of its correctness :)
[Algorithms] Graph Traversal (BFS and DFS)的更多相关文章
- Clone Graph leetcode java(DFS and BFS 基础)
题目: Clone an undirected graph. Each node in the graph contains a label and a list of its neighbors. ...
- [LeetCode] 785. Is Graph Bipartite?_Medium tag: DFS, BFS
Given an undirected graph, return true if and only if it is bipartite. Recall that a graph is bipart ...
- BFS 、DFS 解决迷宫入门问题
问题 B: 逃离迷宫二 时间限制: 1 Sec 内存限制: 128 MB提交: 12 解决: 5[提交][状态][讨论版] 题目描述 王子深爱着公主.但是一天,公主被妖怪抓走了,并且被关到了迷宫. ...
- BFS和DFS详解
BFS和DFS详解以及java实现 前言 图在算法世界中的重要地位是不言而喻的,曾经看到一篇Google的工程师写的一篇<Get that job at Google!>文章中说到面试官问 ...
- 【数据结构与算法】自己动手实现图的BFS和DFS(附完整源码)
转载请注明出处:http://blog.csdn.net/ns_code/article/details/19617187 图的存储结构 本文的重点在于图的深度优先搜索(DFS)和广度优先搜索(BFS ...
- BFS与DFS常考算法整理
BFS与DFS常考算法整理 Preface BFS(Breath-First Search,广度优先搜索)与DFS(Depth-First Search,深度优先搜索)是两种针对树与图数据结构的遍历或 ...
- HDU-4607 Park Visit bfs | DP | dfs
题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=4607 首先考虑找一条最长链长度k,如果m<=k+1,那么答案就是m.如果m>k+1,那么最 ...
- 算法录 之 BFS和DFS
说一下BFS和DFS,这是个比较重要的概念,是很多很多算法的基础. 不过在说这个之前需要先说一下图和树,当然这里的图不是自拍的图片了,树也不是能结苹果的树了.这里要说的是图论和数学里面的概念. 以上概 ...
- hdu--1026--Ignatius and the Princess I(bfs搜索+dfs(打印路径))
Ignatius and the Princess I Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (J ...
随机推荐
- app中h5交互的一些坑 记录笔记
1.ios开发镶嵌 h5页面 存在input 圆角问题(安卓直角) 解决办法 inpput{ -webkit-appearance: none; border-radius: 0px; } 2.ios ...
- unity, break prefab instance
菜单->GameObject->Break Prefab Instance,可以打断prefab实例与prefab的连接. 一个用处是:比如想从sceneA拷贝一部分Hierarchy结构 ...
- Windows 2003 远程桌面
- JS继承的6种方法
1.原型链 基本思想:利用原型让一个引用类型继承另外一个引用类型的属性和方法. 构造函数,原型,实例之间的关系:每个构造函数都有一个原型对象,原型对象包含一个指向构造函数的指针,而实例都包含一个指向原 ...
- JSON资料整理(转载)
目录 1.什么是json 2.json语法规则 3.json基础结构 4.json基础示例 5.JSON和XML比较 6. .NET操作JSON 原始方式 通用方式 内置方式 契约方式 通过序列化将. ...
- linux常用命令系列
自己开始接触linux系统已经两年了,刚到现场进行系统维护的时候,只知道ls和cd命令,所以我被迫开始学习linux,虽然现在每天都在linux系统上进行一些操作,但是感觉自己半路出家一样:可能知道某 ...
- Zabbix exp编写
#/usr/bin/python #*-*coding=utf-8*-* import urllib logo = '''\n _____ _ _ _ _____ _ |__ /__ _| |__ | ...
- 跟着百度学PHP[14]-PDO的预处理语句2
在$sql = $pdo -> prepare("insert into users(gold,user,password) values(?,?,?)"):条语句我们不仅仅 ...
- 使用uGUI系统玩转标准俄罗斯方块
使用uGUI系统玩转标准俄罗斯方块 笔者使用的Unity3D版本是4.6b17.由于一些工作上的一些事情导致制作的进度被严重滞后.笔者实际用于开发俄罗斯方块的时间,大概也就2-3天吧. 开始前的准备 ...
- 基于jQuery的让非HTML5浏览器支持placeholder属性的代码(转)
效果图:http://code.google.com/p/jquery-placeholder-js/ 演示代码:http://demo.jb51.net/js/2011/jqueryplacehol ...