The Connected Components Algorithm
This algorithm computes connected components for a given graph. Connected components are the set of its connected subgraphs. Two nodes belong to the same connected component when there exists a path (without considering the direction of the edges) between them. Therefore, the algorithm does not consider the direction of edges. The number of connected components of an undirected graph is equal to the number of connected components of the same directed graph.
For the initial computation, let n be the number of nodes, then the complexity is 0(n). For the re-optimization steps, let k be the number of nodes concerned by the changes (k <= n), the complexity is O(k).
A Dynamic Algorithm
This algorithm tries to handle the dynamics of the graph, trying not to recompute all from scratch at each change (kind of re-optimization). In this way, each instance of the algorithm is registered as a graph sink. Each change in the graph topology may affect the algorithm.
To start using the algorithm, you first need an instance of
org.graphstream.graph.Graph, then you only have to instantiate the
algorithm class. Whether you specify a reference to the graph in the
constructor or you set it with the
The computation of the algorithm starts only when the graph is specified with
init(Graph) method or with the appropriated constructor. In case
of a static graph, you may call the
compute() method. In case of a
dynamic graph, the algorithm will compute itself automatically when an event
(node or edge added or removed) occurs.
Finally you may ask the algorithm for the number of connected components at
any moment with a call to the
Here is a basic example showing the adaptive behavior of the algorithm:
This example should give you the following output:
1 connected component(s) in this graph, so far. Eventually, there are 2.
Threshold and Ceiling
It is possible to get rid of connected components belong a size threshold
when counting the overall number of connected components. It is also possible
to define a ceiling size for the connected component. Above that size
ceiling, connected components will not be counted. Use the
getConnectedComponentsCount(int, int) methods.
You can tag each node with an integer that identifies the component it
pertains to using
setCountAttribute(String). The argument of this
method is an arbitrary name that will be used as attribute on each node of
the graph. The value of this attribute will be an integer (counting from
zero) that is different for each connected component.
getGiantComponent() method gives you a list of nodes belonging
to the biggest connected component of the graph.
The cut attribute is a feature that can optionally simulate a given edge to
be invisible (as if the edge did not exist). In other words if an edge is
given such a cut attribute, it will be ignored by the algorithm when
counting. You can enable (or disable by passing null) the cut attribute by
specifying it with the
setCutAttribute(String) method, and by giving
the special edges the same attribute.
What is it useful for? Well you may want to simulate the removal of a given edge and see if it increases the number of connected components. You may not want to really remove and then re-add that edge in the graph, because such removal event may have consequences on other algorithms, viewer, writers…
Note that setting the cut attribute will trigger a new computation of the algorithm.