all the complexities added with $ symbol as requested

Author: MuraliDharan7

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

@@ -37,13 +37,13 @@ Consider the following graph:
 
 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).
+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`
+- `$1 <= number of vertices <= 10^3$`
+- `$0 <= value of vertices <= 10^3$`
 
 ## Problem Explanation
 
@@ -129,11 +129,11 @@ Here's the step-by-step breakdown of the BFS traversal process:
 
 ## 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.
+$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.
+$O(V)$, where V is the number of vertices. The space is used to store the visited array and the queue.
 
 ## Resources
 

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

@@ -46,13 +46,13 @@ Output: No
 
 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.
+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`
+- `$1 <= number of nodes <= 10^5$`
+- `$1 <= data of node <= 10^5$`
 
 ## Problem Explanation
 
@@ -131,11 +131,11 @@ Here's the step-by-step breakdown of the checking process:
 
 ## Time Complexity
 
-O(N), where N is the number of nodes in the tree. The function visits each node once.
+$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.
+$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
 

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

@@ -37,13 +37,13 @@ Consider the following graph:
 
 Your task is to complete the function `dfs()`, which takes the graph, the number of vertices, and the source vertex as its arguments and prints the DFS 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).
+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`
+- `$1 <= number of vertices <= 10^3$`
+- `$0 <= value of vertices <= 10^3$`
 
 ## Problem Explanation
 
@@ -111,11 +111,11 @@ Here's the step-by-step breakdown of the DFS traversal process:
 
 ## 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.
+$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.
+$O(V)$, where V is the number of vertices. The space is used to store the visited array.
 
 ## Resources
 

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

@@ -36,13 +36,13 @@ Output: 1 -> 2 -> 4
 
 Your task is to complete the function `deleteMid()`, which takes the head of the linked list as its argument and returns the head of the modified list after the middle node has been deleted.
 
-Expected Time Complexity: O(N).
-Expected Auxiliary Space: O(1).
+Expected Time Complexity: $O(N)$.
+Expected Auxiliary Space: $O(1)$.
 
 ## Constraints
 
-- `1 <= number of nodes <= 10^3`
-- `1 <= value of nodes <= 10^3`
+- `$1 <= number of nodes <= 10^3$`
+- `$1 <= value of nodes <= 10^3$`
 
 ## Problem Explanation
 
@@ -124,11 +124,11 @@ Here's the step-by-step breakdown of the deletion process:
 
 ## Time Complexity
 
-O(N), where N is the number of nodes in the list. The function traverses the list once to find the middle node.
+$O(N)$, where N is the number of nodes in the list. The function traverses the list once to find the middle node.
 
 ## Space Complexity
 
-O(1), constant space complexity. The algorithm uses only a few additional pointers for traversal and modification, which does not depend on the input size.
+$O(1)$, constant space complexity. The algorithm uses only a few additional pointers for traversal and modification, which does not depend on the input size.
 
 ## Resources
 

dsa-solutions/gfg-solutions/problems/Delete-without-head-pointer.md

@@ -40,13 +40,13 @@ Output: 10 4 30
 
 Your task is to complete the function `deleteNode()`, which takes a reference to the node to be deleted and modifies the linked list directly. You should not return anything from the function.
 
-Expected Time Complexity: O(1).
-Expected Auxiliary Space: O(1).
+Expected Time Complexity: $O(1)$.
+Expected Auxiliary Space: $O(1)$.
 
 ## Constraints
 
-- `2 <= number of nodes <= 10^3`
-- `1 <= value of nodes <= 10^3`
+- `$2 <= number of nodes <= 10^3$`
+- `$1 <= value of nodes <= 10^3$`
 
 ## Problem Explanation
 
@@ -92,11 +92,11 @@ Here's the step-by-step breakdown of the deletion process:
 
 ## Time Complexity
 
-O(1), since the node is deleted in constant time by copying the data and updating pointers.
+$O(1)$, since the node is deleted in constant time by copying the data and updating pointers.
 
 ## Space Complexity
 
-O(1), constant space complexity, as no extra space is used beyond a few pointers.
+$O(1)$, constant space complexity, as no extra space is used beyond a few pointers.
 
 ## Resources
 

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

@@ -51,13 +51,13 @@ Your task is to complete the class `TwoStacks` which should contain the followin
 - `int pop1()`: Pops the top element from the first stack and returns it. Returns `-1` if the first stack is empty.
 - `int pop2()`: Pops the top element from the second stack and returns it. Returns `-1` if the second stack is empty.
 
-Expected Time Complexity: O(1) for all the operations.
-Expected Auxiliary Space: O(1) for all the operations.
+Expected Time Complexity: $O(1)$ for all the operations.
+Expected Auxiliary Space: $O(1)$ for all the operations.
 
 ## Constraints
 
-- `1 <= N <= 100`
-- `1 <= x <= 100`
+- `$1 <= N <= 100$`
+- `$1 <= x <= 100$`
 
 ## Problem Explanation
 
@@ -188,11 +188,11 @@ Here's the step-by-step breakdown of implementing two stacks in a single array:
 
 ## Time Complexity
 
-O(1) for all the operations, as the operations of push and pop involve a fixed number of steps.
+$O(1)$ for all the operations, as the operations of push and pop involve a fixed number of steps.
 
 ## Space Complexity
 
-O(1) auxiliary space, as the additional space used does not depend on the input size and is constant.
+$O(1)$ auxiliary space, as the additional space used does not depend on the input size and is constant.
 
 ## Resources
 

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

@@ -38,13 +38,13 @@ Output: Empty List
 
 Your task is to complete the function `findIntersection()`, which takes the heads of both linked lists as arguments and returns the head of the new linked list representing their intersection.
 
-Expected Time Complexity: O(N + M), where N and M are the lengths of the two linked lists.
-Expected Auxiliary Space: O(1).
+Expected Time Complexity: $O(N + M)$, where N and M are the lengths of the two linked lists.
+Expected Auxiliary Space: $O(1)$.
 
 ## Constraints
 
-- `1 <= number of nodes <= 10^5`
-- `1 <= value of nodes <= 10^5`
+- `$1 <= number of nodes <= 10^5$`
+- `$1 <= value of nodes <= 10^5$`
 
 ## Problem Explanation
 
@@ -126,11 +126,11 @@ Here's the step-by-step breakdown of finding the intersection:
 
 ## Time Complexity
 
-O(N + M), where N and M are the lengths of the two linked lists. The function visits each node in both linked lists once.
+$O(N + M)$, where N and M are the lengths of the two linked lists. The function visits each node in both linked lists once.
 
 ## Space Complexity
 
-O(1), constant space complexity. The algorithm uses only a few additional pointers for traversal and modification, which does not depend on the input size.
+$O(1)$, constant space complexity. The algorithm uses only a few additional pointers for traversal and modification, which does not depend on the input size.
 
 ## Resources
 

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

@@ -35,13 +35,13 @@ Output: 196 59 122 75
 
 Your task is to complete the given function reverseDLL(), which takes head reference as argument and this function should reverse the elements 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. The printing and verification is done by the driver code.
 
-Expected Time Complexity: O(n).
-Expected Auxiliary Space: O(1).
+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$`
 
 ## Problem Explanation
 
