C program to implement depth first search in graph

If the pushed order is 2 , 4 , 3 , the vertices in the stack are:. This is not an answer, but an extended comment, showing the application of the algorithm in amit's answer to the graph in the current version of the question, assuming 1 is the start node and its neighbors are pushed in the order 2, 4, Thus applying the algorithm pushing 1's neighbors in the order 2, 4, 3 results in visit order 1, 3, 2, 4.

Regardless of the push order for 1's neighbors, 2 and 3 will be adjacent in the visit order because whichever is visited first will push the other, which is not yet visited, as well as 1 which has been visited. That's not accurate, let me explain a bit more. Recursive DFS uses the call stack to keep state, meaning you do not manage a separate stack yourself. However, for a large graph, recursive DFS or any recursive function that is may result in a deep recursion, which can crash your problem with a stack overflow not this website, the real thing.

It has a different space utilization, but if you implement it just like BFS, but using a stack rather than a queue, you will use more space than non-recursive DFS. In the first piece of code you are putting all the adjacent nodes in the stack before iterating to the next adjacent vertex and that has a space cost. If the graph is large it can make a significant difference. If you decide to solve the space problem by iterating over the adjacency list again after popping the stack, that's going to add time complexity cost.

One solution is to add items to the stack one by one, as you visit them. To achieve this you can save an iterator in the stack to resume the iteration after popping. In Java you can set the stack size as a JVM parameter. Recursion is a way to use the call stack to store the state of the graph traversal. You can use the stack explicitly, say by having a local variable of type std::stack , then you won't need the recursion to implement the DFS, but just a loop. Python code.

The space complexity is O V due to the worst-case where there is a path that contains every vertex without any backtracking i. The example code uses a complete digraph where every vertex is connected to every other vertex. Hence it is not necessary to store an explicit edge list for each node, as the graph is an edge list the graph G contains every vertex. Note that time here is measuring V operations and not E.

Acutally, stack is not well able to deal with discover time and finish time, if we want to implement DFS with stack, and want to deal with discover time and finish time, we would need to resort to another recorder stack, my implementation is shown below, have test correct, below is for case-1, case-2 and case-3 graph.

I think you need to use a visited[n] boolean array to check if the current node is visited or not earlier. A recursive algorithm works very well for DFS as we try to plunge as deeply as we can, ie. Using Stack and implementing as done by the call stack in the recursion process-. The Idea is to push a vertex in the stack, and then push its vertex adjacent to it which is stored in a adjacency list at the index of the vertex and then continue this process until we cannot move further in the graph, now if we cannot move ahead in the graph then we will remove the vertex which is currently on the top of the stack as it is unable to take us on any vertex which is unvisited.

Now, using stack we take care of the point that the vertex is only removed from the stack when all the vertices that can be explored from the current vertex have been visited, which was being done by the recursion process automatically.

The above parenthesis show the order in which the vertex is added on the stack and removed from the stack, so a parenthesis for a vertex is closed only when all the vertices that can be visited from it have been done. Stack Overflow for Teams — Collaborate and share knowledge with a private group.

Create a free Team What is Teams? Collectives on Stack Overflow. Learn more. How to implement depth first search for graph with a non-recursive approach Ask Question. Asked 7 years, 11 months ago.

Active 1 year, 5 months ago. Viewed 74k times. Since 0 has already been visited, we visit 2 instead.

Vertex 2 has an unvisited adjacent vertex in 4, so we add that to the top of the stack and visit it. After we visit the last element 3, it doesn't have any unvisited adjacent nodes, so we have completed the Depth First Traversal of the graph. The pseudocode for DFS is shown below.

In the init function, notice that we run the DFS function on every node. This is because the graph might have two different disconnected parts so to make sure that we cover every vertex, we can also run the DFS algorithm on every node. The code for the Depth First Search Algorithm with an example is shown below. The code has been simplified so that we can focus on the algorithm rather than other details. Course Index Explore Programiz. Start Learning DSA.

Popular Tutorials Quicksort Algorithm. Merge Sort Algorithm. Linked List Data Structure. Hash Table Data Structure. Dynamic Programming. Explore Python Examples. I have tried it for 9 nodes entered 81 elements and at last all get disappeared. I have tried this two times and get realized that getch is remaining. After inserting this line I could see the output. Then I have converted it to VB. I am sure it will be very great help for me. Thanks a lot. Your email address will not be published.

Most of graph problems involve traversal of a graph. Traversal of a graph means visiting each node and visiting exactly once. There are two types of traversal in graphs i.

It is like tree. Traversal can start from any vertex, say V i. V i is visited and then all vertices adjacent to V i are traversed recursively using DFS. Since, a graph can have cycles.