| Package | Description |
|---|---|
| graph.algorithm.cycles |
Classes for detecting cycles and finding a cycle basis of directed and undirected graphs.
|
| graph.algorithms.connectivity |
Classes related to the planar augmentation problem.
|
| graph.algorithms.drawing |
Implementations of various graph drawing algorithms.
|
| graph.algorithms.interlacement |
Elements of the interlacement graphs.
|
| graph.algorithms.lrpartition |
Classes related to LR partitions.
|
| graph.algorithms.numbering |
Classes represent different numberings of vertices.
|
| graph.algorithms.planarity |
Implementations of different planarity testing algorithms.
|
| graph.algorithms.planarity.dual |
Classes represent dual graph and its elements.
|
| graph.drawing |
Contains a class which represents results of the execution of layout algorithms.
|
| graph.elements |
Basic graph elements.
|
| graph.elements.impl |
Classes which implement edge and vertex interfaces in case they are needed to
invoke any of the algorithms.
|
| graph.layout |
Layouters which are invoked in order to lay out graphs.
|
| graph.layout.automatic |
Classes for laying graphs automatically, based on their properties.
|
| graph.layout.box |
Simple layouter which places vertices on a table like structure.
|
| graph.layout.circle |
Layouters which use different circular layout algorithms.
|
| graph.layout.dsl |
Contains a class for laying out a graph based on the provided description
which should be in accordance with the domain-specific language.
|
| graph.layout.force.directed |
Layouters which call different force-directed algorithms.
|
| graph.layout.organic |
Layouters which call different organic layout algorithms.
|
| graph.layout.orthogonal |
Layouters which use orthogonal drawing algorithms.
|
| graph.layout.router.orthogonal |
Classes responsible for routing edges as a part of the orthogonal drawing algorithms.
|
| graph.layout.straight.line |
Layouters which call different straight-line graph drawing algorithms.
|
| graph.layout.symmetric |
Layouters which call different symmetric graph drawing algorithms.
|
| graph.layout.tree |
Layouters which call different tree drawing algorithms.
|
| graph.math |
Classes containing various mathematical calculations and mathematical objects.
|
| graph.operations |
Classes containing certain mathematical calculations involving two graphs,
like their unions.
|
| graph.ordering |
Classes implementing different orderings of graph vertices.
|
| graph.ordering.circular |
Classes including an implementation of the algorithm CIRCULAR and necessary helper classes.
|
| graph.properties |
Classes containing methods for checking different properties of the given graph.
|
| graph.properties.components |
Classes representing split components and other elements associated with them, such as separation pairs.
|
| graph.properties.splitting |
Implementations of algorithms for splitting graph into bi- and triconnected components.
|
| graph.symmetry |
Classes related to graph's symmetries and automorphisms.
|
| graph.symmetry.nauty |
Classes needed to implement McKay's graph labeling algorithm.
|
| graph.traversal |
Classes implementing different graph traversal algorithms, like DFS and Dijkstra's shortest path.
|
| graph.tree.bc |
Classes representing a BC-tree and its elements.
|
| graph.tree.binary |
Classes representing a binary-tree and its elements.
|
| graph.tree.pq |
Classes representing a PQ-tree and its elements.
|
| graph.tree.spqr |
Classes representing a SPQR-tree and its elements.
|
| graph.trees.dfs |
Contains a class which represents a DFS tree.
|
| graph.util |
Helper classes.
|
| Modifier and Type | Class and Description |
|---|---|
class |
JohnsonSimpleCycles<V extends Vertex,E extends Edge<V>>
Find all simple cycles of a directed graph using the Johnson's
algorithm.
|
class |
PatonSimpleCycles<V extends Vertex,E extends Edge<V>>
Find a cycle basis of an undirected graph using the Paton's
algorithm.
|
class |
SimpleCyclesFinder<V extends Vertex,E extends Edge<V>>
Finds all simple cycles of a given graph.
|
class |
SimpleUndirectedCyclesFinder<V extends Vertex,E extends Edge<V>>
Finds all cycles of a graph
|
| Modifier and Type | Class and Description |
|---|---|
class |
PlanarAugmentation<V extends Vertex,E extends Edge<V>>
Given a connected, but not biconnected planar graph, the algorithm
adds a minimum number of edges to turn it into a biconnected graph
while not ruining the planarity
This implementation is based on Fialko and Mutzel's 5/3 approximation
|
class |
PlanarAugmentationLabel<V extends Vertex,E extends Edge<V>>
A bundle of pendants together with its parent
is called a label.
|
| Modifier and Type | Class and Description |
|---|---|
class |
ConvexDrawing<V extends Vertex,E extends Edge<V>>
Implementation of Chiba's convex drawing algorithm
Linear Algorithm for Convex Drawong of Planar Graphs
Norishige Chiba, Tadashi Yamanouchi, Takao Nishizeki
In Progress In Graph Theory, 1984.
|
class |
CyclicSymmetricGraphDrawing<V extends Vertex,E extends Edge<V>>
Implementation of concentric symmetric drawing based on:
An Algorithm for Drawing Graphs Symmetrically
Hamish Carr and William Kocay
Bulletin of the Institute of Combinatorics and its Applications 27, 1999
|
class |
PlanarConvexEmbedding<V extends Vertex,E extends Edge<V>>
Part of Chiba's convex drawing algorithm
Determines if a graph has convex drawing and finds the extendable facial cycle
|
class |
TutteEmbedding<V extends Vertex,E extends Edge<V>>
Implementations of Tutte's (or barycentric) embedding of a simple 3-vertex-connected planar graph.
|
class |
VisibilityRepresentation<V extends Vertex,E extends Edge<V>>
Finds a graph's visibility representation.
|
| Modifier and Type | Class and Description |
|---|---|
class |
InterlacementGraphEdge<V extends Vertex,E extends Edge<V>> |
class |
InterlacementGraphVertex<V extends Vertex,E extends Edge<V>>
Vertex of the interlacement graph.
|
| Modifier and Type | Class and Description |
|---|---|
class |
InterlacementGraphVertex<V extends Vertex,E extends Edge<V>>
Vertex of the interlacement graph.
|
| Modifier and Type | Class and Description |
|---|---|
class |
LRPartition<V extends Vertex,E extends Edge<V>>
A partition B = L U R of DFS oriented graph's
back edges into two classes, referred to as left and right, is called left-right
partition, or LR partition for short
|
class |
LRPartitionEdge<V extends Vertex,E extends Edge<V>>
Used to implement LR planar testing algorithms
Saves lists of edges which should be in the same and in different partitions
than the given edge
|
class |
LRPartitionSet<V extends Vertex,E extends Edge<V>>
Used in LR planar testing algorithm to form L and R partitions
|
| Modifier and Type | Class and Description |
|---|---|
class |
DFSNumbering<V extends Vertex,E extends Edge<V>>
Represents DFS numbering of a given graph
|
class |
Numbering<V extends Vertex,E extends Edge<V>>
Abstract class meant to be extended by all implementing a numbering algorithm
|
class |
STNumbering<V extends Vertex,E extends Edge<V>>
Given any edge {s,t} in a biconnected graph G with n vertices,
the vertices can be numbered from 1 to n so that vertex s receives the number 1
and vertex t the number n
This is called the st-numbering
This implementation is based on an algoritm by Even and Tarjan from their paper
titled "Computing an st-numbering"
|
| Modifier and Type | Class and Description |
|---|---|
class |
BoyerMyrvoldPlanarity<V extends Vertex,E extends Edge<V>>
Implementation of the Boyer-Myrvold planarity testing algorithm
The Boyer-Myrvold algorithm is a planarity testing algorithm which uses reverse DFS order as numbering
of the vertices of G.
|
class |
Embedding<V extends Vertex,E extends Edge<V>>
Represents embedding of a graph - clockwise order of edges around each vertex
|
class |
FraysseixMendezPlanarity<V extends Vertex,E extends Edge<V>>
An algorithm for checking the planarity of a graph based on Fraysseix and Mendez's algorithm
|
class |
MaximumPlanaritySubgraph<V extends Vertex,E extends Edge<V>>
Finds maximum planar subgraph
A widely used standard heuristic for finding a maximal planar subgraph is to start with
a spanning tree of G, and to iteratively try to add the remaining edges one by one
In every step, a planarity testing algorithm is called for the obtained graph.
|
class |
PlanarFaces<V extends Vertex,E extends Edge<V>>
Finds planar faces of a graph.
|
class |
PlanarityTestingAlgorithm<V extends Vertex,E extends Edge<V>>
A class which should be extended by all planarity testing implementations
|
class |
PQTreePlanarity<V extends Vertex,E extends Edge<V>>
Implementation of the PQ tree planarity testing based on Booth and Lueker's algorithm
|
| Modifier and Type | Method and Description |
|---|---|
static <V extends Vertex,E extends Edge<V>> |
PlanarEmbedding.emedGraph(Graph<V,E> graph,
V s,
V t)
Calculates a planar embedding of a graph based on the work of Chiba, Nishizeki, Abe and Ozava
A linear algorithm for embedding planar graphs using PQ-trees, Journal of Computer and System Sciences 30, 1985
|
| Modifier and Type | Class and Description |
|---|---|
class |
DualGraphEdge<V extends Vertex,E extends Edge<V>>
Class represents edge of a dual graph
Each edge of dual graphs connects a face to the left of a graph's edge
and the face to the right
|
class |
DualGraphVertex<V extends Vertex,E extends Edge<V>>
Class represents vertices of dual graphs
Vertices of dual graphs are sets of faces of G, where G is a st-graph
(DAG with one source and one sink)
|
class |
STDualGraph<V extends Vertex,E extends Edge<V>>
Constructs a st-dual graph
Given a planar st-graph G, the dual planar st-graph G = (V, E)
is a digraph with the following properties:
- V* is the set of faces in G with the addition that the external face (s, .
|
| Modifier and Type | Class and Description |
|---|---|
class |
DualGraphVertex<V extends Vertex,E extends Edge<V>>
Class represents vertices of dual graphs
Vertices of dual graphs are sets of faces of G, where G is a st-graph
(DAG with one source and one sink)
|
| Modifier and Type | Class and Description |
|---|---|
class |
Drawing<V extends Vertex,E extends Edge<V>>
Represents a drawing of a graph.
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
Edge<V extends Vertex>
Edge of the graph
|
class |
Graph<V extends Vertex,E extends Edge<V>>
/**
A graph consisting of a set of vertices of type
V
and a set of edges of type E. |
class |
Path<V extends Vertex,E extends Edge<V>>
Represents a path (list of edges)
|
class |
VertexDegreeComparator<V extends Vertex,E extends Edge<V>>
Class used for sorting vertices based on their degree
|
| Modifier and Type | Method and Description |
|---|---|
void |
Graph.addVertex(V... vert) |
| Modifier and Type | Class and Description |
|---|---|
class |
GraphVertex
A class which implements the Vertex interface
|
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractJGraphXLayouter<V extends Vertex,E extends Edge<V>>
Contains general code used for calling JGraphX layout algorithms
|
class |
AbstractJungLayouter<V extends Vertex,E extends Edge<V>>
Contains general code used for calling Jung layout algorithms
|
class |
AbstractLayouter<V extends Vertex,E extends Edge<V>>
Abstract layouter class meant to be extended by all layouters.
|
class |
AbstractPrefuseLayouter<V extends Vertex,E extends Edge<V>>
Contains general code used for calling prefuse layout algorithms.
|
class |
Layouter<V extends Vertex,E extends Edge<V>>
Layouter accepts lists of veritces and edges which might in fact form more than one graph
It then forms the graphs which can later be layouted using the desired method
|
class |
LayouterFactory<V extends Vertex,E extends Edge<V>>
Factory class used to create an instance of the layouter class
|
| Modifier and Type | Class and Description |
|---|---|
class |
AutomaticPropertiesLayout<V extends Vertex,E extends Edge<V>>
Layouter which automatically picks and executes an algorithm
based on the properties of the given graph
|
class |
LayoutPicker<V extends Vertex,E extends Edge<V>>
Class used to select an algorithm automatically based on properties
of the graph
|
| Modifier and Type | Class and Description |
|---|---|
class |
BoxLayouter<V extends Vertex,E extends Edge<V>>
A simple layout algorithm which places elements in a table like structure
Suitable if the elements are not linked
|
| Modifier and Type | Class and Description |
|---|---|
class |
CircleLayouter<V extends Vertex,E extends Edge<V>>
Layotuer which embeds the vertices on a circle, with or without optimizing
edge crossings (depending on the optimize crossings parameter value).
|
class |
CircleWithCenterLayouter<V extends Vertex,E extends Edge<V>>
This layouter takes places vertices on a circumference of a circle,
and places the vertex with the highest number of links with other graph vertices in
the center of the circle
|
| Modifier and Type | Class and Description |
|---|---|
class |
DSLLayouter<V extends Vertex,E extends Edge<V>>
A layouter which lays out a given graph in accordance with the user's description
which needs to conform to the defined dsl.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractForceDirectedLayouter<V extends Vertex,E extends Edge<V>>
Abstract class meant to be extended by others using JUNG framework's force-directed algorithms
|
class |
DAGLayouter<V extends Vertex,E extends Edge<V>>
Layouter which uses JUNG framework's DAG layout
|
class |
FruchtermanReingoldLayouter<V extends Vertex,E extends Edge<V>>
Layouter which uses JUNG framework's Fruchterman-Reingold layout
|
class |
KamadaKawaiLayouter<V extends Vertex,E extends Edge<V>>
Layouter which uses JUNG framework's Kamada-Kawai layout
|
class |
PrefuseForceDirectedLayouter<V extends Vertex,E extends Edge<V>>
Layouter which uses prefuse framework's force-directed layout
|
class |
SpringLayouter<V extends Vertex,E extends Edge<V>>
Layouter which uses JUNG framework's spring layout
|
| Modifier and Type | Class and Description |
|---|---|
class |
JGraphFastorganicLayouter<V extends Vertex,E extends Edge<V>>
Layouter which uses JGraphX's fast organic layout
|
class |
JGraphHierarchicalLayouter<V extends Vertex,E extends Edge<V>>
Layouter which uses JGraphX's hierarchical layout
|
class |
JGraphOrganicLayouter<V extends Vertex,E extends Edge<V>>
Layouter which uses JGraphX's organic layout
|
class |
JungISOMLayouter<V extends Vertex,E extends Edge<V>>
Layouter which uses JUNG grapmework's ISOM layout
|
| Modifier and Type | Class and Description |
|---|---|
class |
VisibilityRepresentationLayout<V extends Vertex,E extends Edge<V>>
Layouter using visibility representation or orthogonally lay out a graph
|
| Modifier and Type | Class and Description |
|---|---|
class |
OrthogonalConnector<V extends Vertex>
Class represents a point where an edge begins or ends inside a vertex
Used to implement the orthogonal layout
|
class |
OrthogonalEdgeRouter<V extends Vertex,E extends Edge<V>>
Part of the orthogonal graph drawing algorithm.
|
| Modifier and Type | Class and Description |
|---|---|
class |
ConvexLayouter<V extends Vertex,E extends Edge<V>>
A layouter which creates a drawing of a graph using Chiba's convex drawing algorithm
|
class |
TutteLayouter<V extends Vertex,E extends Edge<V>>
A layouter which creates a drawing of the graph using Tutte's embedding
|
| Modifier and Type | Class and Description |
|---|---|
class |
SymmetricCircleLayouter<V extends Vertex,E extends Edge<V>>
Layouter which creates a drawing of a graph using Carr and Kocay's symmetric
circular algorithm
|
class |
SymmetricLayouter<V extends Vertex,E extends Edge<V>>
Abstract layouter, meant to be extended by all symmetric layouters.
|
| Modifier and Type | Class and Description |
|---|---|
class |
JGraphCompactTreeLayout<V extends Vertex,E extends Edge<V>>
A layouter which creates a drawing of a graph using JGraphX's compact tree algorithm
|
class |
JungTreeLayouter<V extends Vertex,E extends Edge<V>>
A layouter which creates a drawing of a graph using JUNG franework's tree algorithm
|
class |
PrefuseBalloonLayouter<V extends Vertex,E extends Edge<V>>
A layouter which creates a drawing of a graph using prefuse's balloon tree drawing algorithm
|
class |
PrefuseNodeLinkTreeLayouter<V extends Vertex,E extends Edge<V>>
A layouter which creates a drawing of a graph using prefuse's node link tree drawing algorithm
|
class |
PrefuseRadialTreeLayouter<V extends Vertex,E extends Edge<V>>
A layouter which creates a drawing of a graph using prefuse's radial tree drawing algorithm
|
class |
RadialTreeLayouter<V extends Vertex,E extends Edge<V>>
A layouter which creates a drawing of a graph using JUNG framework's radial tree drawing algorithm
|
| Modifier and Type | Class and Description |
|---|---|
class |
CircleLayoutCalc<V extends Vertex>
A class containing methods for calculating certain values needed by
the circular drawing algorithms
|
class |
CzekanovskiDiceDistance<V extends Vertex,E extends Edge<V>>
A class for calculating Czekanovski-Dice distances.
|
| Modifier and Type | Class and Description |
|---|---|
class |
GraphOperations<V extends Vertex,E extends Edge<V>>
A class containing util methods, mostly regarding
operations between two graphs
|
| Modifier and Type | Method and Description |
|---|---|
static <V extends Vertex,E extends Edge<V>> |
TopologicalOrdering.calculateOrdering(Graph<V,E> graph)
Finds the topological ordering
|
static <V extends Vertex,E extends Edge<V>> |
CanonicalOrdering.calculateOrdering(Graph<V,E> graph) |
| Modifier and Type | Class and Description |
|---|---|
class |
Circular<V extends Vertex,E extends Edge<V>>
An implementation of the algorithm CIRCULAR
which optimizes the number of edge crossings in circular drawings
|
class |
GraphCopy<V extends Vertex,E extends Edge<V>>
A graph containing triangulated edges.
|
class |
TriangulatedEdge<V extends Vertex>
Triangulated edge as defined in algorithm CIRCULAR
|
| Modifier and Type | Class and Description |
|---|---|
class |
Bipartite<V extends Vertex,E extends Edge<V>>
A class for checking the bipartite property of a graph
Bipartite graph (or bigraph) is a graph whose vertices can be divided into two disjoint sets U and V
(that is, U and V are each independent sets) such that every edge connects a vertex in U to one in V.
|
class |
GraphProperties<V extends Vertex,E extends Edge<V>>
A class containing methods for checking various properties
of the given graph
|
| Modifier and Type | Class and Description |
|---|---|
class |
Block<V extends Vertex,E extends Edge<V>>
Class represent a block of a graph.
|
class |
Component<V extends Vertex,E extends Edge<V>>
Class represent a component of a graph.
|
class |
HopcroftTarjanSplitComponent<V extends Vertex,E extends Edge<V>>
A component of a graph used in Hopcroft-Tarjan splitting algorithm
|
class |
SeparationPair<V extends Vertex>
A separation pair, used in Hopcroft-Tarjan splitting
|
class |
SplitComponent<V extends Vertex,E extends Edge<V>>
Class represents a split component of a graph
|
class |
SplitPair<V extends Vertex,E extends Edge<V>>
Class represent a split pair of a graph.
|
| Modifier and Type | Class and Description |
|---|---|
class |
BiconnectedSplitting<V extends Vertex,E extends Edge<V>>
Finds all biconnected components of a graph
efficiently, by using the depth-first search
Since the components should have the same features as block
Like removal of vertex which also removed the edge, being able to find its cut vertices etc.
|
class |
HopcroftTarjanSplitting<V extends Vertex,E extends Edge<V>>
Implementation based on Hopcroft and Tarjan's algorithm:
J.
|
class |
SeparationPairSplitting<V extends Vertex,E extends Edge<V>>
An implementation of Hopcroft-Tarjan's algorithm for finding separation pairs
|
class |
Splitting<V extends Vertex,E extends Edge<V>>
A class containing methods regarding graph splitting, such as finding cut vertices
Some methods need to be rewritten due to being slow
|
| Modifier and Type | Class and Description |
|---|---|
class |
CyclicPermutation<V extends Vertex>
Class represents a permutation in the cyclic representation
|
class |
DeFrayseeixHeuristic<V extends Vertex,E extends Edge<V>>
A class for calculating De Frayseeix's heuristic
|
class |
PermutationAnalyzator<V extends Vertex,E extends Edge<V>>
A class containing methods for analyzing permutations of a graph
|
class |
PermutationCycle<V extends Vertex>
Represents one permutation cycle
|
| Modifier and Type | Class and Description |
|---|---|
class |
BinaryRepresentation<V extends Vertex,E extends Edge<V>>
Binary representation of a graph, used in graph labeling algorithm
|
class |
McKayGraphLabelingAlgorithm<V extends Vertex,E extends Edge<V>>
Implementation of McKay's canonical graph labeling algorithm
|
class |
OrderedPartition<V extends Vertex>
Ordered partition, used in graph labeling algorithm
|
class |
SearchTree<V extends Vertex>
Class represents a search tree defined and used in graph labeling algorithm
|
class |
SearchTreeNode<V extends Vertex>
Class represents a search tree node
|
| Modifier and Type | Class and Description |
|---|---|
class |
DFSTreeTraversal<V extends Vertex,E extends Edge<V>>
Class for forming a DFS tree given a graph
|
class |
DijkstraAlgorithm<V extends Vertex,E extends Edge<V>>
An implementation of Dijkstra's algorithm for finding a path between
two graph vertices in a graph
|
| Modifier and Type | Method and Description |
|---|---|
static <V extends Vertex,E extends Edge<V>> |
TraversalUtil.circularNoCrossingsPath(V v1,
V v2,
java.util.Map<V,java.util.List<E>> adj,
boolean debug,
java.util.List<V> excluding,
java.util.List<E> excludingEdges)
Finds a path from one vertex to another such that the there are no back edges
and no edge crossings.
|
static <V extends Vertex,E extends Edge<V>> |
GraphTraversal.findAllPathsDFS(Graph<V,E> graph,
V source,
V target)
Finds all paths in the given graph between two provided vertices using depth-first search
|
static <V extends Vertex,E extends Edge<V>> |
GraphTraversal.findAllPathsDFS(Graph<V,E> graph,
V source,
V target,
java.util.List<V> excluding)
Finds all paths in the given graph between two provided vertices not containing any of vertices in the given list using depth-first search
|
static <V extends Vertex,E extends Edge<V>> |
GraphTraversal.findAllPathsDFSContaining(Graph<V,E> graph,
V source,
V target,
java.util.List<V> containing)
Finds all paths in the given graph between two provided vertices containing a list of vertices using depth-first search
|
static <V extends Vertex,E extends Edge<V>> |
GraphTraversal.findLongestPath(Graph<V,E> graph)
Finds the longest path in a graph
Method should be rewritten to increase its effectiveness
|
static <V extends Vertex,E extends Edge<V>> |
GraphTraversal.nonrecursiveDFSPath(Graph<V,E> graph,
V source,
V target)
A non-recursive implementation of the depth-first search for finding a path between two vertices
More efficient than the recursive implementation
|
| Modifier and Type | Class and Description |
|---|---|
class |
BCTree<V extends Vertex,E extends Edge<V>>
Class represents a block-cut vertex tree and contains methods for its construction given
a separable graph
Let B be the set of blocks and C be the set of cut vertices of a separable graph G.
|
| Modifier and Type | Class and Description |
|---|---|
class |
BCTreeNode
Node of the block-cut vertex tree
|
| Modifier and Type | Class and Description |
|---|---|
class |
BinaryTree<V extends Vertex,E extends Edge<V>>
A binary tree and methods for its construction
|
class |
BinaryTreeNode<V extends Vertex>
Node of the binary tree
|
| Modifier and Type | Class and Description |
|---|---|
class |
PQTree<V extends Vertex,E extends Edge<V>>
Class represents a PQ-tree, which is used in some algorithms for planarity testing
P nodes are cut vertices
Q nodes are nonseparable components
Leaves are virtual vertices (vertices on the other side of edges where one vertex is on subgraph Gk and the
other one is in V-Vk)
|
class |
PQTreeReduction<V extends Vertex,E extends Edge<V>>
Implementation of the PQ-tree reduction procedure, as described by Booth and Lueker.
|
| Modifier and Type | Class and Description |
|---|---|
class |
PQTreeNode
Node of the PQ-tree
|
| Modifier and Type | Class and Description |
|---|---|
class |
AbstractTree<V extends Vertex,E extends Edge<V>>
Abstract class, extended by SPQR tree and proto SPQR tree
|
class |
ProtoSPQRTree<V extends Vertex,E extends Edge<V>>
Used in the construction of SPQR trees
Not a very efficient implementation, needs to be rewritten
Can be used for smaller graphs
|
class |
Skeleton<V extends Vertex,E extends Edge<V>>
Each node is associated with a special graph which is called a skeleton of the node
It is a simplified version of the original graph where some subgraphs were replaces
|
class |
SPQRTree<V extends Vertex,E extends Edge<V>>
SPQR-trees implicitly represent all embeddings of a graph
The triconnected components of a biconnected graph are a system of smaller graphs
that describe all of the 2-vertex cuts in the graph.
|
class |
SPQRTreeNode<V extends Vertex,E extends Edge<V>>
Node of the SPQR tree
|
class |
TreeEdgeWithContent<V extends Vertex,E extends Edge<V>>
Class which implements the
Edge interface and adds the content attribute
Used for constructing SPQR-trees |
| Modifier and Type | Class and Description |
|---|---|
class |
SPQRTreeNode<V extends Vertex,E extends Edge<V>>
Node of the SPQR tree
|
| Modifier and Type | Class and Description |
|---|---|
class |
DFSTree<V extends Vertex,E extends Edge<V>>
DFS tree, with methods for its creation and relevant method
regarding its edges and nodes
|
| Modifier and Type | Method and Description |
|---|---|
static <V extends Vertex,E extends Edge<V>> |
Util.copyGraph(Graph<V,E> graph)
Creates a copy of a graph
|
static <V extends Vertex,E extends Edge<V>> |
Util.createEdge(V origin,
V destination,
java.lang.Class<?> edgeClass)
Creates a graph edge between two vertices of the given class
|
static <V extends Vertex> |
Util.createVertex(java.lang.Class<?> vertexClass)
Creates a vertex of the given class
|
static <V extends Vertex,E extends Edge<V>> |
Util.generateRandomGraph(int numberOfVertices,
java.lang.Class<?> vertexClass,
int numberOfEdges,
java.lang.Class<?> edgesClass)
Generates a random graph
|