BreadthFirst Search Breadthfirst search goes through the tree level by level, visiting all of the nodes on the top level first, then all the nodes on the second level, and so on. This strategy has the benefit of being complete (if there's a solution, it will be found), and optimal as long as the shallowest solution is the best solution. However, the way breadthfirst search achieves this is by keeping all of the leaf nodes in memory, which requires a prohibitive amount of memory when searching anything more than a very small tree. The time complexity of breadthfirst search is O(b^d) where b is the branching factor (2 for the binary trees below) and d is the depth of the solution. 

DepthFirst Search Depthfirst search goes through the tree branch by branch, going all the way down to the leaf nodes at the bottom of the tree before trying the next branch over. This strategy requires much less memory than breadthfirst search, since it only needs to store a single path from the root of the tree down to the leaf node. However, it is potentially incomplete, since it will keep going on down one branch until it finds a deadend, and it is nonoptimal  if there's a solution at the fourth level in the first branch tried, and a solution at the second level in the next one over, the solution at the fourth level will be returned. The time complexity of depthfirst search is O(b^m) where b is the branching factor (2 for the binary trees below) and m is the maximum depth of the tree. Its space complexity is only b*m. Try searching for "a" and see which of the two solutions is found when using depthfirst search. 

DepthLimited Search Depthlimited search essentially does a depthfirst search with a cutoff at a specified depth limit. When the search hits a node at that depth, it stops going down that branch and moves over to the next one. This avoids the potential problem with depthfirst search of going down one branch indefinitely. However, depthlimited search is incomplete  if there is a solution, but only at a level deeper than the limit, it will not be found. It is also nonoptimal in the same way as depthfirst search is. The time complexity of depthfirst search is O(b^l) where b is the branching factor (2 for the binary trees below) and l is the depth limit. Its space complexity is only b*l. The depth limit in this instance of the algorithm (set using the PARAM tag within the APPLET tag; view the source of the file to see) is 2. (The depth of the root node is 0.) 

Iterative Deepening Search Iterative deepening does repeated depthlimited searches, starting with a limit of zero and incrementing once each time. As a result, it has the spacesaving benefits of depthfirst search, but is also complete and optimal, since it will visit all the nodes on the same level first before continuing on to the next level in the next round when the depth is incremented. The time complexity of iterative deepening search is O(b^d) where b is the branching factor (2 for the binary trees below) and d is the depth of the solution. The space complexity is O(bd). 