CareerCup

I would suggest a DFS. Let me know if you find an error or a better solution

public class NodeCollect {

	public Iterable<Node> getAllNodes(final Node root) {
		List<Node> retVal = new LinkedList<Node>();
		getAllNodes(root, retVal);
		return retVal;
	}

	private void getAllNodes(final Node currentRoot, final List<Node> retVal) {
		if (currentRoot != null) {
			retVal.add(currentRoot);
			if (currentRoot.getChildren() != null) {
				for (Node current : currentRoot.getChildren()) {
					getAllNodes(current, retVal);
				}
			}
		}
	}

	public static class Node {
		private Iterable<Node> _children;

		public Iterable<Node> getChildren() {
			return _children;
		}

		public void setChildren(final Iterable<Node> children) {
			_children = children;
		}
	}
}

Try recursion method as below:

package com.returnallnodes;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Node {

	Iterator<Node> children;

	public static Iterator<Node> getAllNodes(Node root){
		
		List<Node> allNodes=new ArrayList<Node>();
		if(root!=null){
			while(root.children.hasNext()){
				Iterator<Node> childNodes=getAllNodes(root.children.next());
				while(childNodes.hasNext()){
					allNodes.add(childNodes.next());
				}
			}
		}
		return allNodes.iterator();
	}
}

If there are circular links, the program will go into an infinte loop and run out of memory or hit a stack limit.
You should keep a hash of all visited nodes so that you can avoid nodes that have already been visited.

c#.
variant 1 (recursive) (DFS)

private static IEnumerable<Node> Get1( Node node ) {

            var result = new HashSet<Node> { node };

            if ( node.Children == null ) { return result; }

            result.UnionWith( node.Children );

            foreach ( var child in node.Children ) {
                result.UnionWith( Get1( child ) );
            }
            return result;
        }

c#.
variant 2 (recursive) (DFS)

private static IEnumerable<Node> Get2( Node node ) {

    var result = new List<Node> { node };

    if ( node.Children == null ) { return result; }

    foreach ( var child in node.Children ) {
        var tmpRes = result;
        result = (List<Node>)new AggFunc( // AggFunc = Func<IEnumerable<Node>>;
            () => { tmpRes.AddRange( Get2( child ) ); return tmpRes; } )();
    }
    return result;
}

c#.
variant 3 (recursive) (DFS) (using Linq extension methods)

static private IEnumerable<Node> Get3( Node node ) {
                       
    var result = new List<Node> { node };

    if ( node.Children == null ) { return result; }

    return node.Children.Aggregate(result, (current, child) => 
        (List<Node>)new AggFunc( // AggFunc = Func<IEnumerable<Node>>;
            () => { current.AddRange( Get3( child ) ); return current; } )() );
}

c#.
variant 4 (recursive) (DFS) (using Linq extension methods)

static private IEnumerable<Node> Get4( Node node ) {
                       
    var res = new List<Node> { node };
    if ( node.Children == null ) { return res; }
    return node.Children.Aggregate( res, (curr, child) => curr.Concat( Get4( child ) ).ToList() );
}

c#.
variant 5 (iterative) (BFS)

static private IEnumerable<Node> Get5( Node node ) {

    var res = new List<Node>();
    var currList = new List<Node> { node };

    while ( currList.Count > 0 ) {

        var tmpList = new List<Node>();

        for ( int i = 0; i < currList.Count; i++ ) {
            var children = currList[ i ].Children;
            if ( children == null ) { continue; }
            tmpList.AddRange( children );
        }
        res.AddRange( currList );
        currList = tmpList;
    }
    return res;
}