Public

<init>

breadthFirst

checkThatNodeIsInTree

depthFirstPostOrder

depthFirstPreOrder

Charset

Reactive rest calls using spring rest template

This class provides methods that return pseudo-random values.It is dangerous to
seed Random with the

java.util.Random

A task that returns a result and may throw an exception. Implementors define a
single method with no

java.util.concurrent.Callable

A plug-in replacement for JDK1.5 java.util.concurrent.ConcurrentHashMap. This
version is based on or

java.util.concurrent.ConcurrentHashMap

javax.swing.JButton

Main entry-point into the library.

Options represents a collection of Option objects, which describ

org.apache.commons.cli.Options

General IO stream manipulation utilities. This class provides static utility
methods for input/outpu

org.apache.commons.io.IOUtils

getSupportFragmentManager

notifyDataSetChanged

addToBackStack

/**
 * Creates a new traverser for a directed acyclic graph that has at most one path from the start
 * node(s) to any node reachable from the start node(s), and has no paths from any start node to
 * any other start node, such as a tree or forest.
 *
 * {@code forTree()} is especially useful (versus {@code forGraph()}) in cases where the data
 * structure being traversed is, in addition to being a tree/forest, also defined <a
 * href="https://github.com/google/guava/wiki/GraphsExplained#non-recursiveness">recursively</a>.
 * This is because the {@code forTree()}-based implementations don't keep track of visited nodes,
 * and therefore don't need to call `equals()` or `hashCode()` on the node objects; this saves
 * both time and space versus traversing the same graph using {@code forGraph()}.
 *
 * Providing a graph to be traversed for which there is more than one path from the start
 * node(s) to any node may lead to:
 *
 * <ul>
 * <li>Traversal not terminating (if the graph has cycles)
 * <li>Nodes being visited multiple times (if multiple paths exist from any start node to any
 * node reachable from any start node)
 * </ul>
 *
 * Performance notes
 *
 * <ul>
 * <li>Traversals require O(n) time (where n is the number of nodes reachable from
 * the start node).
 * <li>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").
 * </ul>
 *
 * Examples (all edges are directed facing downwards)
 *
 * The graph below would be valid input with start nodes of {@code a, f, c}. However, if {@code
 * b} were also a start node, then there would be multiple paths to reach {@code e} and
 * {@code h}.
 *
 * <pre>{@code
 * a b c
 * / \ / \ |
 * / \ / \ |
 * d e f g
 * |
 * |
 * h
 * }</pre>
 *
 * .
 *
 * The graph below would be a valid input with start nodes of {@code a, f}. However, if {@code
 * b} were a start node, there would be multiple paths to {@code f}.
 *
 * <pre>{@code
 * a b
 * / \ / \
 * / \ / \
 * c d e
 * \ /
 * \ /
 * f
 * }</pre>
 *
 * Note on binary trees
 *
 * This method can be used to traverse over a binary tree. Given methods {@code
 * leftChild(node)} and {@code rightChild(node)}, this method can be called as
 *
 * <pre>{@code
 * Traverser.forTree(node -> ImmutableList.of(leftChild(node), rightChild(node)));
 * }</pre>
 *
 * @param tree {@link SuccessorsFunction} representing a directed acyclic graph that has at most
 * one path between any two nodes
 */

"Undirected networks can never be trees."

How to use com.google.common.graph.Traverser$TreeTraverserconstructor

Best Java code snippets using com.google.common.graph.Traverser$TreeTraverser.<init> (Showing top 5 results out of 315)

How to use
com.google.common.graph.Traverser$TreeTraverser
constructor