com.google.common.graph

Class Traverser<N>

java.lang.Object

com.google.common.graph.Traverser<N>

Type Parameters:

N - Node parameter type

@Beta
public abstract class Traverser<N>
extends Object

Provides methods for traversing a graph.

Since:

23.1

Author:

Jens Nyman

Constructor Summary

Constructors

Constructor and Description
Traverser()

Method Summary

Modifier and Type	Method and Description
abstract Iterable<N>	breadthFirst(N startNode) Returns an unmodifiable iterable over the nodes in the graph, using breadth-first traversal.
abstract Iterable<N>	depthFirstPostOrder(N startNode) Returns an unmodifiable iterable over the nodes in the graph, using depth-first post-order traversal.
abstract Iterable<N>	depthFirstPreOrder(N startNode) Returns an unmodifiable iterable over the nodes in the graph, using depth-first pre-order traversal.
static <N> Traverser<N>	forGraph(SuccessorsFunction<N> graph) Creates a new traverser for the given general graph.
static <N> Traverser<N>	forTree(SuccessorsFunction<N> tree) Creates a new traverser for a directed acyclic graph that has at most one path from the start node to any node reachable from the start node, such as a tree.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Traverser

public Traverser()

Method Detail

forGraph

public static <N> Traverser<N> forGraph(SuccessorsFunction<N> graph)

Creates a new traverser for the given general graph.

If graph is known to be tree-shaped, consider using forTree(SuccessorsFunction) instead.

Performance notes

• Traversals require O(n) time (where n is the number of nodes reachable from the start node), assuming that the node objects have O(1) equals() and hashCode() implementations.
• While traversing, the traverser will use O(n) space (where n is the number of nodes that have thus far been visited), plus O(H) space (where H is the number of nodes that have been seen but not yet visited, that is, the "horizon").

Parameters:

graph - SuccessorsFunction representing a general graph that may have cycles.

forTree

public static <N> Traverser<N> forTree(SuccessorsFunction<N> tree)

Creates a new traverser for a directed acyclic graph that has at most one path from the start node to any node reachable from the start node, such as a tree.

Providing graphs that don't conform to the above description may lead to:

• Traversal not terminating (if the graph has cycles)
• Nodes being visited multiple times (if multiple paths exist from the start node to any node reachable from it)

In these cases, use forGraph(SuccessorsFunction) instead.

Performance notes

• Traversals require O(n) time (where n is the number of nodes reachable from the start node).
• While traversing, the traverser will use O(H) space (where H is the number of nodes that have been seen but not yet visited, that is, the "horizon").

Examples

This is a valid input graph (all edges are directed facing downwards):

    a     b      c
   / \   / \     |
  /   \ /   \    |
 d     e     f   g
       |
       |
       h
 

This is not a valid input graph (all edges are directed facing downwards):

    a     b
   / \   / \
  /   \ /   \
 c     d     e
        \   /
         \ /
          f
 

because there are two paths from b to f (b->d->f and b->e->f).

Note on binary trees

This method can be used to traverse over a binary tree. Given methods leftChild(node) and rightChild(node), this method can be called as

 Traverser.forTree(node -> ImmutableList.of(leftChild(node), rightChild(node)));
 

Parameters:

tree - SuccessorsFunction representing a directed acyclic graph that has at most one path between any two nodes

breadthFirst

public abstract Iterable<N> breadthFirst(N startNode)

Returns an unmodifiable iterable over the nodes in the graph, using breadth-first traversal. That is, all the nodes of depth 0 are returned, then depth 1, then 2, and so on.

Example: The following graph with startNode a would return nodes in the order abcdef (assuming successors are returned in alphabetical order).

 b ---- a ---- d
 |      |
 |      |
 e ---- c ---- f
 

The behavior of this method is undefined if the nodes, or the topology of the graph, change while iteration is in progress.

The returned iterable can be iterated over multiple times. Every iterator will compute its next element on the fly. It is thus possible to limit the traversal to a certain number of nodes as follows:

 Iterables.limit(Traverser.forGraph(graph).breadthFirst(node), maxNumberOfNodes);
 

See Wikipedia for more info.

depthFirstPreOrder

public abstract Iterable<N> depthFirstPreOrder(N startNode)

Returns an unmodifiable iterable over the nodes in the graph, using depth-first pre-order traversal. That is, the nodes are returned in the order they are visited for the first time.

Example: The following graph with startNode a would return nodes in the order abcdef (assuming successors are returned in alphabetical order).

 b ---- a ---- f
 |      |
 |      |
 c ---- d ---- e
 

The behavior of this method is undefined if the nodes, or the topology of the graph, change while iteration is in progress.

The returned iterable can be iterated over multiple times. Every iterator will compute its next element on the fly. It is thus possible to limit the traversal to a certain number of nodes as follows:

 Iterables.limit(
     Traverser.forGraph(graph).depthFirstPreOrder(node), maxNumberOfNodes);
 

See Wikipedia for more info.

depthFirstPostOrder

public abstract Iterable<N> depthFirstPostOrder(N startNode)

Returns an unmodifiable iterable over the nodes in the graph, using depth-first post-order traversal. That is, the nodes are returned in the order they are visited for the last time.

Example: The following graph with startNode a would return nodes in the order edcbfa (assuming successors are returned in alphabetical order).

 b ---- a ---- f
 |      |
 |      |
 c ---- d ---- e
 

The behavior of this method is undefined if the nodes, or the topology of the graph, change while iteration is in progress.

The returned iterable can be iterated over multiple times. Every iterator will compute its next element on the fly. It is thus possible to limit the traversal to a certain number of nodes as follows:

 Iterables.limit(
     Traverser.forGraph(graph).depthFirstPostOrder(node), maxNumberOfNodes);
 

See Wikipedia for more info.