Merge pull request #536 from MuraliDharan7/add-gfgsol-problems

Added Easy problem solution GFG

Author: ajay-dhangar

dsa-problems/gfg-problems/easy/problems.md

@@ -14,61 +14,61 @@ export const problems = [
     "problemName": "1. Reverse-a-linked-list",
     "difficulty": "easy",
     "leetCodeLink": "https://www.geeksforgeeks.org/problems/reverse-a-linked-list/0",
-    "solutionLink": "#"
+    "solutionLink": "/dsa-solutions/gfg-solutions/problems/Reverse-a-linked-list"
   },
     {
         "problemName": "2. Reverse-a-doubly-linked-list",
         "difficulty": "easy",
         "leetCodeLink": "https://www.geeksforgeeks.org/problems/reverse-a-doubly-linked-list/0",
-        "solutionLink": "#"
+        "solutionLink": "/dsa-solutions/gfg-solutions/problems/Reverse-a-doubly-linked-list"
     },
     {
         "problemName": "3. Delete-without-head-pointer",
         "difficulty": "easy",
         "leetCodeLink": "https://www.geeksforgeeks.org/problems/delete-without-head-pointer/0",
-        "solutionLink": "#"
+        "solutionLink": "/dsa-solutions/gfg-solutions/problems/Delete-without-head-pointer"
     },
     {
         "problemName": "4. Check-for-balanced-tree",
         "difficulty": "easy",
         "leetCodeLink": "https://www.geeksforgeeks.org/problems/check-for-balanced-tree/0",
-        "solutionLink": "#"
+        "solutionLink": "/dsa-solutions/gfg-solutions/problems/Check-for-balanced-tree"
     },
     {
         "problemName": "5. Delete-middle-of-linked-list",
         "difficulty": "easy",
         "leetCodeLink": "https://www.geeksforgeeks.org/problems/delete-middle-of-linked-list/0",
-        "solutionLink": "#"
+        "solutionLink": "/dsa-solutions/gfg-solutions/problems/Delete-middle-of-linked-list"
     },
     {
         "problemName": "6. Intersection-of-two-sorted-linked-lists",
         "difficulty": "easy",
         "leetCodeLink": "https://www.geeksforgeeks.org/problems/intersection-of-two-sorted-linked-lists/0",
-        "solutionLink": "#"
+        "solutionLink": "/dsa-solutions/gfg-solutions/problems/Intersection-of-two-sorted-linked-lists"
     },
     {
         "problemName": "7. DFS-traversal-of-graph",
         "difficulty": "easy",
         "leetCodeLink": "https://www.geeksforgeeks.org/problems/depth-first-traversal-for-a-graph/0",
-        "solutionLink": "#"
+        "solutionLink": "/dsa-solutions/gfg-solutions/problems/DFS-traversal-of-graph"
     },
     {
         "problemName": "8. BFS-traversal-of-graph",
         "difficulty": "easy",
         "leetCodeLink": "https://www.geeksforgeeks.org/problems/bfs-traversal-of-graph/0",
-        "solutionLink": "#"
+        "solutionLink": "/dsa-solutions/gfg-solutions/problems/BFS-traversal-of-graph"
     },
     {
         "problemName": "9. Square-root",
         "difficulty": "easy",
         "leetCodeLink": "https://www.geeksforgeeks.org/problems/square-root/0",
-        "solutionLink": "#"
+        "solutionLink": "/dsa-solutions/gfg-solutions/problems/Square-root"
     },
     {
         "problemName": "10. Implement-two-stacks-in-an-array",
         "difficulty": "easy",
         "leetCodeLink": "https://www.geeksforgeeks.org/problems/implement-two-stacks-in-an-array/0",
-        "solutionLink": "#"
+        "solutionLink": "/dsa-solutions/gfg-solutions/problems/Implement-two-stacks-in-an-array"
     }
 ]
 

dsa-solutions/gfg-solutions/problems/BFS-traversal-of-graph.md

