Tree, Back, Edge and Cross Edges in DFS of Graph

Last Updated : 15 Feb, 2025

Given a directed graph, the task is to identify tree, forward, back and cross edges present in the graph.

Note: There can be multiple answers.

Example:

Input: Graph
Output:
Tree Edges: 1->2, 2->4, 4->6, 1->3, 3->5, 5->7, 5->8
Forward Edges: 1->8
Back Edges: 6->2
Cross Edges: 5->4

Tree Edge: It is an edge which is present in the tree obtained after applying DFS on the graph. All the Green edges are tree edges.
Forward Edge: It is an edge (u, v) such that v is a descendant but not part of the DFS tree. An edge from 1 to 8 is a forward edge.
Back edge: It is an edge (u, v) such that v is the ancestor of node u but is not part of the DFS tree. Edge from 6 to 2 is a back edge. Presence of back edge indicates a cycle in directed graph.
Cross Edge: It is an edge that connects two nodes such that they do not have any ancestor and a descendant relationship between them. The edge from node 5 to 4 is a cross edge.

Approach:

The idea is to perform a Depth-First Search (DFS) traversal of the directed graph while tracking discovery and finish times to classify edges into Tree, Forward, Back, and Cross edges based on their relationship with visited nodes and the DFS call stack.

Step by step approach:

Initialize discovery and finish time arrays, a visited array, and an inStack array to track nodes in the current DFS recursion stack.
Start DFS from each unvisited node, updating discovery times and marking nodes as visited and in the stack.
If an adjacent node v is unvisited, classify the edge (u, v) as a Tree Edge and recursively call DFS on v.
If v is already visited and present in the recursion stack, classify (u, v) as a Back Edge, indicating a cycle.
If v is already visited but not in the recursion stack and discovery[u] < discovery[v], classify (u, v) as a Forward Edge, meaning v is a descendant of u.
If v is already visited, not in the stack, and discovery[u] > discovery[v], classify (u, v) as a Cross Edge, indicating a connection between different DFS trees.
After processing all neighbors of u, remove u from the stack and update its finish time.

Below is the implementation of the above approach:

C++

// c++ program to identify Tree, Back,  // Edge and Cross Edges in DFS of Graph #include <bits/stdc++.h> using namespace std;  void dfs(int u, vector<vector<int>>& adj, vector<bool>& visited,      vector<bool>& inStack, vector<int>& discovery,      vector<int>& finish, int& timeStamp,     vector<vector<vector<int>>>& edges) {          visited[u] = true;     inStack[u] = true;     discovery[u] = ++timeStamp;          for(int v : adj[u]) {         if(!visited[v]) {                          // Tree Edge             edges[0].push_back({u, v});             dfs(v, adj, visited, inStack,              discovery, finish, timeStamp, edges);         }         else {             if(inStack[v]) {                                  // Back Edge                 edges[2].push_back({u, v});             }             else if(discovery[u] < discovery[v]) {                                  // Forward Edge                 edges[1].push_back({u, v});             }             else {                                  // Cross Edge                 edges[3].push_back({u, v});             }         }     }          inStack[u] = false;     finish[u] = ++timeStamp; }  vector<vector<vector<int>>> classifyEdges(vector<vector<int>>& adj) {     int n = adj.size();          // Array to store discovery timeStamp of node     vector<int> discovery(n, 0);          // Array to store finish timeStamp of node.     vector<int> finish(n, 0);          // Array to check if node is visited     vector<bool> visited(n, false);          // Array to check if node is in call stack.     vector<bool> inStack(n, false);     int timeStamp = 0;          // Initialize result vector with      // 4 empty vectors for each edge type     vector<vector<vector<int>>> edges(4);          // Run DFS for each unvisited vertex     for(int i = 0; i < n; i++) {         if(!visited[i]) {             dfs(i, adj, visited, inStack,              discovery, finish, timeStamp, edges);         }     }          return edges; }  int main() {          vector<vector<int>> adj = {         {1, 2, 7},              {3},              {4},                {5},          {3, 6, 7},         {1},         {},         {}     };          vector<vector<vector<int>>> edges = classifyEdges(adj);          vector<string> edgeNames = {"Tree Edges", "Forward Edges",      "Back Edges", "Cross Edges"};          for(int i = 0; i < 4; i++) {         cout << edgeNames[i] << ": ";         for(auto& edge : edges[i]) {             cout << edge[0] << "->" << edge[1] << " ";         }         cout << endl;     }          return 0; }

