Java Algorithm depth-first search

It is recursively exploring left branch looking for target and then right branch for target.

To be more specific the algorithm does this:

• if target is found in this node, return true
• else, recurse into left subtree looking for target
• if target is in left subtree then recursive call will return true and short-circuit on || will make the method return immediately
• else the second sub-expression in || expression is evaluated, recursing into right subtree looking for target, returns boolean signifying presence of target in right subtree

The program applies the same method (dfs) to the left and right branches of the tree and returns the "OR" of both results.

Basically if the target isn't found in the current node, then check if it can be found in the left branch OR the right branch. This is applied recursively until there are no nodes left (when it matches the first case of root being null).

You can check out my answer here: Recursion - trying to understand and see if it helps understanding the problem.

It's doing a recursive call to explore first the left, then the right subtree.

It means it will first go down on the left until it gets to a leaf, then backtrack and go down on the right.

It returns true if it finds target in the left OR in the right subtree.

http://en.wikipedia.org/wiki/Depth-first_search

It's a recursive call where dfs first traverse all nodes left to root and then all nodes right to root and 'OR' the result of these two calls to return either true or false.

The last line

return dfs(root.left, target) || dfs(root.right, target);

is equivalent to

if (dfs(root.left, target)) {
   return true;
}
return dfs(root.right, target);

In other words, the method is applied recursively to the left subtree. Only if that returns false, the method is also recursively applied to the right subtree.