Update README.md

JawadSher · web-flow · commit 720072f88fe8 · 2024-11-25T19:33:52.000+05:00
diff --git a/23 - Graph Data Structure Problems/02 - BFS Traversal in Graph/README.md b/23 - Graph Data Structure Problems/02 - BFS Traversal in Graph/README.md
@@ -83,7 +83,7 @@ public:
         }
     }
 
-    // Function to perform BFS traversal
+    // Iterative BFS traversal
     void bfs(int startNode) {
         vector<bool> visited(adjacencyList.size(), false); // Visited array
         queue<int> q; // Queue for BFS
@@ -92,7 +92,7 @@ public:
         visited[startNode] = true;
         q.push(startNode);
 
-        cout << "BFS Traversal: ";
+        cout << "BFS Traversal (Iterative): ";
 
         while (!q.empty()) {
             int currentNode = q.front();
@@ -111,6 +111,46 @@ public:
         }
         cout << endl;
     }
+
+    // Recursive BFS traversal
+    void bfsRecursiveHelper(int startNode, vector<bool>& visited, queue<int>& q) {
+        if (q.empty()) {
+            return;  // Base case: queue is empty, stop recursion
+        }
+
+        int currentNode = q.front();
+        q.pop();
+
+        // Process the current node (e.g., print it)
+        cout << currentNode << " ";
+
+        // Visit all unvisited neighbors
+        for (int neighbor : adjacencyList[currentNode]) {
+            if (!visited[neighbor]) {
+                visited[neighbor] = true;
+                q.push(neighbor);
+            }
+        }
+
+        // Recursive call with the updated queue
+        bfsRecursiveHelper(startNode, visited, q);
+    }
+
+    void bfsRecursive(int startNode) {
+        vector<bool> visited(adjacencyList.size(), false); // Visited array
+        queue<int> q; // Queue for BFS
+
+        // Start BFS from the startNode
+        visited[startNode] = true;
+        q.push(startNode);
+
+        cout << "BFS Traversal (Recursive): ";
+
+        // Start recursive BFS traversal
+        bfsRecursiveHelper(startNode, visited, q);
+
+        cout << endl;
+    }
 };
 
 int main() {
@@ -126,222 +166,162 @@ int main() {
     g.addEdge(1, 4);
     g.addEdge(2, 5);
 
-    // Perform BFS traversal starting from node 0
+    // Perform BFS traversal starting from node 0 (Iterative)
     g.bfs(0);
 
+    // Perform BFS traversal starting from node 0 (Recursive)
+    g.bfsRecursive(0);
+
     return 0;
 }
+
 ```
 
 ### Source Code Explanation
-Here’s a **line-by-line explanation** of the BFS traversal code with examples and the corresponding output:
-
-### **Code Explanation**
-
-```cpp
-#include <iostream>
-#include <vector>
-#include <queue>
-using namespace std;
-```
 
-- **Purpose**: These are essential header files.
-  - `#include <iostream>`: For input/output operations.
-  - `#include <vector>`: For using the adjacency list as a vector of vectors.
-  - `#include <queue>`: BFS requires a queue to manage nodes to visit.
+#### 1. **Graph Class:**
 
+The `Graph` class manages the graph structure using an **adjacency list** to store the neighbors of each node.
 
+##### **Constructor:**
 ```cpp
-class Graph {
-public:
-    vector<vector<int>> adjacencyList;
+Graph(int totalNodes) {
+    adjacencyList.resize(totalNodes);
+}
 ```
+- The constructor initializes the graph by resizing the adjacency list to hold the `totalNodes`. Each node initially has an empty list of neighbors.
 
-- **Explanation**: 
-  - A class named `Graph` is defined.
-  - `adjacencyList`: A vector of vectors to represent the graph. Each index `i` holds a list of nodes connected to node `i`.
-
-
-
+##### **addEdge Function:**
 ```cpp
-    Graph(int totalNodes) {
-        adjacencyList.resize(totalNodes);
+void addEdge(int sourceNode, int destinationNode, bool isDirected = false) {
+    adjacencyList[sourceNode].push_back(destinationNode);
+    if (!isDirected) {
+        adjacencyList[destinationNode].push_back(sourceNode);
     }
+}
 ```
+- `addEdge` adds an edge from `sourceNode` to `destinationNode`. If the graph is undirected (default behavior), it adds the reverse edge from `destinationNode` to `sourceNode`.
 
-- **Explanation**: 
-  - Constructor initializes the graph with `totalNodes` nodes.
-  - Resizes the `adjacencyList` to ensure every node has an associated list.
-
-
+#### 2. **BFS (Iterative) Implementation:**
 
+##### **BFS Function:**
 ```cpp
-    void addEdge(int sourceNode, int destinationNode, bool isDirected = false) {
-        adjacencyList[sourceNode].push_back(destinationNode);
-        if (!isDirected) {
-            adjacencyList[destinationNode].push_back(sourceNode);
+void bfs(int startNode) {
+    vector<bool> visited(adjacencyList.size(), false);
+    queue<int> q;
+    visited[startNode] = true;
+    q.push(startNode);
+
+    cout << "BFS Traversal (Iterative): ";
+
+    while (!q.empty()) {
+        int currentNode = q.front();
+        q.pop();
+        cout << currentNode << " ";
+
+        for (int neighbor : adjacencyList[currentNode]) {
+            if (!visited[neighbor]) {
+                visited[neighbor] = true;
+                q.push(neighbor);
+            }
         }
     }
+    cout << endl;
+}
 ```
 
-- **Purpose**: Adds edges between nodes.
-- **Parameters**:
-  - `sourceNode`: Start of the edge.
-  - `destinationNode`: End of the edge.
-  - `isDirected`: If `true`, the edge is one-way; otherwise, it is bidirectional.
-- **How it works**:
-  - Adds `destinationNode` to `sourceNode`'s adjacency list.
-  - If the graph is undirected, it also adds `sourceNode` to `destinationNode`'s adjacency list.
-
-
-
-```cpp
-    void bfs(int startNode) {
-        vector<bool> visited(adjacencyList.size(), false);
-        queue<int> q;
-```
-
-- **Explanation**:
-  - Initializes a `visited` array to track visited nodes.
-  - A queue `q` is used to manage BFS traversal.
-
-
-
-```cpp
-        visited[startNode] = true;
-        q.push(startNode);
-```
-
-- **Explanation**:
-  - Marks the `startNode` as visited.
-  - Pushes the `startNode` into the queue to begin traversal.
-
-
-
-```cpp
-        cout << "BFS Traversal: ";
-```
-
-- **Explanation**: Outputs a label for the BFS traversal results.
+- **Explanation:**
+  - The function takes `startNode` as input and performs a **Breadth-First Search** (BFS) starting from that node.
+  - `visited` array ensures that no node is visited more than once.
+  - A `queue` is used to manage the nodes to visit next. We push the `startNode` into the queue and mark it as visited.
+  - The BFS traversal proceeds by dequeuing nodes from the front of the queue and processing them. Then, all their unvisited neighbors are pushed into the queue.
 
+#### 3. **BFS (Recursive) Implementation:**
 
+##### **Recursive Helper Function:**
 ```cpp
-        while (!q.empty()) {
-            int currentNode = q.front();
-            q.pop();
-```
-
-- **Explanation**:
-  - The loop continues until the queue is empty.
-  - Retrieves the front node of the queue (`currentNode`) and removes it.
+void bfsRecursiveHelper(int startNode, vector<bool>& visited, queue<int>& q) {
+    if (q.empty()) {
+        return;  // Base case: queue is empty, stop recursion
+    }
 
+    int currentNode = q.front();
+    q.pop();
+    cout << currentNode << " ";
 
+    for (int neighbor : adjacencyList[currentNode]) {
+        if (!visited[neighbor]) {
+            visited[neighbor] = true;
+            q.push(neighbor);
+        }
+    }
 
-```cpp
-            cout << currentNode << " ";
+    bfsRecursiveHelper(startNode, visited, q);  // Recursive call
+}
 ```
+- **Explanation:**
+  - This helper function is designed to perform the recursive part of BFS.
+  - It processes nodes in a similar way to the iterative BFS but using recursion to handle the queue management.
+  - If the queue is empty, the recursion terminates. Otherwise, it pops a node from the queue, processes it, and pushes all its unvisited neighbors into the queue, making a recursive call after each step.
 
-- **Explanation**: Prints the `currentNode` to show its processing in BFS.
-
-
+##### **Main Recursive BFS Function:**
 ```cpp
-            for (int neighbor : adjacencyList[currentNode]) {
-                if (!visited[neighbor]) {
-                    visited[neighbor] = true;
-                    q.push(neighbor);
-                }
-            }
-        }
-        cout << endl;
-    }
+void bfsRecursive(int startNode) {
+    vector<bool> visited(adjacencyList.size(), false);
+    queue<int> q;
+    visited[startNode] = true;
+    q.push(startNode);
+
+    cout << "BFS Traversal (Recursive): ";
+    bfsRecursiveHelper(startNode, visited, q);
+    cout << endl;
+}
 ```
+- This function initializes the `visited` array and the queue, starting from `startNode`, and calls the recursive helper to perform the BFS traversal.
 
-- **Explanation**:
-  - Iterates through all neighbors of the `currentNode`.
-  - If a neighbor has not been visited:
-    - Marks it as visited.
-    - Adds it to the queue for future processing.
-
-
-
+#### 4. **Main Function:**
 ```cpp
 int main() {
     int totalNodes = 6;
-
-    // Create the graph
     Graph g(totalNodes);
-```
-
-- **Explanation**:
-  - Declares `totalNodes` as `6`.
-  - Creates a graph object `g` with `6` nodes.
-
 
-```cpp
     g.addEdge(0, 1);
     g.addEdge(0, 2);
     g.addEdge(1, 3);
     g.addEdge(1, 4);
     g.addEdge(2, 5);
-```
-
-- **Explanation**:
-  - Adds edges to the graph:
-    - Node `0` is connected to nodes `1` and `2`.
-    - Node `1` is connected to nodes `3` and `4`.
-    - Node `2` is connected to node `5`.
-
 
-```cpp
-    g.bfs(0);
+    g.bfs(0);         // Iterative BFS starting from node 0
+    g.bfsRecursive(0); // Recursive BFS starting from node 0
 
     return 0;
 }
 ```
+- Creates a graph with 6 nodes.
+- Adds edges to the graph.
+- Calls both the **Iterative BFS** (`g.bfs(0)`) and **Recursive BFS** (`g.bfsRecursive(0)`) functions to perform BFS starting from node `0`.
 
-- **Explanation**:
-  - Calls `bfs(0)` to perform BFS starting from node `0`.
-  - Returns `0` to indicate successful program execution.
-
-
-### **Graph Representation**
-
-The graph looks like this:
+### **Output:**
 
 ```
-    0
-   / \
-  1   2
- / \   \
-3   4   5
+BFS Traversal (Iterative): 0 1 2 3 4 5 
+BFS Traversal (Recursive): 0 1 2 3 4 5
 ```
 
+### **Time and Space Complexity:**
 
-### **Output**
-
-```
-BFS Traversal: 0 1 2 3 4 5
-```
-
-- **Explanation**:
-  - BFS starts at node `0`.
-  - Visits nodes `1` and `2` (neighbors of `0`).
-  - Then visits nodes `3` and `4` (neighbors of `1`) and finally node `5` (neighbor of `2`).
-
-### **Time Complexity**
-
-1. **Adjacency List Traversal**:
-   - Each edge is visited once: **O(E)**.
-   - Each node is visited once: **O(V)**.
-
-   Total Time Complexity: **O(V + E)**.
-
-
-### **Space Complexity**
+#### **Time Complexity:**
+- Both **Iterative BFS** and **Recursive BFS** have the same time complexity:
+  - **O(V + E)**, where:
+    - `V` is the number of vertices (nodes) in the graph.
+    - `E` is the number of edges in the graph.
+  - We visit each vertex and edge exactly once.
 
-1. **Visited Array**: Stores the state of each node: **O(V)**.
-2. **Queue**: Can hold up to **O(V)** nodes.
-3. **Adjacency List**: Takes **O(V + E)**.
+#### **Space Complexity:**
+- **O(V)**:
+  - The space is mainly used for the `visited` array (of size `V`), the queue (`O(V)`), and the recursion stack in the recursive approach (`O(V)` in the worst case).
 
-   Total Space Complexity: **O(V + E)**.
+### **Conclusion:**
+- **Iterative BFS** is more common and efficient in terms of stack space, as it avoids recursion depth limitations.
+- **Recursive BFS** is an interesting implementation that can be used for educational purposes, but it may suffer from stack overflow issues for large graphs.
 