@@ -0,0 +1,144 @@
+---
+id: BFS-traversal-of-graph
+title: BFS Traversal of Graph (Geeks for Geeks)
+sidebar_label: BFS Traversal of Graph
+tags:
+  - Intermediate
+  - Graph
+  - Breadth-First Search
+  - Geeks for Geeks
+  - CPP
+  - Python
+  - DSA
+description: "This is a solution to the BFS Traversal of Graph problem on Geeks for Geeks."
+---
+
+## Problem Description
+
+Given a graph, perform Breadth-First Search (BFS) traversal starting from a given source vertex.
+
+## Examples
+
+**Example:**
+
+Consider the following graph:
+
+```
+      1
+     / \
+    2   3
+   / \
+  4   5
+```
+
+**Output:** 1 2 3 4 5
+
+## Your Task
+
+Your task is to complete the function `bfs()`, which takes the graph, the number of vertices, and the source vertex as its arguments and prints the BFS traversal of the graph starting from the source vertex.
+
+Expected Time Complexity: $O(V + E)$, where V is the number of vertices and E is the number of edges in the graph.
+Expected Auxiliary Space: $O(V)$.
+
+## Constraints
+
+- $1 <= number of vertices <= 10^3$
+- $0 <= value of vertices <= 10^3$
+
+## Problem Explanation
+
+Here's the step-by-step breakdown of the BFS traversal process:
+
+1. **Initialize visited array**: Create a visited array to keep track of visited vertices.
+2. **Initialize queue**: Create a queue to store vertices to be visited next.
+3. **Perform BFS**: Start BFS traversal from the source vertex.
+4. **Enqueue source**: Enqueue the source vertex into the queue and mark it as visited.
+5. **Process vertices**: While the queue is not empty, dequeue a vertex, print it, and enqueue its unvisited adjacent vertices.
+
+### Code Implementation
+
+<Tabs>
+  <TabItem value="Python" label="Python" default>
+  <SolutionAuthor name="@ngmuraqrdd"/>
+  ```python
+  from collections import deque
+
+  def bfs(graph, v, source):
+      visited = [False] * v
+      queue = deque([source])
+      visited[source] = True
+
+      while queue:
+          u = queue.popleft()
+          print(u, end=" ")
+
+          for neighbor in graph[u]:
+              if not visited[neighbor]:
+                  visited[neighbor] = True
+                  queue.append(neighbor)
+  
+  def bfsTraversal(graph, V, source):
+      bfs(graph, V, source)
+  ```
+  </TabItem>
+
+  <TabItem value="C++" label="C++" default>
+  <SolutionAuthor name="@ngmuraqrdd"/>
+  ```cpp
+  #include <iostream>
+  #include <vector>
+  #include <queue>
+  #include <cstring>
+  using namespace std;
+
+  void bfs(vector<int> graph[], int v, int source) {
+      bool visited[v];
+      memset(visited, false, sizeof(visited));
+      queue<int> q;
+
+      q.push(source);
+      visited[source] = true;
+
+      while (!q.empty()) {
+          int u = q.front();
+          q.pop();
+          cout << u << " ";
+
+          for (int neighbor : graph[u]) {
+              if (!visited[neighbor]) {
+                  visited[neighbor] = true;
+                  q.push(neighbor);
+              }
+          }
+      }
+  }
+
+  void bfsTraversal(vector<int> graph[], int V, int source) {
+      bfs(graph, V, source);
+  }
+  ```
+  </TabItem>
+</Tabs>
+
+## Solution Logic
+
+1. **Initialize visited array and queue**: Create an array to mark visited vertices initially as False and a queue to store vertices to be visited.
+2. **Perform BFS**: Start BFS traversal from the source vertex.
+3. **Enqueue source**: Enqueue the source vertex into the queue and mark it as visited.
+4. **Process vertices**: While the queue is not empty, dequeue a vertex, print it, and enqueue its unvisited adjacent vertices.
+
+## Time Complexity
+
+$O(V + E)$, where V is the number of vertices and E is the number of edges in the graph. Each vertex and edge are visited only once.
+
+## Space Complexity
+
+$O(V)$, where V is the number of vertices. The space is used to store the visited array and the queue.
+
+## Resources
+
+- **GFG Problem:** [GFG Problem](https://www.geeksforgeeks.org/breadth-first-search-or-bfs-for-a-graph/)
+- **LeetCode Problem:** [LeetCode Problem](https://leetcode.com/problems/number-of-connected-components-in-an-undirected-graph/)
+- **Author's Geeks for Geeks Profile:** [MuraliDharan](https://www.geeksforgeeks.org/user/ngmuraqrdd/)
+
+This format ensures that all necessary details about the problem and its solution are clearly presented and easy to follow.

dsa-solutions/gfg-solutions/problems/Check-for-balanced-tree.md

@@ -0,0 +1,146 @@
+---
+id: Check-for-balanced-tree
+title: Check for Balanced Tree (Geeks for Geeks)
+sidebar_label: Check for Balanced Tree 
+tags:
+  - Intermediate
+  - Tree
+  - Geeks for Geeks
+  - CPP
+  - Python
+  - DSA
+description: "This is a solution to the Check for Balanced Tree problem on Geeks for Geeks."
+---
+
+## Problem Description
+
+Given a binary tree, determine if it is height-balanced. A binary tree is height-balanced if the left and right subtrees of every node differ in height by no more than 1.
+
+## Examples
+
+**Example 1:**
+```
+Input:
+      1
+     / \
+    2   3
+   / \
+  4   5
+Output: Yes
+```
+
+**Example 2:**
+```
+Input:
+        10
+       /  \
+      20   30
+     / \
+    40  60
+         \
+         70
+Output: No
+```
+
+## Your Task
+
+Your task is to complete the function `isBalanced()`, which takes the root of the binary tree as its argument and returns a boolean value indicating whether the tree is balanced or not.
+
+Expected Time Complexity: $O(N)$.
+Expected Auxiliary Space: $O(h)$, where h is the height of the tree.
+
+## Constraints
+
+- $1 <= number of nodes <= 10^5$
+- $1 <= data of node <= 10^5$
+
+## Problem Explanation
+
+Here's the step-by-step breakdown of the checking process:
+
+1. **Recursive depth calculation**: Create a helper function to calculate the depth of each subtree.
+2. **Height difference check**: Check the difference in height between the left and right subtrees.
+3. **Recursive balance check**: Recursively check if each subtree is balanced.
+4. **Return result**: Return True if the tree is balanced, otherwise False.
+
+### Code Implementation
+
+<Tabs>
+  <TabItem value="Python" label="Python" default>
+  <SolutionAuthor name="@ngmuraqrdd"/>
+  ```py
+  class TreeNode:
+      def __init__(self, val=0, left=None, right=None):
+          self.val = val
+          self.left = left
+          self.right = right
+
+  def isBalanced(root):
+      def check(root):
+          if not root:
+              return 0, True
+          left_height, left_balanced = check(root.left)
+          right_height, right_balanced = check(root.right)
+          balanced = left_balanced and right_balanced and abs(left_height - right_height) <= 1
+          return max(left_height, right_height) + 1, balanced
+      
+      return check(root)[1]
+  ```
+  </TabItem>
+
+  <TabItem value="C++" label="C++" default>
+  <SolutionAuthor name="@ngmuraqrdd"/>
+  ```cpp
+  struct TreeNode {
+      int val;
+      TreeNode *left;
+      TreeNode *right;
+      TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+  };
+
+  class Solution {
+  public:
+      bool isBalanced(TreeNode* root) {
+          return checkHeight(root) != -1;
+      }
+      
+      int checkHeight(TreeNode* root) {
+          if (root == NULL) return 0;
+          
+          int leftHeight = checkHeight(root->left);
+          if (leftHeight == -1) return -1;
+          
+          int rightHeight = checkHeight(root->right);
+          if (rightHeight == -1) return -1;
+          
+          if (abs(leftHeight - rightHeight) > 1) return -1;
+          
+          return max(leftHeight, rightHeight) + 1;
+      }
+  };
+  ```
+  </TabItem>
+</Tabs>
+
+## Solution Logic
+
+1. **Recursive depth calculation**: A helper function calculates the height of the subtree rooted at each node.
+2. **Height difference check**: For each node, the function checks if the height difference between the left and right subtrees is more than 1.
+3. **Recursive balance check**: The function is recursively called on each subtree to ensure both are balanced.
+4. **Return result**: The function returns True if all nodes are balanced, otherwise False.
+
+## Time Complexity
+
+$O(N)$, where N is the number of nodes in the tree. The function visits each node once.
+
+## Space Complexity
+
+$O(h)$, where h is the height of the tree. This is due to the recursive stack space used during the depth-first traversal.
+
+## Resources
+
+- **GFG Problem:** [GFG Problem](https://www.geeksforgeeks.org/how-to-determine-if-a-binary-tree-is-balanced/)
+- **LeetCode Problem:** [LeetCode Problem](https://leetcode.com/problems/balanced-binary-tree/)
+- **Author's Geeks for Geeks Profile:** [MuraliDharan](https://www.geeksforgeeks.org/user/ngmuraqrdd/)
+
+This format ensures that all necessary details about the problem and its solution are clearly presented and easy to follow.