| Package | Description | 
|---|---|
| org.jgrapht.alg.cycle | 
 Algorithms related to graph cycles. 
 | 
| org.jgrapht.alg.interfaces | 
 Algorithm related interfaces. 
 | 
| org.jgrapht.alg.shortestpath | 
 Shortest-path related algorithms. 
 | 
| org.jgrapht.alg.tour | 
 Graph tours related algorithms. 
 | 
| org.jgrapht.graph | 
 Implementations of various graphs. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
GraphPath<V,E> | 
BergeGraphInspector.getCertificate()
Returns the certificate in the form of a hole or anti-hole in the inspected graph, when the
  
BergeGraphInspector.isBerge(org.jgrapht.Graph<V, E>, boolean) method is previously called with
 computeCertificate=true. | 
GraphPath<V,E> | 
WeakChordalityInspector.getCertificate()
Computes and returns the certificate in the form of a hole or anti-hole in the inspected
  
graph. | 
GraphPath<V,E> | 
ChinesePostman.getCPPSolution(Graph<V,E> graph)
Solves the Chinese Postman Problem on the given graph. 
 | 
GraphPath<V,E> | 
HierholzerEulerianCycle.getEulerianCycle(Graph<V,E> g)
Compute an Eulerian cycle of a graph. 
 | 
GraphPath<V,E> | 
ChordalityInspector.getHole()
A graph which is not chordal, must contain a
 hole (chordless cycle on 4 or more
 vertices). 
 | 
static <V,E> GraphPath<V,E> | 
Cycles.simpleCycleToGraphPath(Graph<V,E> graph,
                      List<E> cycle)
Transform a simple cycle from an edge set representation to a graph path. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
GraphPath<V,E> | 
EulerianCycleAlgorithm.getEulerianCycle(Graph<V,E> graph)
Compute an Eulerian cycle of a graph. 
 | 
GraphPath<V,E> | 
ShortestPathAlgorithm.SingleSourcePaths.getPath(V sink)
Return the path from the source vertex to the sink vertex. 
 | 
GraphPath<V,E> | 
ShortestPathAlgorithm.getPath(V source,
       V sink)
Get a shortest path from a source vertex to a sink vertex. 
 | 
GraphPath<V,E> | 
HamiltonianCycleAlgorithm.getTour(Graph<V,E> graph)
Computes a tour. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
Set<GraphPath<V,E>> | 
CycleBasisAlgorithm.CycleBasis.getCyclesAsGraphPaths()
Return the set of cycles of the cycle basis. 
 | 
Set<GraphPath<V,E>> | 
CycleBasisAlgorithm.CycleBasisImpl.getCyclesAsGraphPaths()
Return the set of cycles of the cycle basis. 
 | 
Set<GraphPath<V,E>> | 
TreeToPathDecompositionAlgorithm.PathDecomposition.getPaths()
Set of disjoint paths of the decomposition 
 | 
Set<GraphPath<V,E>> | 
TreeToPathDecompositionAlgorithm.PathDecompositionImpl.getPaths()  | 
List<GraphPath<V,E>> | 
MultiObjectiveShortestPathAlgorithm.MultiObjectiveSingleSourcePaths.getPaths(V sink)
Return the path from the source vertex to the sink vertex. 
 | 
List<GraphPath<V,E>> | 
MultiObjectiveShortestPathAlgorithm.getPaths(V source,
        V sink)
Get a shortest path from a source vertex to a sink vertex. 
 | 
List<GraphPath<V,E>> | 
KShortestPathAlgorithm.getPaths(V source,
        V sink,
        int k)
Get a list of k-shortest paths from a source vertex to a sink vertex. 
 | 
| Modifier and Type | Field and Description | 
|---|---|
protected Map<V,GraphPath<V,E>> | 
ListSingleSourcePathsImpl.paths
One path per vertex 
 | 
protected Map<V,List<GraphPath<V,E>>> | 
ListMultiObjectiveSingleSourcePathsImpl.paths
One path per vertex 
 | 
