updated as per your suggestion

Author: Vipullakum007

dsa-solutions/gfg-solutions/Easy problems/bfs-of-graph.md

@@ -44,11 +44,11 @@ Starting from 0, it will go to 1 then 2, thus BFS will be 0 1 2.
 
 You don't need to read input or print anything. Your task is to complete the function `bfsOfGraph()` which takes the integer `V` denoting the number of vertices and adjacency list as input parameters and returns a list containing the BFS traversal of the graph starting from the 0th vertex from left to right.
 
-**Expected Time Complexity:** $ O(V + E) $ 
+**Expected Time Complexity:** $O(V + E)$ 
 **Expected Auxiliary Space:** $O(V)$
 
 **Constraints**
-- $ 1 ≤ V, E ≤ 10^4 $
+- $1 ≤ V, E ≤ 10^4$
 
 ## Solution
 
@@ -211,10 +211,10 @@ class Solution {
 
 ## Complexity analysis
 
-The provided solutions efficiently perform a Breadth First Search (BFS) traversal of a directed graph. By starting from the 0th vertex and using a queue to manage the traversal, the algorithms ensure that all reachable vertices are visited in the correct order. The solutions operate in O(V + E) time and use O(V) space complexity, where V and E are the numbers of vertices and edges in the graph, respectively.
+The provided solutions efficiently perform a Breadth First Search (BFS) traversal of a directed graph. By starting from the 0th vertex and using a queue to manage the traversal, the algorithms ensure that all reachable vertices are visited in the correct order. The solutions operate in $O(V + E)$ time and use $O(V)$ space complexity, where V and E are the numbers of vertices and edges in the graph, respectively.
 
-**Time Complexity:** $ O(V + E)  $
-**Auxiliary Space:** $ O(V)$
+**Time Complexity:** $O(V + E)$
+**Auxiliary Space:** $O(V)$
 
 ## References
 

dsa-solutions/gfg-solutions/Easy problems/check-for-balanced-tree.md

@@ -50,7 +50,7 @@ Output: true
 ### Constraints
 
 - The number of nodes in the tree is in the range `[0, 5000]`.
-- $ -10^4 <=$ Node.val $<= 10^4 $
+- $-10^4 <=$ Node.val $<= 10^4$
 
 ---
 

dsa-solutions/gfg-solutions/Easy problems/delete-middle-of-linked-list.md

@@ -41,12 +41,12 @@ Output:
 ### Your Task
 The task is to complete the function `deleteMid()` which takes head of the linked list and returns head of the linked list with the middle element deleted. If the linked list is empty or contains a single element, then it should return NULL.
 
-**Expected Time Complexity:** O(n).  
-**Expected Auxiliary Space:** O(1).
+**Expected Time Complexity:** $O(n)$  
+**Expected Auxiliary Space:** $O(1)$
 
 ### Constraints
-1 ≤ n ≤ 10^5  
-1 ≤ value[i] ≤ 10^9
+- $1 ≤ n ≤ 10^5$  
+- $1 ≤ value[i] ≤ 10^9$
 
 ## Solution
 
@@ -59,8 +59,7 @@ To delete the middle node, ensure that the `slow` pointer is at the node just be
 **Edge Case:** If there is only one node in the linked list, return NULL or None.
 
 ### Complexity
-- **Time Complexity:** O(n)
-- **Space Complexity:** O(1)
+- **Time Complexity:** $O(n)$- **Space Complexity:** O(1)
 
 ### Implementation
 
@@ -164,8 +163,8 @@ function deleteMid(head: ListNode | null): ListNode | null {
 </Tabs>
 
 ### Complexity
-- **Time Complexity:** O(n)
-- **Space Complexity:** O(1)
+- **Time Complexity:** $O(n)$
+- **Space Complexity:** $O(1)$
 
 ---
 

dsa-solutions/gfg-solutions/Easy problems/delete-without-head-pointer.md

@@ -58,12 +58,12 @@ we have remaining nodes as 10, 4, 30.
 ### Your Task
 You don't need to read or print anything. You only need to complete the function `deleteNode()` which takes a reference of the deleting node value and your task is to delete the given node value.
 
-**Expected Time Complexity:** O(1)  
-**Expected Auxiliary Space:** O(1)
+**Expected Time Complexity:** $O(1)$  
+**Expected Auxiliary Space:** $O(1)$
 
 ### Constraints
-2 ≤ n ≤ 10^3  
-1 ≤ elements of the linked list ≤ 10^9
+- $2 ≤ n ≤ 10^3$  
+- $1 ≤ elements of the linked list ≤ 10^9$
 
 ## Solution
 
@@ -213,8 +213,8 @@ class Solution {
 
 ### Complexity Analysis
 
-- **Time Complexity:** O(1), as the deletion operation requires constant time regardless of the size of the linked list.
-- **Space Complexity:** O(1), as the algorithm uses only a constant amount of extra space regardless of the input size.
+- **Time Complexity:** $O(1)$, as the deletion operation requires constant time regardless of the size of the linked list.
+- **Space Complexity:** $O(1)$, as the algorithm uses only a constant amount of extra space regardless of the input size.
 
 ---
 

dsa-solutions/gfg-solutions/Easy problems/dfs-of-graph.md

@@ -52,8 +52,8 @@ Thus DFS will be 0 1 2 3.
 
 You don't need to read input or print anything. Your task is to complete the function `dfsOfGraph()` which takes the integer `V` denoting the number of vertices and adjacency list as input parameters and returns a list containing the DFS traversal of the graph starting from the 0th vertex from left to right according to the graph.
 
-- **Expected Time Complexity:** $ O(V + E)  $
-- **Expected Auxiliary Space:** $ O(V)$
+- **Expected Time Complexity:** $O(V + E)$
+- **Expected Auxiliary Space:** $O(V)$
 
 **Constraints**
 - $ 1 ≤ V, E ≤ 10^4 $

dsa-solutions/gfg-solutions/Easy problems/implement-two-stacks-in-an-array.md

@@ -337,7 +337,7 @@ class TwoStacks {
 
 ## Complexity Analysis
 
-The provided solutions efficiently implement two stacks in a single array using pointers. This approach ensures a time complexity of O(1) for all stack operations and an auxiliary space complexity of O(1). The algorithms are designed to handle up to 10^4 queries efficiently without relying on dynamic data structures.
+The provided solutions efficiently implement two stacks in a single array using pointers. This approach ensures a time complexity of $O(1)$ for all stack operations and an auxiliary space complexity of $O(1)$. The algorithms are designed to handle up to $10^4$ queries efficiently without relying on dynamic data structures.
 
 **Time Complexity:** $O(1)$ for all the four methods.  
 **Auxiliary Space:** $O(1)$ for all the four methods.

dsa-solutions/gfg-solutions/Easy problems/intersection-of-two-sorted-linked-lists.md

@@ -45,14 +45,14 @@ Output:
 
 You don't have to take any input or print anything. Your task is to complete the function `findIntersection()`, which will take the head of both of the linked lists as input and should find the intersection of the two linked lists and add all the elements in the intersection to the third linked list and return the head of the third linked list.
 
-**Expected Time Complexity:** O(n + m)  
-**Expected Auxiliary Space:** O(n + m)
+**Expected Time Complexity:** $O(n + m)$  
+**Expected Auxiliary Space:** $O(n + m)$
 
 **Note:** n, m are the sizes of the respective linked lists.
 
 ### Constraints
-1 ≤ size of linked lists ≤ 5000  
-1 ≤ Data in linked list nodes ≤ 10^4
+- $1 ≤ size of linked lists ≤ 5000$  
+- $1 ≤ Data in linked list nodes ≤ 10^4$
 
 ## Solution
 
@@ -231,8 +231,8 @@ class Solution {
   </TabItem>
 </Tabs>
 
-**Time Complexity:** O(n + m)  
-**Auxiliary Space:** O(n + m)
+**Time Complexity:** $O(n + m)$  
+**Auxiliary Space:** $O(n + m)$
 
 ## References
 

dsa-solutions/gfg-solutions/Easy problems/reverse-a-doubly-linked-list.md

@@ -45,12 +45,12 @@ After reversing the list, elements are 196 <--> 59 <--> 122 <--> 75.
 ### Your Task
 Your task is to complete the given function `reverseDLL()`, which takes head reference as an argument and reverses the elements in-place such that the tail becomes the new head and all pointers are pointing in the right order. You need to return the new head of the reversed list.
 
-**Expected Time Complexity:** $ O(N)$  
+**Expected Time Complexity:** $O(N)$  
 **Expected Auxiliary Space:** $O(1)$
 
 ### Constraints
-- $ 1 ≤ number of nodes ≤ 10^4 $
-- $ 0 ≤ value of nodes ≤ 10^4 $
+- $1 ≤ number of nodes ≤ 10^4$
+- $0 ≤ value of nodes ≤ 10^4$
 
 ## Solution
 
@@ -155,7 +155,7 @@ class Solution {
 
 ### Complexity Analysis
 
-- **Time Complexity:** $ O(N),$ where N is the number of elements in the doubly linked list. We traverse the entire list once.
+- **Time Complexity:** $O(N),$ where N is the number of elements in the doubly linked list. We traverse the entire list once.
 - **Space Complexity:** $O(1)$, as we only use a constant amount of extra space for pointers.
 
 ---

dsa-solutions/gfg-solutions/Easy problems/reverse-a-linked-list.md

@@ -178,8 +178,8 @@ function reverseList(head: ListNode | null): ListNode | null {
 
 ### Complexity Analysis
 
-- **Time Complexity:** $ O(N) $, where N is the number of nodes in the linked list. We traverse the entire list once.
-- **Space Complexity:** $ O(1) $, as we only use a constant amount of extra space for pointers.
+- **Time Complexity:** $O(N)$, where N is the number of nodes in the linked list. We traverse the entire list once.
+- **Space Complexity:** $O(1)$, as we only use a constant amount of extra space for pointers.
 
 ---
 

dsa-solutions/gfg-solutions/Easy problems/square-root.md

@@ -39,11 +39,11 @@ Explanation: Since 4 is a perfect square, its square root is 2.
 
 You don't need to read input or print anything. The task is to complete the function `floorSqrt()` which takes `x` as the input parameter and returns its square root. Note: Try solving the question without using the sqrt function. The value of `x` ≥ 0.
 
-**Expected Time Complexity:** $ O(log N)  $
-**Expected Auxiliary Space:** $ O(1) $
+**Expected Time Complexity:** $O(log N)$
+**Expected Auxiliary Space:** $O(1)$
 
 **Constraints**
-- $ 1 ≤ x ≤ 10^7 $
+- $1 ≤ x ≤ 10^7$
 
 ## Solution
 
@@ -187,10 +187,10 @@ class Solution {
 
 ## Complexity Analysis
 
-The provided solutions efficiently find the floor value of the square root of a given integer `x` using binary search. This approach ensures a time complexity of $ O(log N) and an auxiliary space complexity of $ O(1) $. The algorithms are designed to handle large values of `x` up to 10^7 efficiently without relying on built-in square root functions.
+The provided solutions efficiently find the floor value of the square root of a given integer `x` using binary search. This approach ensures a time complexity of $ O(log N) and an auxiliary space complexity of $O(1)$. The algorithms are designed to handle large values of `x` up to 10^7 efficiently without relying on built-in square root functions.
 
-**Time Complexity:** $ O(log N)  $
-**Auxiliary Space:** $ O(1) $
+**Time Complexity:** $O(log N)$
+**Auxiliary Space:** $O(1)$
 
 ---