CareerCup

public void bfs() {
        // BFS uses Queue data structure
        Queue queue = new LinkedList();
        queue.add(this.rootNode);
        System.out.println(this.rootNode);
        visited.put(rootNode, true);
        while (!queue.isEmpty()) {
            Node node = (Node) queue.remove();
            Node child = null;
            while ((child = getUnvisitedChildNode(node)) != null) {
                visited.put(child, true);
                System.out.println(child);
                queue.add(child);
            }
        }
        // Clear visited property of nodes
        clearNodes();
    }

    public void bfsRecursive(Queue queue) {
        // BFS uses Queue data structure
        if (queue.isEmpty()) return;
        Node node = (Node) queue.remove();
        System.out.println(node);
        visited.put(node, true);
        for (Node child: node.child) {
            queue.add(child);
        }
        bfsRecursive(queue);
    }

    public void dfs() {
        // DFS uses Stack data structure
        Stack stack = new Stack();
        stack.push(this.rootNode);
        visited.put(rootNode, true);
        System.out.println(rootNode);
        while (!stack.isEmpty()) {
            Node node = (Node) stack.peek();
            Node child = getUnvisitedChildNode(node);
            if (child != null) {
                visited.put(child, true);
                System.out.println(child);
                stack.push(child);
            } else {
                stack.pop();
            }
        }
        clearNodes();
    }

    public void dfsRecursive(Stack stack) {
        // DFS uses Stack data structure
        if (stack.empty()) return;
        Node node = (Node) stack.peek();
        if (visited.get(node)==null) System.out.println(node);
        visited.put(node, true);
        Node child = getUnvisitedChildNode(node);
        if (child != null) {
            stack.push(child);
        } else {
            stack.pop();
        }
        dfsRecursive(stack);
    }

Even though recursive solution should be avoided as much as possible since for large tree they are bound fail with stack overflow, here is the pseudo code for recursive solutions:

dfs_recursive (Node n){
	if n==null
	   return;
	end-if

	if n has children
	   for each entry c in n->children
		dfs_recursive(c);
	   end-for
	end-if
	print n; //post order DFS
}
	

bfs_pre_recursive {
    Q <-- initialize a queue
    Node marker <-- initialize a node
    Q.enqueue(root);
    Q.emqueue(marker);
    bfs_recursive(Q, marker);
}

bfs_recursive (Queue Q, Node MARKER) {
     while true
         Node n=Q.dequeue();
         If n is MARKER
		break;
	 end-if

         print n
         if n has children
	     for each entry c in n->children
		 Q.enqueue(c);
	     end-for
	 end-if
     end-while

     if Q is not empty
	Q.enque(MARKER);
	bfs_recursive(Q, MARKER);
     end-if	
}

dfs(node n){
visit n;
foreach i child of n{
dfs(i);
}
}

public static void BFS(TNode root){
		Queue<TNode> q = new LinkedList<TNode>();
		q.add(root);
		recursiveBFS(q);
	}
	public static void recursiveBFS(Queue<TNode> q){
		if(q.isEmpty())
			return;
		TNode t = q.poll();
		System.out.println(t.data);
		for(Tnode temp : t.childrenList)
                         q.add(temp);
		recursiveBFS(q);
	}

for DFS : Use stack
For BFS : user queue

class Node{
 int data;
 Node children; // Linked list of children
}
Node DFS(int data, Node root){
 if(root == null)
  return(null);
 if(root.data == data);
  return(root);
 Node child = root.children;
 while(child != null){
  if(child.data == data)
    return(child);
  Node returnVal = DFS(data, child);
  if(returnVal != null)
    return(returnVal);
  child = child.next();
 }
return(null);
}
Node BFS(int data, Node root){
 LinkedList<Node> queue = new LinkedList<Node>();
 queue.addLast(root);
 return(BFSRecursive(data, queue));
}
Node BFSRecursive(data, queue){
 Node node = queue.getFirst();
 if(node != null)
  return(null);
 if(node.data == data)
  return(Node);
 Node child = node.children;
 while(child != null){
  if(child.data == data)
   return(child);
  queue.addLast(child);
  child = child.next();
 }
return(BFSRecursive(data,queue));
}