Scribd
Upload
34 views7 pages

Akhilesh DAA 3.1

The document describes an experiment to implement depth-first search (DFS) on an undirected graph and use it to find the topological sort of a directed acyclic graph. It outlines the steps to perform DFS and topological sorting, provides sample code implementing DFS and topological sorting on a graph, and analyzes the time and space complexity. The learning outcomes are stated as understanding DFS, topological sorting, and their implementation and analysis of time/space complexity on different graph types.

Uploaded by

harshit143singh
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
34 views7 pages

Akhilesh DAA 3.1

The document describes an experiment to implement depth-first search (DFS) on an undirected graph and use it to find the topological sort of a directed acyclic graph. It outlines the steps to perform DFS and topological sorting, provides sample code implementing DFS and topological sorting on a graph, and analyzes the time and space complexity. The learning outcomes are stated as understanding DFS, topological sorting, and their implementation and analysis of time/space complexity on different graph types.

Uploaded by

harshit143singh
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 7

Experiment-3.

Student Name: Akhilesh Kumar Singh UID: 21BCS7126


Branch: BE-CSE Section/Group: 21BCS_IOT-605 B
Semester: 5th Date of Performance: 17/10/23
Subject Name: Design and Analysis of Subject Code: 21CSH-311
Algorithms with LAB

Aim:
Develop a program and analyze complexity to do a depth-first search (DFS) on an undirected
graph. Implementing an application of DFS such as to find the topological sort of a directed
acyclic graph

Objective:

Code and analyze to do a depth-first search (DFS) on an undirected graph. Implementing an


application of DFS such as to find the topological sort of a directed acyclic graph

Input/Apparatus Used:

Visual studio code, GDB compiler, etc.

Procedure/Algorithm:
For DFS:

Step-1: Create a 'Graph' object with a specified number of vertices (V).


Step-2: Initialize an adjacency list to represent the graph.
Step-3: Use the 'addEdge' function to add directed edges between vertices, building the
graph.
Step-4: Initialize a boolean array 'visited' to track visited vertices.

Name: Akhilesh Kumar Singh UID: 21BCS7126


Step-5: Initialize an empty stack for DFS traversal.
Step-6: For each unvisited vertex in the graph, perform the following:
 Call the 'DFSUtil' function with the current vertex, 'visited', and the stack as
parameters.
 In the 'DFSUtil' function, mark the vertex as visited and explore all its unvisited
neighbors recursively.
Step-7: Push the visited vertex onto the stack as it is finished.
Step-8: After all vertices are visited, pop vertices from the stack and print them to display
the DFS traversal in the order they are visited.
DFSUtil function:
DFSUtil(v, visited, stack):
Mark vertex v as visited
Print v

For each neighbor u of v:


If u is not visited:
Recursively call DFSUtil(u, visited, stack)

Push v onto the stack

For Topological Sort:

Step-1: Reinitialize the 'visited' array to mark all vertices as unvisited.


Step-2: Reinitialize the stack for topological sorting.
Step-3: For each unvisited vertex in the graph, perform DFS starting from that vertex using
'DFSUtil'.
Step-4: In the 'DFSUtil' function, mark the vertex as visited and explore all its unvisited
neighbors recursively.
Step-5: After all vertices are visited, push the visited vertex onto the stack.
Step-6: Finally, pop vertices from the stack and print them, which represents the topological

Name: Akhilesh Kumar Singh UID: 21BCS7126


sort order.

Topological Sort:
TopologicalSort():
Reinitialize the 'visited' array to mark all vertices as unvisited
Reinitialize the stack for topological sorting

For each vertex v in the graph:


If v is not visited:
Call DFSUtil(v, visited, stack)

Print the elements of the stack (topological sort order)

Sample Code:

#include <bits/stdc++.h>
#include <list>
#include <stack>

class Graph {
private:
int V; // Number of vertices
std::list<int>* adj; // Adjacency list

void DFSUtil(int v, bool visited[], std::stack<int>& stack);

public:
Graph(int V);
void addEdge(int v, int w);

Name: Akhilesh Kumar Singh UID: 21BCS7126


void DFS();
void topologicalSort();
};

Graph::Graph(int V) {
this->V = V;
adj = new std::list<int>[V];
}

void Graph::addEdge(int v, int w) {


adj[v].push_back(w);
}

void Graph::DFSUtil(int v, bool visited[], std::stack<int>& stack) {


visited[v] = true;

for (auto i = adj[v].begin(); i != adj[v].end(); ++i) {


if (!visited[*i]) {
DFSUtil(*i, visited, stack);
}
}

stack.push(v);
}

void Graph::DFS() {
bool* visited = new bool[V];
for (int i = 0; i < V; i++) {
visited[i] = false;
}

Name: Akhilesh Kumar Singh UID: 21BCS7126


std::stack<int> stack;

for (int i = 0; i < V; i++) {


if (!visited[i]) {
DFSUtil(i, visited, stack);
}
}

while (!stack.empty()) {
std::cout << stack.top() << " ";
stack.pop();
}

delete[] visited;
}

void Graph::topologicalSort() {
bool* visited = new bool[V];
for (int i = 0; i < V; i++) {
visited[i] = false;
}

std::stack<int> stack;

for (int i = 0; i < V; i++) {


if (!visited[i]) {
DFSUtil(i, visited, stack);
}
}

Name: Akhilesh Kumar Singh UID: 21BCS7126


std::cout << "Topological Sort: ";
while (!stack.empty()) {
std::cout << stack.top() << " ";
stack.pop();
}

delete[] visited;
}

int main() {
Graph g(6); // Create a graph with 6 vertices

// Add edges to the graph to represent a directed acyclic graph (DAG)


g.addEdge(5, 2);
g.addEdge(5, 0);
g.addEdge(4, 0);
g.addEdge(4, 1);
g.addEdge(2, 3);
g.addEdge(3, 1);

std::cout << "DFS Traversal: ";


g.DFS();
std::cout << "\n";

g.topologicalSort();

return 0;
}

Name: Akhilesh Kumar Singh UID: 21BCS7126


Observations/Outcome:

Time and Space Complexities:


 Time Complexity:
DFS Traversal:
The time complexity of the DFS traversal is O(V + E), where V is the number of vertices
and E is the number of edges in the graph.

Topological Sort:
The time complexity of topological sort is the same as DFS, which is O(V + E).

 Space Complexity:
DFS Traversal:
The overall space complexity is O(V).

Topological Sort:
Similar to the DFS traversal, the space complexity for topological sort is O(V) due to the
recursion stack and the visited array.

Learning Outcomes:
 I learned about DFS.
 I learned about the Topological Sort and its functioning.
 I learned about the time and space complexity of DFS and Topological Sort.
 I learned about its implementation on both directed and undirected graph.

Name: Akhilesh Kumar Singh UID: 21BCS7126

You might also like

pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy