|
|
| Line 1: |
Line 1: |
| {{Infobox algorithm
| | Friends call him Royal. I am a production and distribution officer. I've usually loved living in Idaho. The thing I adore most bottle tops gathering and now I have time to consider on new things.<br><br>my homepage; [http://vendorportal.citypower.Co.za/Activity-Feed/My-Profile/UserId/18066 vendorportal.citypower.Co.za] |
| |class=
| |
| |image=[[File:Tarjan's Algorithm Animation.gif|thumb|Tarjan's Algorithm Animation]]
| |
| |caption = Tarjan's Algorithm.
| |
| |data=[[Graph (data structure)|Graph]]
| |
| |time= <math>O(|V|+|E|)</math>
| |
| |best-time=
| |
| |average-time=
| |
| |space=
| |
| |optimal=
| |
| |complete=
| |
| }}
| |
| '''Tarjan's Algorithm''' (named for its discoverer, [[Robert Tarjan]]<ref>{{citation|first=R. E.|last=Tarjan|authorlink=Robert Tarjan|title=Depth-first search and linear graph algorithms|journal=[[SIAM Journal on Computing]]|volume=1|year=1972|issue=2|pages=146–160|doi=10.1137/0201010}}</ref>) is a [[graph theory]] [[algorithm]] for finding the [[strongly connected component]]s of a [[Graph (data structure)|graph]]. Although it precedes it chronologically, it can be seen as an improved version of [[Kosaraju's algorithm]], and is comparable in efficiency to the [[path-based strong component algorithm]].
| |
| | |
| == Overview ==
| |
| | |
| The algorithm takes a [[directed graph]] as input, and produces a [[Partition of a set|partition]] of the graph's [[Vertex (graph theory)|vertices]] into the graph's strongly connected components. Each vertex of the graph appears in exactly one of the strongly connected components. Any vertex that is not on a directed cycle forms a strongly connected component all by itself: for example, a vertex whose in-degree or out-degree is 0, or any vertex of an acyclic graph.
| |
| | |
| The basic idea of the algorithm is this: a depth-first search begins from an arbitrary start node (and subsequent depth-first searches are conducted on any nodes that have not yet been found). As usual with depth-first search, the search visits every node of the graph exactly once, declining to revisit any node that has already been explored. Thus, the collection of search trees is a [[spanning forest]] of the graph. The strongly connected components will be recovered as certain subtrees of this forest. The roots of these subtrees are called the "roots" of the strongly connected components. Any node of a strongly connected component might serve as the root, if it happens to be the first node of the component that is discovered by the search. | |
| | |
| === Stack invariant ===
| |
| | |
| The nodes are placed on a [[Stack (data structure)|stack]] in the order in which they are visited. When the depth-first search recursively explores a node <tt>v</tt> and its descendants, those nodes are not all necessarily popped from the stack before this recursive call returns. The crucial [[Invariant (computer science)|invariant property]] is that a node remains on the stack after exploration if and only if it has a path to some node earlier on the stack.
| |
| | |
| At the end of the call that explores <tt>v</tt> and its descendants, we know whether <tt>v</tt> itself has a path to any node earlier on the stack. If so, the call returns, leaving <tt>v</tt> on the stack to preserve the invariant. If not, then <tt>v</tt> must be the root of its strongly connected component, which consists of <tt>v</tt> together with any later nodes on the stack (such nodes all have paths back to <tt>v</tt> but not to any earlier node). This entire component is then popped from the stack and returned, again preserving the invariant.
| |
| | |
| === Bookkeeping ===
| |
| | |
| Each node v is assigned a unique integer <tt>v.index</tt>, which numbers the nodes consecutively in the order in which they are discovered. It also maintains a value <tt>v.lowlink</tt> that represents (roughly speaking) the smallest index of any node known to be reachable from <tt>v</tt>, including <tt>v</tt> itself. Therefore <tt>v</tt> must be left on the stack if <tt>v.lowlink < v.index</tt>, whereas v must be removed as the root of a strongly connected component if <tt>v.lowlink == v.index</tt>. The value <tt>v.lowlink</tt> is computed during the depth-first search from <tt>v</tt>, as this finds the nodes that are reachable from <tt>v</tt>.
| |
| | |
| == The algorithm in pseudocode ==
| |
| '''algorithm''' tarjan '''is'''
| |
| '''input:''' graph ''G'' = (''V'', ''E'')
| |
| '''output:''' set of strongly connected components (sets of vertices)
| |
|
| |
| ''index'' := 0
| |
| ''S'' := empty
| |
| '''for each''' ''v'' '''in''' ''V'' '''do'''
| |
| '''if''' (''v''.index is undefined) '''then'''
| |
| strongconnect(''v'')
| |
| '''end if'''
| |
| '''end for'''
| |
|
| |
| '''function''' strongconnect(''v'')
| |
| ''// Set the depth index for v to the smallest unused index''
| |
| ''v''.index := ''index''
| |
| ''v''.lowlink := ''index''
| |
| ''index'' := ''index'' + 1
| |
| ''S''.push(''v'')
| |
|
| |
| ''// Consider successors of v''
| |
| '''for each''' (''v'', ''w'') '''in''' ''E'' '''do'''
| |
| '''if''' (''w''.index is undefined) '''then'''
| |
| ''// Successor w has not yet been visited; recurse on it''
| |
| strongconnect(''w'')
| |
| ''v''.lowlink := min(''v''.lowlink, ''w''.lowlink)
| |
| '''else if''' (''w'' is in ''S'') '''then'''
| |
| ''// Successor w is in stack S and hence in the current SCC''
| |
| ''v''.lowlink := min(''v''.lowlink, ''w''.index)
| |
| '''end if'''
| |
| '''end for'''
| |
|
| |
| ''// If v is a root node, pop the stack and generate an SCC''
| |
| '''if''' (''v''.lowlink = ''v''.index) '''then'''
| |
| start a new strongly connected component
| |
| '''repeat'''
| |
| ''w'' := ''S''.pop()
| |
| add ''w'' to current strongly connected component
| |
| '''until''' (''w'' = ''v'')
| |
| output the current strongly connected component
| |
| '''end if'''
| |
| '''end function'''
| |
| | |
| The <tt>index</tt> variable is the depth-first search node number counter. <tt>S</tt> is the node stack, which starts out empty and stores the history of nodes explored but not yet committed to a strongly connected component. Note that this is not the normal depth-first search stack, as nodes are not popped as the search returns up the tree; they are only popped when an entire strongly connected component has been found.
| |
| | |
| The outermost loop searches each node that has not yet been visited, ensuring that nodes which are not reachable from the first node are still eventually traversed. The function <tt>strongconnect</tt> performs a single depth-first search of the graph, finding all successors from the node <tt>v</tt>, and reporting all strongly connected components of that subgraph.
| |
| | |
| When each node finishes recursing, if its lowlink is still set to its index, then it is the root node of a strongly connected component, formed by all of the nodes above it on the stack. The algorithm pops the stack up to and including the current node, and presents all of these nodes as a strongly connected component.
| |
| | |
| == Remarks ==
| |
| # Complexity: The Tarjan procedure is called once for each node; the forall statement considers each edge at most twice. The algorithm's running time is therefore linear in the number of edges and nodes in G, i.e. <math>O(|V|+|E|)</math>.
| |
| # The test for whether <tt>w</tt> is on the stack should be done in constant time, for example, by testing a flag stored on each node that indicates whether it is on the stack.
| |
| # While there is nothing special about the order of the nodes within each strongly connected component, one useful property of the algorithm is that no strongly connected component will be identified before any of its successors. Therefore, the order in which the strongly connected components are identified constitutes a reverse [[Topological sorting|topological sort]] of the [[Directed acyclic graph|DAG]] formed by the strongly connected components.<ref>{{cite web|last=Harrison|first=Paul|title=Robust topological sorting and Tarjan's algorithm in Python|url=http://www.logarithmic.net/pfh/blog/01208083168|accessdate=9 February 2011}}</ref>
| |
| | |
| == References ==
| |
| <references />
| |
| | |
| == External links ==
| |
| *[http://www.ics.uci.edu/~eppstein/161/960220.html#sca Description of Tarjan's Algorithm]
| |
| *[http://stackoverflow.com/questions/6643076/tarjan-cycle-detection-help-c#sca Implementation of Tarjan's Algorithm in .NET]
| |
| *[https://github.com/danielrbradley/CycleDetection Implementation of Tarjan's Algorithm in .NET (GitHub)]
| |
| *[https://github.com/bwesterb/py-tarjan/ Another implementation of Tarjan's Algorithm in Python]
| |
| *[https://gist.github.com/1440602 Implementation of Tarjan's Algorithm in Javascript]
| |
| | |
| [[Category:Graph algorithms]]
| |
| [[Category:Graph connectivity]]
| |
| [[Category:Articles with example pseudocode]]
| |
Friends call him Royal. I am a production and distribution officer. I've usually loved living in Idaho. The thing I adore most bottle tops gathering and now I have time to consider on new things.
my homepage; vendorportal.citypower.Co.za