Documentation / Algorithms

Lots of small often used algorithms

The class org.graphstream.algorithm.Toolkit contains a lot of very small algorithms that could be often useful with a graph. Most methods take a graph as first argument.



The degreeDistribution(Graph) method allows to obtain an array where each cell index represents the degree, and the value of the cell the number of nodes having this degree. Its complexity is O(n) with n the number of nodes.

The degreeMap(Graph) returns an array of nodes sorted by degree in descending order. The complexity is O(n log(n)) with n the number of nodes.

The averageDegree(Graph) returns the average degree. The complexity is O(1).

The degreeAverageDeviation(Graph) returns the deviation of the average degree. The complexity is O(n) with n the number of nodes.


The density(Graph) method returns the number of links in the graph divided by the total number of possible links. The complexity is O(1).

Clustering coefficient

The clusteringCoefficient(Node) method return the clustering coefficient for the given node. The complexity if O(d^2) where d is the degree of the node.

The clusteringCoefficients(Graph) method return the clustering coefficient of each node of the graph as an array.

The averageClusteringCoefficient(Graph) method return the average clustering coefficient for the graph.

Random nodes and edges

The randomNode(Graph) returns a node chosen at random in the graph. You can alternatively pass a Random instance as parameter with randomNode(Graph, Random). The complexity depends on the kind of graph.

The randomEdge(Graph) returns an edge chosen at random in the graph. You can alternatively pass a Random instance as parameter with randomEdge(Graph, Random). The randomEdge(Node) returns an edge chosen at random within the edge set of the given node. You can also use randomEdge(Node, Random). To chose a random edge of a node inside the entering or leaving edge sets only, you can use randomInEdge(Node) or randomInEdge(Node, Random), or randomOutEdge(Node) or finally randomOutEdge(Node, Random).

Nodes position

Extracting nodes position from attributes can be tricky due to the face the positions can be stored either as separate x, y and z attributes or inside xy or xyz attributes.

To simplify things you can use nodePosition(Node) which returns an array of three doubles, containing the position of the node. You can also use nodePosition(Graph, String) with a graph and a node identifier.

If you already have an array of doubles with at least three cells you can also use nodePosition(Node, double[]) that will store the position in the passed array. You can as well use nodePosition(Graph, String, double[]).

All these methods can also handle the org.graphstream.ui.geom.Point3 class instead of arrays of doubles. Methods that use such an array as argument are the same. Methods that return a Point3 instead of an array are nodePointPosition(Graph, String) and nodePointPosition(Node).


The diameter(Graph) method computes the diameter of the graph, considering it is not weighted but that it is directed. The diameter of the graph is the largest of all the shortest paths from any node to any other node.

The diameter(Graph, String, boolean) method does the same thing, but considers that the graph is weighted if the second argument is non-null. The second argument is the weight attribute name. The third argument indicates if the graph must be considered as directed or not.

The returned diameter is not an integer since some graphs have non-integer weights on edges.

Note that this operation can be quite costly, the algorithm used depends on the fact the graph is weighted or not. If unweighted, the algorithm is in O(n*(n+m)) (it computes a breath-first search from all the vertices to all other vertices and computes the max of the max depths of each of these searches). If weighted the algorithm is the Floyd-Warshall algorithm whose complexity is at worst of O(n^3).

The unweightedEccentricity(Node node,boolean directed) method will compute the maximum distance in edge jumps from the given node toward each other nodes. This is the largest of the shortest paths toward other nodes not considering eventual weights.


You can use this class with a static import for example:

import static org.graphstream.algorithm.Toolkit.*;