Java

// Java program to identify Tree, Back,  // Edge and Cross Edges in DFS of Graph  import java.util.*;  class GfG {      static void dfs(int u, int[][] adj, boolean[] visited,          boolean[] inStack, int[] discovery, int[] finish,          int[] timeStamp, List<int[]>[] edges) {                  visited[u] = true;         inStack[u] = true;         discovery[u] = ++timeStamp[0];                  for (int v : adj[u]) {             if (!visited[v]) {                                  // Tree Edge                 edges[0].add(new int[]{u, v});                 dfs(v, adj, visited, inStack,                  discovery, finish, timeStamp, edges);             } else {                 if (inStack[v]) {                                          // Back Edge                     edges[2].add(new int[]{u, v});                 } else if (discovery[u] < discovery[v]) {                                          // Forward Edge                     edges[1].add(new int[]{u, v});                 } else {                                          // Cross Edge                     edges[3].add(new int[]{u, v});                 }             }         }                  inStack[u] = false;         finish[u] = ++timeStamp[0];     }      static List<int[]>[] classifyEdges(int[][] adj) {         int n = adj.length;                  int[] discovery = new int[n];         int[] finish = new int[n];         boolean[] visited = new boolean[n];         boolean[] inStack = new boolean[n];         int[] timeStamp = {0};                  List<int[]>[] edges = new List[4];         for (int i = 0; i < 4; i++) {             edges[i] = new ArrayList<>();         }                  for (int i = 0; i < n; i++) {             if (!visited[i]) {                 dfs(i, adj, visited, inStack, discovery, finish, timeStamp, edges);             }         }                  return edges;     }      public static void main(String[] args) {         int[][] adj = {             {1, 2, 7},                  {3},                  {4},                    {5},              {3, 6, 7},             {1},             {},             {}         };                  List<int[]>[] edges = classifyEdges(adj);                  String[] edgeNames = {"Tree Edges", "Forward Edges",          "Back Edges", "Cross Edges"};                  for (int i = 0; i < 4; i++) {             System.out.print(edgeNames[i] + ": ");             for (int[] edge : edges[i]) {                 System.out.print(edge[0] + "->" + edge[1] + " ");             }             System.out.println();         }     } }

Python

# Python program to identify Tree, Back,  # Edge and Cross Edges in DFS of Graph  # Function to perform DFS def dfs(u, adj, visited, inStack, discovery, finish, timeStamp, edges):     visited[u] = True     inStack[u] = True     discovery[u] = timeStamp[0] = timeStamp[0] + 1          for v in adj[u]:         if not visited[v]:                          # Tree Edge             edges[0].append([u, v])             dfs(v, adj, visited, inStack, discovery, finish, timeStamp, edges)         else:             if inStack[v]:                                  # Back Edge                 edges[2].append([u, v])             elif discovery[u] < discovery[v]:                                  # Forward Edge                 edges[1].append([u, v])             else:                                  # Cross Edge                 edges[3].append([u, v])          inStack[u] = False     finish[u] = timeStamp[0] = timeStamp[0] + 1  # Function to classify edges def classifyEdges(adj):     n = len(adj)          discovery = [0] * n     finish = [0] * n     visited = [False] * n     inStack = [False] * n     timeStamp = [0]          edges = [[] for _ in range(4)]          for i in range(n):         if not visited[i]:             dfs(i, adj, visited, inStack, discovery, finish, timeStamp, edges)          return edges  if __name__ == "__main__":     adj = [         [1, 2, 7],              [3],              [4],                [5],          [3, 6, 7],         [1],         [],         []     ]          edges = classifyEdges(adj)          edgeNames = ["Tree Edges", "Forward Edges", "Back Edges", "Cross Edges"]          for i in range(4):         print(edgeNames[i] + ":", end=" ")         for edge in edges[i]:             print(f"{edge[0]}->{edge[1]}", end=" ")         print()

