Just build one level at a time, e.g.: class Node(object): def __init__(self, value, left=None, right=None): self.value = value self.left = left self.right = right def traverse(rootnode): thislevel = [rootnode] while thislevel: nextlevel = list() for n in thislevel: print n.value, if n.left: nextlevel.append(n.left) if n.right: nextlevel.append(n.right) print thislevel = nextlevel t = Node(1, Node(2, Node(4, … Read more
Depth first search is more memory efficient than breadth first search as you can backtrack sooner. It is also easier to implement if you use the call stack but this relies on the longest path not overflowing the stack. Also if your graph is directed then you have to not just remember if you have … Read more
Technically, Breadth-first search (BFS) by itself does not let you find the shortest path, simply because BFS is not looking for a shortest path: BFS describes a strategy for searching a graph, but it does not say that you must search for anything in particular. Dijkstra’s algorithm adapts BFS to let you find single-source shortest … Read more
Your sum v1 + (incident edges) + v2 + (incident edges) + …. + vn + (incident edges) can be rewritten as (v1 + v2 + … + vn) + [(incident_edges v1) + (incident_edges v2) + … + (incident_edges vn)] and the first group is O(N) while the other is O(E).
Breadth first search Queue<TreeNode> queue = new LinkedList<BinaryTree.TreeNode>() ; public void breadth(TreeNode root) { if (root == null) return; queue.clear(); queue.add(root); while(!queue.isEmpty()){ TreeNode node = queue.remove(); System.out.print(node.element + ” “); if(node.left != null) queue.add(node.left); if(node.right != null) queue.add(node.right); } }
Dijkstra allows assigning distances other than 1 for each step. For example, in routing the distances (or weights) could be assigned by speed, cost, preference, etc. The algorithm then gives you the shortest path from your source to every node in the traversed graph. Meanwhile BFS basically just expands the search by one “step” (link, … Read more
That heavily depends on the structure of the search tree and the number and location of solutions (aka searched-for items). If you know a solution is not far from the root of the tree, a breadth first search (BFS) might be better. If the tree is very deep and solutions are rare, depth first search … Read more
As a caveat, remember that there can be exponentially many shortest paths between two nodes in a graph. Any algorithm for this will potentially take exponential time. That said, there are a few relatively straightforward algorithms that can find all the paths. Here’s two. BFS + Reverse DFS When running a breadth-first search over a … Read more
(I’m assuming that this is just some kind of thought exercise, or even a trick homework/interview question, but I suppose I could imagine some bizarre scenario where you’re not allowed any heap space for some reason [some really bad custom memory manager? some bizarre runtime/OS issues?] while you still have access to the stack…) Breadth-first … Read more
To do so, you need to store a map:V->V (from vertices to vertices), which will map from each node v, the vertex u that “discovered” v. You will populate this map during the iterations of BFS. Later – you can reconstruct the path by simply going from the target node (in the map) up until … Read more