| Modifier and Type | Method and Description | 
|---|---|
protected GraphPath<V,E> | 
BhandariKDisjointShortestPaths.calculateShortestPath(V startVertex,
                     V endVertex)  | 
protected GraphPath<V,E> | 
SuurballeKDisjointShortestPaths.calculateShortestPath(V startVertex,
                     V endVertex)  | 
protected GraphPath<V,E> | 
BaseBidirectionalShortestPathAlgorithm.createPath(org.jgrapht.alg.shortestpath.BaseBidirectionalShortestPathAlgorithm.BaseSearchFrontier forwardFrontier,
          org.jgrapht.alg.shortestpath.BaseBidirectionalShortestPathAlgorithm.BaseSearchFrontier backwardFrontier,
          double weight,
          V source,
          V commonVertex,
          V sink)
Builds shortest path between  
source and sink based on the information
 provided by search frontiers and common vertex. | 
static <V,E> GraphPath<V,E> | 
BidirectionalDijkstraShortestPath.findPathBetween(Graph<V,E> graph,
               V source,
               V sink)
Find a path between two vertices. 
 | 
static <V,E> GraphPath<V,E> | 
BellmanFordShortestPath.findPathBetween(Graph<V,E> graph,
               V source,
               V sink)
Find a path between two vertices. 
 | 
static <V,E> GraphPath<V,E> | 
BFSShortestPath.findPathBetween(Graph<V,E> graph,
               V source,
               V sink)
Find a path between two vertices. 
 | 
static <V,E> GraphPath<V,E> | 
DijkstraShortestPath.findPathBetween(Graph<V,E> graph,
               V source,
               V sink)
Find a path between two vertices. 
 | 
GraphPath<?,?> | 
NegativeCycleDetectedException.getCycle()
Get the actual negative cycle, or null if not provided. 
 | 
GraphPath<V,E> | 
ListSingleSourcePathsImpl.getPath(V targetVertex)
Return the path from the source vertex to the sink vertex. 
 | 
GraphPath<V,E> | 
TreeSingleSourcePathsImpl.getPath(V targetVertex)
Return the path from the source vertex to the sink vertex. 
 | 
GraphPath<V,E> | 
BidirectionalDijkstraShortestPath.getPath(V source,
       V sink)  | 
GraphPath<V,E> | 
BidirectionalAStarShortestPath.getPath(V source,
       V sink)
Get a shortest path from a source vertex to a sink vertex. 
 | 
GraphPath<V,E> | 
FloydWarshallShortestPaths.getPath(V a,
       V b)
Get a shortest path from a source vertex to a sink vertex. 
 | 
GraphPath<V,E> | 
JohnsonShortestPaths.getPath(V source,
       V sink)
Get a shortest path from a source vertex to a sink vertex. 
 | 
GraphPath<V,E> | 
DeltaSteppingShortestPath.getPath(V source,
       V sink)
Get a shortest path from a source vertex to a sink vertex. 
 | 
GraphPath<V,E> | 
BellmanFordShortestPath.getPath(V source,
       V sink)
Get a shortest path from a source vertex to a sink vertex. 
 | 
GraphPath<V,E> | 
BFSShortestPath.getPath(V source,
       V sink)
Get a shortest path from a source vertex to a sink vertex. 
 | 
GraphPath<V,E> | 
AStarShortestPath.getPath(V sourceVertex,
       V targetVertex)
Calculates (and returns) the shortest path from the sourceVertex to the targetVertex. 
 | 
GraphPath<V,E> | 
DijkstraShortestPath.getPath(V source,
       V sink)
Get a shortest path from a source vertex to a sink vertex. 
 | 
GraphPath<V,E> | 
YenShortestPathIterator.next() | 
GraphPath<V,E> | 
EppsteinShortestPathIterator.next() | 
| Modifier and Type | Method and Description | 
|---|---|
List<GraphPath<V,E>> | 
AllDirectedPaths.getAllPaths(Set<V> sourceVertices,
           Set<V> targetVertices,
           boolean simplePathsOnly,
           Integer maxPathLength)
