Breadth First Search (BFS) Depth First Search (DFS)
Data Structure Used Queue Stack
Traversal Level order Traversal

Inorder Traversal (Left-Root-Right)

Preorder Traversal (Root-Left-Right)

Postorder Traversal (Left-Right-Root)

Starts visiting nodes from root or leaves

Root

Leaves

When to use

If our problem is to search something that is more likely to closer to root. If the target node is close to a leaf, we would prefer DFS
Approach Iterative Reccursive
Shortes Path Problem BFS is more efficient than DFS. DFS is not recommended as it will start traversing from a leaf node.
Implementation

        //Search element with integer data
        private GraphNode SearchBFS(GraphNode node, int valueToCheck)
        {
            //validate node
            if (node == null)
            {
                return node;
            }

            Queue<GraphNode> nodesToProcess = new Queue<GraphNode>();
            //mark as visited
            node.MarkAsVisited = true;
            //Add first node/root to queue
            nodesToProcess.Enqueue(node);

            while (nodesToProcess.Count > 0)
            {
                GraphNode currentNode = nodesToProcess.Dequeue();

                //visit node
                if (currentNode.Value == valueToCheck)
                {
                    return currentNode;
                }

                foreach (GraphNode adjecentNode in currentNode.Childrens)
                {
                    if (!adjecentNode.MarkAsVisited)
                    {
                        adjecentNode.MarkAsVisited = true;
                        nodesToProcess.Enqueue(adjecentNode);
                    }
                }
                currentNode = nodesToProcess.Dequeue();
            }

            //Element/Node not found
            return null;
        }

        //Search element with integer data
        //Pre-Order traversal
        private GraphNode SearchDFS(GraphNode node, int valueToCheck)
        {
            //validate node
            if (node == null)
            {
                return node;
            }

            //visit node
            if (node.Value == valueToCheck)
            {
                return node;
            }

            //mark as visited
            node.MarkAsVisited = true;

            //Check for adjecent node
            foreach (GraphNode adjecentNode in node.Childrens)
            {
                if (!adjecentNode.MarkAsVisited)
                {
                    //Search reccursively starting with first adjucent node
                    return SearchDFS(adjecentNode, valueToCheck);
                }
            }

            //Element/Node not found
            return null;
        }

Space Complexity Extra Space required for Level Order Traversal is O(w) where w is a maximum width of Binary Tree.  Extra Space required for Depth First Traversals is O(h) where h is a maximum height of Binary Tree. 
Search the entire tree  

Depth First Search is commonly used when you need to search the entire tree. 

Lower memory requirements   DFS is that it has much lower memory requirements than BFS because it’s not necessary to store all of the child pointers at each level.
Example Finding the neighbor nodes in the peer to peer networks like Bit Torrent, GPS systems to find nearby locations, social networking sites to find people in the specified distance and things like that.

Games like Chess, tic-tac-toe when you are deciding what move to make, you can mentally imagine a move, then your opponent’s possible responses, then your responses, and so on. You can decide what to do by seeing which move leads to the best outcome.

Searching files in file system.

Temporary Storage at time of exicution BFS requires you store the entire 'frontier' DFS only requires you store the list of parent nodes of the current element.
If the tree is very deep and solutions are rare If the tree is very deep and solutions are rare, depth-first search (DFS) might take an extremely long time, but BFS could be faster.  
If solutions are frequent but located deep   If solutions are frequent but located deep in the tree, BFS could be impractical.
If the tree is very wide    If the tree is very wide, a BFS might need too much memory, so it might be completely impractical.
When the depth of the tree can vary Breadth First Search is generally the best approach when the depth of the tree can vary, and you only need to search part of the tree for a solution.