Breadth First Search and Depth First Search - algorithm

Question

Can anybody give a link for a simple explanation on BFS and DFS with its implementation?

Answer 1

Depth First Search:

Answer 2

Lets say you are given the following structure:
Format: Node [Children]
A [B C D]
B [E F]
C [G]
D []
E []
F []
G []
A breadth first search visits all of a node's children before visiting their children. Here's the pseudocode and the solution for the above structure:
1. Enqueue root node.
2. Dequeue and output. If the queue is empty, go to step 5.
3. Enqueue the dequeued node's children.
4. Go to Step 2.
5. Done
Two queues: (Active Node) [Output] [Working Set]
Starting with root:
( ) [] [A]
(A) [A] [B C D]
(B) [A B] [C D E F]
(C) [A B C] [D E F G]
(D) [A B C D] [E F G]
(E) [A B C D E] [F G]
(F) [A B C D E F] [G]
(G) [A B C D E F G] []
Done
A depth first search visits the lowest level (deepest children) of the tree first instead. There are two types of depth first search: pre-order and post-order. This just differentiates between when you add the node to the output (when you visit it vs leave it).
var rootNode = structure.getRoot();
var preOrder = new Array();
var postOrder = new Array();
function DepthFirst( rootNode ){
// Pre-order
preOrder[ preOrder.length ] = rootNode;
for( var child in rootNode ){
DepthFirst( child );
}
// Post-order
postOrder[ postOrder.length ] = rootNode;
}
Pre-order:
* A B E F C G D
Post-order:
* E F B G C D A

Answer 3

Say you have a tree as follows:
It may be a little confusing because E is both a child of A and F but it helps illustrate the depth in a depth first search. A depth first search searches the tree going as deep (hence the term depth) as it can first. So the traversal left to right would be A, B, D, F, E, C, G.
A breadth first search evaluates all the children first before proceeding to the children of the children. So the same tree would go A, B, C, E, D, F, G.
Hope this helps.

Answer 4

you can find everything on wiki:
BFS and DFS
this link can be useful too. if you want an implementation go to: c++ boost library: DFS

Answer 5

Here are a few links to check out:
Breadth-first search
BFS is an uninformed search method that aims to expand and examine all nodes of a graph or combination of sequences by systematically searching through every solution. In other words, it exhaustively searches the entire graph or sequence without considering the goal until it finds it.
Depth-first search
Formally, DFS is an uninformed search that progresses by expanding the first child node of the search tree that appears and thus going deeper and deeper until a goal node is found, or until it hits a node that has no children. Then the search backtracks, returning to the most recent node it hasn't finished exploring
Not only do they contain good explanations on how they are implemented in applications but also some algorithm pseudo code.

Answer 6

Breadth First Search/Depth First Search Animations

Answer 7

graph traversal with dfs and bfs.
in c++ and python.

Answer 8

Heres the idea in basics:
get a new queue ...initalize it with the root node .... loop through the entire queue and keep removing an item from the queue and printing it out (or saving it etc) and check if the same item has any children , if so push them onto the queue and continue in the loop until you traverse the entire segment(graph)...

Answer 9

snippet with 2 pointers.
void BFS(int v,struct Node **p)
{
struct Node *u;
visited[v-1] = TRUE;
printf("%d\t",v);
AddQueue(v);
while(IsEmpty() == FALSE)
{
v = DeleteQueue();
u = *(p+v-1);
while(u!=NULL)
{
if(visited(u->data -1) == FALSE)
{
AddQueue(u->data);
visited[u->data -1]=TRUE;
printf("%d\t",u->data);
}
u = u->next;
}
}
}

Answer 10

BFS and DFS are applicable to all kinds of graphs. I explain it for binary tree only. BFS visit each node top to bottom, left to right. For example for this:
1
/ \
7 9
\ / \
8 2 3
BFS gives us: 1 7 9 8 2 3. DFS visits depth of each branch first. Then, it comes back to its parents. You can follow this informal rule. First left child then right child then parent. But, you need to start from the depth of each branch. For example, here you start from 8, since there is no left child for 7. Then, you visit parent 7. Then, 1 parent of 7 will be visited. Then, you go to right branch. But, this time there is 2 as the left most child. So, you visit 2 (left child) then, right child 3 then, 9 their parents. So, DFS gives us 8 7 1 2 9 3. This is the implementation:
import java.util.ArrayList;
import java.util.List;
public class TreeTraverse {
static class Node{
Node(int data){
this.data = data;
this.left = null;
this.right = null;
this.visited = false;
}
int data;
Node left;
Node right;
boolean visited;
}
public static void main(String[] args) {
//The tree:
// 1
// / \
// 7 9
// \ / \
// 8 2 3
Node node1 = new Node(1);
Node node7 = new Node(7);
Node node9 = new Node(9);
Node node8 = new Node(8);
Node node2 = new Node(2);
Node node3 = new Node(3);
node1.left = node7;
node1.right = node9;
node7.right = node8;
node9.right = node3;
node9.left = node2;
System.out.println("DFS: ");
depthFirstSearch(node1);
System.out.println("\nBFS: ");
breadthFirstSearch(node1);
}
private static void depthFirstSearch(Node node){
if(node.left == null && node.right == null){
System.out.print(node.data+" ");
node.visited = true;
}else if(node.left == null || node.left.visited){
depthFirstSearch(node.right);
System.out.print(node.data+" ");
node.visited = true;
}else{
depthFirstSearch(node.left);
node.visited = true;
System.out.print(node.data+" ");
depthFirstSearch(node.right);
}
}
private static void breadthFirstSearch(Node node){
List<Node> al = new ArrayList<>();
al.add(node);
while(!al.isEmpty()){
node = al.get(0);
if(node.left != null){
int index = al.size();
al.add(index,node.left);
}
if(node.right != null){
int index = al.size();
al.add(index,node.right);
}
System.out.print(al.get(0).data+" ");
al.remove(0);
}
}
}
I hope it helps. If you want to clone the project, please visit: https://github.com/m-vahidalizadeh/foundations/blob/master/src/algorithms/TreeTraverse.java. I hope it helps.

Answer 11

First of all, BFS and DFS are two ways to implement binary tree traversal. Breadth First means level order traversal. Depth First has three ways to implemnt -- , , .
Preorder:
a. Start with root,
b. mark it visited,
c. go to left node
d. (b) - mark it visited
e. Repeat (c) till there is not any new left node remaining
(We are/might be at leaf node at this point,)
f. Is there any right node available? If yes, go to (a).
Level Order Traversal
Time Complexity
O(n)- Number of times each node is visited is 1 only, means total is n times.
Space Complexity-
Best Case: Tree only left nodes, is O(1)
Average Case: Perfect binary tree is example, n/2 number of nodes, O(n)