Skip to content
Related Articles
Printing pre and post visited times in DFS of a graph
• Difficulty Level : Easy
• Last Updated : 14 Dec, 2020

Depth First Search (DFS) marks all the vertices of a graph as visited. So for making DFS useful, some additional information can also be stored. For instance, the order in which the vertices are visited while running DFS.

Pre-visit and Post-visit numbers are the extra information that can be stored while running a DFS on a graph and which turns out to be really useful. Pre-visit number tells the time at which the node gets into the recursion stack and Post-visit number tells the time at which the node comes out from recursion stack of DFS.

Example: The numbers written in brackets denote [Pre-visit number, Post-visit number].

Pre and Post numbers are widely used in graph algorithms. For example, they can be used to find out whether a particular node lies in the sub-tree of another node
To find whether u lies in the sub-tree of v or not we just compare the pre and post number of u and v. If pre[u] > pre[v] and post[u] < post[v] then u lies in the sub-tree of v otherwise not. You can see above example for more clarification.

Pre-visit and Post-visit numbers can be found out by simple DFS. We will take two arrays one for storing pre numbers and one for post numbers and by taking a variable which will keep track of the time. The implementation of the same is given below:

## C++

 `#include ``using` `namespace` `std;` `// Variable to keep track of time``int` `Time = 1;` `// Function to perform DFS starting from node u``void` `dfs(``int` `u, vector> aList,``                       ``vector<``int``> &pre,``                       ``vector<``int``> &post,``                       ``vector<``int``> &vis)``{``    ` `    ``// Storing the pre number whenever``    ``// the node comes into recursion stack``    ``pre[u] = Time;` `    ``// Increment time``    ``Time++;``    ``vis[u] = 1;``    ` `    ``for``(``int` `v : aList[u])``    ``{``        ``if` `(vis[v] == 0)``            ``dfs(v, aList, pre, post, vis);``    ``}` `    ``// Storing the post number whenever``    ``// the node goes out of recursion stack``    ``post[u] = Time;``    ``Time++;``}` `// Driver Code   ``int` `main()``{``    ` `    ``// Number of nodes in graph``    ``int` `n = 6;` `    ``// Adjacency list``    ``vector> aList(n + 1);``    ` `    ``vector<``int``> pre(n + 1);``    ``vector<``int``> post(n + 1);` `    ``// Visited array``    ``vector<``int``> vis(n + 1);` `    ``// Edges``    ``aList.push_back(2);``    ``aList.push_back(1);``    ``aList.push_back(4);``    ``aList.push_back(2);``    ``aList.push_back(3);``    ``aList.push_back(1);``    ``aList.push_back(4);``    ``aList.push_back(3);``    ``aList.push_back(5);``    ``aList.push_back(3);``    ``aList.push_back(6);``    ``aList.push_back(5);` `    ``// DFS starting at Node 1``    ``dfs(1, aList, pre, post, vis);` `    ``// Number of nodes in graph``    ``for``(``int` `i = 1; i <= n; i++)``        ``cout << ``"Node "` `<< i << ``" Pre number "``             ``<< pre[i] << ``" Post number "``             ``<< post[i] << endl;` `    ``return` `0;``}` `// This code is contributed by divyesh072019`

## Java

 `import` `java.util.*;``public` `class` `GFG {` `    ``// Variable to keep track of time``    ``static` `int` `time = ``1``;` `    ``// Function to perform DFS starting from node u``    ``static` `void` `dfs(``int` `u, ArrayList > aList,``                    ``int` `pre[], ``int` `post[], ``int` `vis[])``    ``{` `        ``// Storing the pre number whenever``        ``// the node comes into recursion stack``        ``pre[u] = time;` `        ``// Increment time``        ``time++;``        ``vis[u] = ``1``;``        ``for` `(``int` `v : aList.get(u)) {``            ``if` `(vis[v] == ``0``)``                ``dfs(v, aList, pre, post, vis);``        ``}` `        ``// Storing the post number whenever``        ``// the node goes out of recursion stack``        ``post[u] = time;``        ``time++;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String args[])``    ``{` `        ``// Number of nodes in graph``        ``int` `n = ``6``;` `        ``// Adjacency list``        ``ArrayList > aList``            ``= ``new` `ArrayList >(n + ``1``);``        ``for` `(``int` `i = ``1``; i <= n; i++) {``            ``ArrayList list = ``new` `ArrayList<>();``            ``aList.add(list);``        ``}``        ``aList.add(``new` `ArrayList());``        ``int` `pre[] = ``new` `int``[n + ``1``];``        ``int` `post[] = ``new` `int``[n + ``1``];` `        ``// Visited array``        ``int` `vis[] = ``new` `int``[n + ``1``];` `        ``// Edges``        ``aList.get(``1``).add(``2``);``        ``aList.get(``2``).add(``1``);``        ``aList.get(``2``).add(``4``);``        ``aList.get(``4``).add(``2``);``        ``aList.get(``1``).add(``3``);``        ``aList.get(``3``).add(``1``);``        ``aList.get(``3``).add(``4``);``        ``aList.get(``4``).add(``3``);``        ``aList.get(``3``).add(``5``);``        ``aList.get(``5``).add(``3``);``        ``aList.get(``5``).add(``6``);``        ``aList.get(``6``).add(``5``);` `        ``// DFS starting at Node 1``        ``dfs(``1``, aList, pre, post, vis);` `        ``// Number of nodes in graph``        ``for` `(``int` `i = ``1``; i <= n; i++)``            ``System.out.println(``"Node "` `+ i + ``" Pre number "``                               ``+ pre[i] + ``" Post number "` `+ post[i]);``    ``}``}`