Calculate (and return) all paths from the source vertices to the target vertices. 
 | 
List<GraphPath<V,E>> | 
AllDirectedPaths.getAllPaths(V sourceVertex,
           V targetVertex,
           boolean simplePathsOnly,
           Integer maxPathLength)
Calculate (and return) all paths from the source vertex to the target vertex. 
 | 
List<GraphPath<V,E>> | 
ListMultiObjectiveSingleSourcePathsImpl.getPaths(V targetVertex)  | 
List<GraphPath<V,E>> | 
MartinShortestPath.getPaths(V source,
        V sink)  | 
List<GraphPath<V,E>> | 
EppsteinKShortestPath.getPaths(V source,
        V sink,
        int k)
Computes  
k shortest paths between source and sink. | 
List<GraphPath<V,E>> | 
YenKShortestPath.getPaths(V source,
        V sink,
        int k)
Computes  
k shortest loopless paths between source and sink. | 
List<GraphPath<V,E>> | 
KShortestSimplePaths.getPaths(V startVertex,
        V endVertex,
        int k)
Returns a list of the $k$ shortest simple paths in increasing order of weight. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
boolean | 
PathValidator.isValidPath(GraphPath<V,E> partialPath,
           E edge)
Checks if an edge can be added to a previous path element. 
 | 
void | 
NegativeCycleDetectedException.setCycle(GraphPath<?,?> cycle)
Set the negative cycle. 
 | 
| Constructor and Description | 
|---|
NegativeCycleDetectedException(String message,
                              GraphPath<?,?> cycle)
Constructs a new exception with the specified detail message. 
 | 
| Constructor and Description | 
|---|
ListMultiObjectiveSingleSourcePathsImpl(Graph<V,E> graph,
                                       V source,
                                       Map<V,List<GraphPath<V,E>>> paths)
Construct a new instance. 
 | 
ListSingleSourcePathsImpl(Graph<V,E> graph,
                         V source,
                         Map<V,GraphPath<V,E>> paths)
Construct a new instance. 
 | 
YenShortestPathIterator(Graph<V,E> graph,
                       V source,
                       V sink,
                       Supplier<org.jheaps.AddressableHeap<Double,GraphPath<V,E>>> heapSupplier)
Constructs an instance of the algorithm for given  
graph, source, sink
 and heapSupplier. | 
| Modifier and Type | Method and Description | 
|---|---|
GraphPath<V,E> | 
TwoOptHeuristicTSP.getTour(Graph<V,E> graph)
Computes a 2-approximate tour. 
 | 
GraphPath<V,E> | 
TwoApproxMetricTSP.getTour(Graph<V,E> graph)
Computes a 2-approximate tour. 
 | 
GraphPath<V,E> | 
PalmerHamiltonianCycle.getTour(Graph<V,E> graph)
Computes a Hamiltonian tour. 
 | 
GraphPath<V,E> | 
HeldKarpTSP.getTour(Graph<V,E> graph)
Computes a minimum-cost Hamiltonian tour. 
 | 
GraphPath<V,E> | 
ChristofidesThreeHalvesApproxMetricTSP.getTour(Graph<V,E> graph)
Computes a $3/2$-approximate tour. 
 | 
GraphPath<V,E> | 
TwoOptHeuristicTSP.improveTour(GraphPath<V,E> tour)
Try to improve a tour by running the 2-opt heuristic. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
GraphPath<V,E> | 
TwoOptHeuristicTSP.improveTour(GraphPath<V,E> tour)
Try to improve a tour by running the 2-opt heuristic. 
 | 
| Modifier and Type | Class and Description | 
|---|---|
class  | 
GraphWalk<V,E>
A walk in a graph is an alternating sequence of vertices and edges, starting and ending at a
 vertex, in which each edge is adjacent in the sequence to its two endpoints. 
 | 
Copyright © 2019. All rights reserved.