The Algorithms logo
The Algorithms
AboutDonate

Tarjan

S
/**
 * @function tarjan
 * @description Given a graph, find the strongly connected components(SCC) in reverse topological order. A set of nodes form a SCC if there is a path between all pairs of points within that set.
 * @Complexity_Analysis
 * Time complexity: O(V + E). We perform a DFS of (V + E)
 * Space Complexity: O(V). We hold numerous structures all of which at worst holds O(V) nodes.
 * @param {[number, number][][]} graph - The graph in adjacency list form
 * @return {number[][]} - An array of SCCs, where an SCC is an array with the indices of each node within that SCC. The order of SCCs in the array are in reverse topological order.
 * @see https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm
 */
export const tarjan = (graph: number[][]): number[][] => {
  if (graph.length === 0) {
    return []
  }

  let index = 0
  // The order in which we discover nodes
  const discovery: number[] = Array(graph.length)
  // For each node, holds the furthest ancestor it can reach
  const low: number[] = Array(graph.length).fill(undefined)
  // Holds the nodes we have visited in a DFS traversal and are considering to group into a SCC
  const stack: number[] = []
  // Holds the elements in the stack.
  const stackContains = Array(graph.length).fill(false)
  const sccs: number[][] = []

  const dfs = (node: number) => {
    discovery[node] = index
    low[node] = index
    ++index
    stack.push(node)
    stackContains[node] = true

    for (const child of graph[node]) {
      if (low[child] === undefined) {
        dfs(child)
        if (low[child] < low[node]) {
          // Child node loops back to this node's ancestor. Update the low node.
          low[node] = low[child]
        }
      } else if (stackContains[child] && low[node] > discovery[child]) {
        // Found a backedge. Update the low for this node if needed.
        low[node] = discovery[child]
      }
    }

    if (discovery[node] == low[node]) {
      // node is the root of a SCC. Gather the SCC's nodes from the stack.
      const scc: number[] = []
      let i
      for (i = stack.length - 1; stack[i] != node; --i) {
        scc.push(stack[i])
        stackContains[stack[i]] = false
        stack.pop()
      }
      scc.push(stack[i])
      stackContains[stack[i]] = false
      stack.pop()
      sccs.push(scc)
    }
  }

  for (let i = 0; i < graph.length; ++i) {
    if (low[i] === undefined) {
      dfs(i)
    }
  }
  return sccs
}