## Python3

 `# Variable to keep track of time``time ``=` `1` `# Function to perform DFS starting``# from node u``def` `dfs(u, aList, pre, post, vis):``    ` `    ``global` `time``    ` `    ``# Storing the pre number whenever``    ``# the node comes into recursion stack``    ``pre[u] ``=` `time` `    ``# Increment time``    ``time ``+``=` `1``    ` `    ``vis[u] ``=` `1``    ` `    ``for` `v ``in` `aList[u]:``        ``if` `(vis[v] ``=``=` `0``):``            ``dfs(v, aList, pre, post, vis)``            ` `    ``# Storing the post number whenever``    ``# the node goes out of recursion stack``    ``post[u] ``=` `time``    ``time ``+``=` `1` `# Driver code``if` `__name__``=``=``'__main__'``:``    ` `    ``# Number of nodes in graph``    ``n ``=` `6` `    ``# Adjacency list``    ``aList ``=` `[[] ``for` `i ``in` `range``(n ``+` `1``)]``    ` `    ``pre ``=` `[``0` `for` `i ``in` `range``(n ``+` `1``)]``    ``post ``=` `[``0` `for` `i ``in` `range``(n ``+` `1``)]` `    ``# Visited array``    ``vis ``=` `[``0` `for` `i ``in` `range``(n ``+` `1``)]``    ` `    ``# Edges``    ``aList[``1``].append(``2``)``    ``aList[``2``].append(``1``)``    ``aList[``2``].append(``4``)``    ``aList[``4``].append(``2``)``    ``aList[``1``].append(``3``)``    ``aList[``3``].append(``1``)``    ``aList[``3``].append(``4``)``    ``aList[``4``].append(``3``)``    ``aList[``3``].append(``5``)``    ``aList[``5``].append(``3``)``    ``aList[``5``].append(``6``)``    ``aList[``6``].append(``5``)` `    ``# DFS starting at Node 1``    ``dfs(``1``, aList, pre, post, vis)` `    ``# Number of nodes in graph``    ``for` `i ``in` `range``(``1``, n ``+` `1``):``        ``print``(``"Node "` `+` `str``(i) ``+``              ``" Pre number "` `+` `str``(pre[i]) ``+``              ``" Post number "` `+` `str``(post[i]))` `# This code is contributed by rutvik_56`

## C#

 `using` `System;``using` `System.Collections;``using` `System.Collections.Generic;` `class` `GFG{`` ` `// Variable to keep track of time``static` `int` `time = 1;` `// Function to perform DFS starting from node u``static` `void` `dfs(``int` `u, ArrayList aList,``                ``int` `[]pre, ``int` `[]post,``                ``int` `[]vis)``{``    ` `    ``// Storing the pre number whenever``    ``// the node comes into recursion stack``    ``pre[u] = time;` `    ``// Increment time``    ``time++;``    ``vis[u] = 1;``    ` `    ``foreach``(``int` `v ``in` `(ArrayList)aList[u])``    ``{``        ``if` `(vis[v] == 0)``            ``dfs(v, aList, pre, post, vis);``    ``}` `    ``// Storing the post number whenever``    ``// the node goes out of recursion stack``    ``post[u] = time;``    ``time++;``}` `// Driver code``public` `static` `void` `Main(``string` `[]args)``{``    ` `    ``// Number of nodes in graph``    ``int` `n = 6;` `    ``// Adjacency list``    ``ArrayList aList = ``new` `ArrayList(n + 1);``    ` `    ``for``(``int` `i = 1; i <= n; i++)``    ``{``        ``ArrayList list = ``new` `ArrayList();``        ``aList.Add(list);``    ``}``    ``aList.Add(``new` `ArrayList());``    ``int` `[]pre = ``new` `int``[n + 1];``    ``int` `[]post = ``new` `int``[n + 1];` `    ``// Visited array``    ``int` `[]vis = ``new` `int``[n + 1];` `    ``// Edges``    ``((ArrayList)aList).Add(2);``    ``((ArrayList)aList).Add(1);``    ``((ArrayList)aList).Add(4);``    ``((ArrayList)aList).Add(2);``    ``((ArrayList)aList).Add(3);``    ``((ArrayList)aList).Add(1);``    ``((ArrayList)aList).Add(4);``    ``((ArrayList)aList).Add(3);``    ``((ArrayList)aList).Add(5);``    ``((ArrayList)aList).Add(3);``    ``((ArrayList)aList).Add(6);``    ``((ArrayList)aList).Add(5);` `    ``// DFS starting at Node 1``    ``dfs(1, aList, pre, post, vis);` `    ``// Number of nodes in graph``    ``for``(``int` `i = 1; i <= n; i++)``        ``Console.WriteLine(``"Node "` `+ i +``                          ``" Pre number "` `+ pre[i] +``                          ``" Post number "` `+ post[i]);``}``}` `// This code is contributed by pratham76`
Output:
```Node 1 Pre number 1 Post number 12
Node 2 Pre number 2 Post number 11
Node 3 Pre number 4 Post number 9
Node 4 Pre number 3 Post number 10
Node 5 Pre number 5 Post number 8
Node 6 Pre number 6 Post number 7```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live

My Personal Notes arrow_drop_up