@@ -116,11 +116,11 @@ def reverse_doubly_linked_list(head):
 
 ## Time Complexity
 
-O(n), where n is the number of nodes in the list. This is because the loop iterates through each node once.
+$O(n)$, where n is the number of nodes in the list. This is because the loop iterates through each node once.
 
 ## Space Complexity
 
-O(1), constant space complexity. The algorithm uses only a few additional pointers for temporary storage, which does not depend on the input size.
+$O(1)$, constant space complexity. The algorithm uses only a few additional pointers for temporary storage, which does not depend on the input size.
 
 ## Resources
 

dsa-solutions/gfg-solutions/problems/Reverse-a-linked-list.md

@@ -42,12 +42,12 @@ elements are 10->9->8->7->2.
 
 The task is to complete the function reverseList() with head reference as the only argument and should return new head after reversing the list.
 
-Expected Time Complexity: O(N).
-Expected Auxiliary Space: O(1).
+Expected Time Complexity: $O(N)$.
+Expected Auxiliary Space: $O(1)$.
 
 ## Constraints
 
-`1 <= N <= 10^4`
+- `$1 <= N <= 10^4$`
 
 ## Problem Explanation
 
@@ -128,11 +128,11 @@ By repeating these steps, you traverse the linked list, reverse the links in pla
 
 1. Reversing a linked list involves iterating through the list to manipulate the pointers between nodes. In the worst case, you need to visit every single node in the list to reverse the connections.
 
-2. Any efficient reversal algorithm will require at least one pass through the entire list. This takes O(n) time.
+2. Any efficient reversal algorithm will require at least one pass through the entire list. This takes $O(n)$ time.
 
 ## Space Complexity:
 
-The space complexity is typically denoted as O(1), which signifies constant space. This means the extra memory usage doesn't depend on the input size.
+The space complexity is typically denoted as $O(1)$, which signifies constant space. This means the extra memory usage doesn't depend on the input size.
 
 ## References
 

dsa-solutions/gfg-solutions/problems/Square-root.md

@@ -36,12 +36,12 @@ Explanation: The square root of 8 is 2.82842..., and since we want the floor val
 
 Your task is to complete the function `sqrt()`, which takes an integer x as an argument and returns the floor value of its square root.
 
-Expected Time Complexity: O(log x).
-Expected Auxiliary Space: O(1).
+Expected Time Complexity: $O(log x)$.
+Expected Auxiliary Space: $O(1)$.
 
 ## Constraints
 
-- `0 <= x <= 10^9`
+- `$0 <= x <= 10^9$`
 
 ## Problem Explanation
 
@@ -122,11 +122,11 @@ Here's the step-by-step breakdown of finding the square root:
 
 ## Time Complexity
 
-O(log x), where x is the input number. The binary search approach reduces the search space logarithmically.
+$O(log x)$, where x is the input number. The binary search approach reduces the search space logarithmically.
 
 ## Space Complexity
 
-O(1), constant space complexity. The algorithm uses a fixed amount of extra space regardless of the input size.
+$O(1)$, constant space complexity. The algorithm uses a fixed amount of extra space regardless of the input size.
 
 ## Resources