depth-first-search

I have a question about writing recursive algorithms in a functional style. I will use Scala for my example here, but the question applies to any functional language. I am doing a depth-first enumeration of an n -ary tree where each node has a label and a variable number of children. Here is a simple implementation that prints the labels of the leaf nodes. case class Node[T](label:T, ns:Node[T]*) def dfs[T](r:Node[T]):Seq[T] = { if (r.ns.isEmpty) Seq(r.label) else for (n<-r.ns;c<-dfs(n)) yield c } val r = Node('a, Node('b, Node('d), Node('e, Node('f))), Node('c)) dfs(r) // returns Seq[Symbol]

I realize that runtime of BFS and DFS on a generic graph is O(n+m), where n is number of nodes and m is number of edges, and this is because for each node its adjacency list must be considered. However, what is the runtime of BFS and DFS when it is executed on a binary tree? I believe it should be O(n) because the possible number of edges that can go out of a node is constant (i.e., 2). Please confirm if this is the correct understanding. If not, then please explain what is the correct time complexity of BFS and DFS on a binary tree? The time complexities for BFS and DFS are just O(|E|) , or

I need help traversing a tree structure in a depth first fashion. I can't come up with an algorithm to do it properly. My input is this: [ ["A", "B", "C"], ["1", "2"], ["a", "b", "c", "d"] ] The output should take the form: [ "A/1/a", "A/1/b", "A/1/c", "A/1/d", "A/2/a", "A/2/b", "A/2/c", "A/2/d", "B/1/a", "B/1/b", "B/1/c", "B/1/d", "B/2/a", "B/2/b", "B/2/c", "B/2/d", "C/1/a", "C/1/b", "C/1/c", "C/1/d", "C/2/a", "C/2/b", "C/2/c", "C/2/d" ] icyrock.com This should do the job: function traverse(arr) { var first = arr[0]; var ret = []; if (arr.length == 1) { for (var i = 0; i < first.length; i++)

I have a tree with a structure like this: __2__3__4 / \__5__6 0__1___7/__8__9 \\ \\__10__11__12 \__ __ __ 13 14 15 Node 1 has four children (2,7,10,13), nodes 2 and 7 have two children each (both sharing node 5 as a child). What I am trying to do is create a CTE that provide records containing the parent node, the node, the distance away from the root, and the branch (or fork) its contained in. IF (OBJECT_ID('tempdb..#Discovered') IS NOT NULL) BEGIN DROP TABLE #Discovered END CREATE TABLE #Discovered ( ID int PRIMARY KEY NOT NULL, Predecessor int NULL, OrderDiscovered int ); INSERT INTO

I understand and can easily implement BFS. My question is, how can we make this BFS limited to a certain depth? Suppose, I just need to go 10 level deep. You can do this with constant space overhead. BFS has the property that unvisited nodes in the queue all have depths that never decrease, and increase by at most 1. So as you read nodes from the BFS queue, you can keep track of the current depth in a single depth variable, which is initially 0. All you need to do is record which node in the queue corresponds to the next depth increase. You can do this simply by using a variable