// C# program to identify Tree, Back,  // Edge and Cross Edges in DFS of Graph  using System; using System.Collections.Generic;  class GfG {      static void dfs(int u, int[][] adj, bool[] visited,          bool[] inStack, int[] discovery, int[] finish,          int[] timeStamp, List<int[]>[] edges) {                  visited[u] = true;         inStack[u] = true;         discovery[u] = ++timeStamp[0];                  foreach (int v in adj[u]) {             if (!visited[v]) {                                  // Tree Edge                 edges[0].Add(new int[]{u, v});                 dfs(v, adj, visited, inStack,                  discovery, finish, timeStamp, edges);             } else {                 if (inStack[v]) {                                          // Back Edge                     edges[2].Add(new int[]{u, v});                 } else if (discovery[u] < discovery[v]) {                                          // Forward Edge                     edges[1].Add(new int[]{u, v});                 } else {                                          // Cross Edge                     edges[3].Add(new int[]{u, v});                 }             }         }                  inStack[u] = false;         finish[u] = ++timeStamp[0];     }      static List<int[]>[] classifyEdges(int[][] adj) {         int n = adj.Length;                  int[] discovery = new int[n];         int[] finish = new int[n];         bool[] visited = new bool[n];         bool[] inStack = new bool[n];         int[] timeStamp = {0};                  List<int[]>[] edges = new List<int[]>[4];         for (int i = 0; i < 4; i++) {             edges[i] = new List<int[]>();         }                  for (int i = 0; i < n; i++) {             if (!visited[i]) {                 dfs(i, adj, visited, inStack, discovery, finish, timeStamp, edges);             }         }                  return edges;     }      static void Main() {         int[][] adj = {             new int[] {1, 2, 7},                  new int[] {3},                  new int[] {4},                    new int[] {5},              new int[] {3, 6, 7},             new int[] {1},             new int[] {},             new int[] {}         };                  List<int[]>[] edges = classifyEdges(adj);                  string[] edgeNames = {"Tree Edges", "Forward Edges",          "Back Edges", "Cross Edges"};                  for (int i = 0; i < 4; i++) {             Console.Write(edgeNames[i] + ": ");             foreach (var edge in edges[i]) {                 Console.Write(edge[0] + "->" + edge[1] + " ");             }             Console.WriteLine();         }     } }

JavaScript

// JavaScript program to identify Tree, Back,  // Edge and Cross Edges in DFS of Graph  function dfs(u, adj, visited, inStack, discovery,  finish, timeStamp, edges) {     visited[u] = true;     inStack[u] = true;     discovery[u] = ++timeStamp.value;      for (let v of adj[u]) {         if (!visited[v]) {                          // Tree Edge             edges[0].push([u, v]);             dfs(v, adj, visited, inStack, discovery,              finish, timeStamp, edges);         } else {             if (inStack[v]) {                                  // Back Edge                 edges[2].push([u, v]);             } else if (discovery[u] < discovery[v]) {                                  // Forward Edge                 edges[1].push([u, v]);             } else {                                  // Cross Edge                 edges[3].push([u, v]);             }         }     }      inStack[u] = false;     finish[u] = ++timeStamp.value; }  function classifyEdges(adj) {     let n = adj.length;          // Array to store discovery timeStamp of node     let discovery = new Array(n).fill(0);      // Array to store finish timeStamp of node     let finish = new Array(n).fill(0);      // Array to check if node is visited     let visited = new Array(n).fill(false);      // Array to check if node is in call stack     let inStack = new Array(n).fill(false);          let timeStamp = { value: 0 };      // Initialize result array with 4      // empty arrays for each edge type     let edges = [[], [], [], []];      // Run DFS for each unvisited vertex     for (let i = 0; i < n; i++) {         if (!visited[i]) {             dfs(i, adj, visited, inStack,              discovery, finish, timeStamp, edges);         }     }      return edges; }  let adj = [     [1, 2, 7],          [3],          [4],            [5],      [3, 6, 7],     [1],     [],     [] ];  let edges = classifyEdges(adj);  let edgeNames = ["Tree Edges", "Forward Edges", "Back Edges", "Cross Edges"];  for (let i = 0; i < 4; i++) {     let result = edgeNames[i] + ": ";     for (let edge of edges[i]) {         result += edge[0] + "->" + edge[1] + " ";     }     console.log(result); }

Output

Tree Edges: 0->1 1->3 3->5 0->2 2->4 4->6 4->7  Forward Edges: 0->7  Back Edges: 5->1  Cross Edges: 4->3

Time Complexity: O(V+E), where V is the number of nodes and E is the number of edges.
Auxiliary Space: O(V+E), due to recursive stack space, auxiliary arrays (discovery, finish, visited and inStack) and resultant array.

Transitive Closure of a Graph using DFS

him0000

Improve

Article Tags :

Practice Tags :

Tree, Back, Edge and Cross Edges in DFS of Graph

Similar Reads

DFS in different language

Variations of DFS implementations