Public

<init>

breadthFirst

checkThatNodeIsInTree

depthFirstPostOrder

depthFirstPreOrder

Charset

Reactive rest calls using spring rest template

The Font class represents fonts, which are used to render text in a visible way.
A font provides the

java.awt.Font

The GridLayout class is a layout manager that lays out a container's components
in a rectangular gri

java.awt.GridLayout

This exception is thrown when a timeout expired on a socket read or accept
operation.

java.net.SocketTimeoutException

SortedSet is a Set which iterates over its elements in a sorted order. The order
is determined eithe

java.util.SortedSet

TimeZone represents a time zone offset, and also figures out daylight savings. 
Typically, you get a

java.util.TimeZone

An interface for the creation of Connection objects which represent a connection
to a database. This

javax.sql.DataSource

notifyDataSetChanged

runOnUiThread

setContentView

/**
 * 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