diff --git a/blog/Choosing-the right-datastructure-for your-problem.md b/blog/Choosing-the right-datastructure-for your-problem.md
new file mode 100644
index 000000000..392e9c7bd
--- /dev/null
+++ b/blog/Choosing-the right-datastructure-for your-problem.md	
@@ -0,0 +1,126 @@
+---
+
+slug: choosing-the-right-data-structure-for-your-problem  
+title: "Choosing the Right Data Structure for Your Problem"  
+authors: [ajay-dhangar]  
+tags: [ajay-dhangar, algorithms, dsa, data-structures, problem-solving, coding, programming, computer-science, learning]  
+---
+
+When tackling coding challenges, selecting the appropriate data structure can dramatically affect the performance and efficiency of your solution. Different data structures excel in different scenarios, and understanding their characteristics is crucial for effective problem-solving.
+
+In this blog, we’ll cover:
+
+- **Why Choosing the Right Data Structure is Important**
+- **Common Data Structures**
+- **Choosing the Right Structure for Different Problems**
+- **Examples of Data Structures in Action**
+
+## Why Choosing the Right Data Structure is Important
+
+Data structures determine how data is organized, accessed, and manipulated. The wrong choice can lead to inefficient algorithms that slow down performance and complicate code. By selecting the appropriate data structure, you can:
+
+- Improve time complexity.
+- Optimize memory usage.
+- Enhance code readability and maintainability.
+
+## Common Data Structures
+
+### 1. **Arrays**
+- **Description**: A collection of elements identified by index or key.
+- **Time Complexity**: O(1) for access, O(n) for search, O(n) for insertion or deletion.
+- **Use Case**: Storing a fixed number of items (e.g., a list of scores).
+
+### 2. **Linked Lists**
+- **Description**: A sequence of nodes, where each node points to the next.
+- **Time Complexity**: O(1) for insertion/deletion (at the head), O(n) for access/search.
+- **Use Case**: Dynamic size collections (e.g., implementing a queue).
+
+### 3. **Stacks**
+- **Description**: A collection of elements with Last In First Out (LIFO) access.
+- **Time Complexity**: O(1) for push and pop operations.
+- **Use Case**: Undo mechanisms in applications.
+
+### 4. **Queues**
+- **Description**: A collection of elements with First In First Out (FIFO) access.
+- **Time Complexity**: O(1) for enqueue and dequeue operations.
+- **Use Case**: Scheduling tasks or managing requests.
+
+### 5. **Hash Tables**
+- **Description**: A data structure that stores key-value pairs for fast access.
+- **Time Complexity**: O(1) for average-case lookups, O(n) in the worst case (due to collisions).
+- **Use Case**: Implementing a database of user records for fast retrieval.
+
+### 6. **Trees**
+- **Description**: A hierarchical structure with nodes connected by edges.
+- **Time Complexity**: O(log n) for balanced trees for insertion, deletion, and search.
+- **Use Case**: Organizing data for efficient searching (e.g., binary search trees).
+
+### 7. **Graphs**
+- **Description**: A collection of nodes connected by edges, which can be directed or undirected.
+- **Time Complexity**: Varies based on traversal algorithms (e.g., O(V + E) for BFS/DFS).
+- **Use Case**: Representing networks (e.g., social networks or transportation systems).
+
+## Choosing the Right Structure for Different Problems
+
+Selecting the correct data structure often depends on the problem at hand. Here are some scenarios to consider:
+
+### **Searching for an Element**
+- **Best Structure**: **Hash Table**  
+  - **Why**: Provides average O(1) time complexity for lookups.
+
+### **Implementing Undo Functionality**
+- **Best Structure**: **Stack**  
+  - **Why**: Allows for easy retrieval of the last action performed.
+
+### **Managing a Playlist of Songs**
+- **Best Structure**: **Linked List**  
+  - **Why**: Easily allows insertion and deletion of songs without shifting others.
+
+### **Handling Real-Time Task Scheduling**
+- **Best Structure**: **Queue**  
+  - **Why**: Ensures tasks are processed in the order they arrive.
+
+### **Representing a City Map for Shortest Path Algorithms**
+- **Best Structure**: **Graph**  
+  - **Why**: Efficiently models connections between locations.
+
+## Examples of Data Structures in Action
+
+### **Example 1: Using a Hash Table for Frequency Counting**
+When counting occurrences of elements in an array, a hash table can quickly map each element to its frequency:
+```python
+def count_frequencies(arr):
+    frequency = {}
+    for num in arr:
+        if num in frequency:
+            frequency[num] += 1
+        else:
+            frequency[num] = 1
+    return frequency
+```
+
+### **Example 2: Implementing a Queue for Task Management**
+A simple queue implementation can help manage tasks:
+```python
+class Queue:
+    def __init__(self):
+        self.items = []
+    
+    def enqueue(self, item):
+        self.items.insert(0, item)
+    
+    def dequeue(self):
+        return self.items.pop()
+
+queue = Queue()
+queue.enqueue('Task 1')
+queue.enqueue('Task 2')
+print(queue.dequeue())  # Output: Task 1
+```
+
+## Conclusion
+
+Choosing the right data structure is vital for optimizing performance and ensuring that your algorithms function efficiently. By understanding the strengths and weaknesses of various data structures, you can tackle problems more effectively, leading to better solutions in your coding journey. Whether you're preparing for interviews or working on real-world applications, mastering data structures will always be a key asset in your toolkit.
+
+--- 
+
diff --git a/blog/dynamic-programming-breaking-down-complex-problems.md b/blog/dynamic-programming-breaking-down-complex-problems.md
new file mode 100644
index 000000000..7d1bd1679
--- /dev/null
+++ b/blog/dynamic-programming-breaking-down-complex-problems.md
@@ -0,0 +1,73 @@
+---
+
+### Dynamic Programming: Breaking Down Complex Problems
+slug: dynamic-programming-breaking-down-complex-problems  
+title: "Dynamic Programming: Breaking Down Complex Problems"  
+authors: [ADITYA-JANI]  
+tags: [ADITYA-JANI, algorithms, dsa, dynamic-programming, optimization, recursion, coding, programming, computer-science, learning]  
+---
+
+Dynamic programming (DP) is a powerful technique used in algorithm design that simplifies complex problems by breaking them down into smaller, manageable subproblems. This method is particularly effective for optimization problems and can significantly reduce the time complexity compared to naive approaches.
+
+In this blog, we’ll cover:
+
+- **What is Dynamic Programming?**
+- **Key Concepts of Dynamic Programming**
+- **Common Dynamic Programming Problems**
+- **Real-World Applications of Dynamic Programming**
+
+## What is Dynamic Programming?
+
+Dynamic programming is a method for solving problems by storing the results of expensive function calls and reusing them when the same inputs occur again. This approach avoids the redundant calculations that are common in naive recursive solutions.
+
+### Important Points:
+- Dynamic programming is particularly useful for problems that can be broken down into overlapping subproblems.
+- It typically involves two main techniques: **Memoization** (top-down) and **Tabulation** (bottom-up).
+
+## Key Concepts of Dynamic Programming
+
+### 1. **Optimal Substructure**
+A problem exhibits optimal substructure if an optimal solution can be constructed from optimal solutions of its subproblems. 
+
+### 2. **Overlapping Subproblems**
+A problem has overlapping subproblems if it can be broken down into smaller subproblems that are reused several times.
+
+### Example: Fibonacci Sequence
+- **Naive Recursive Approach**: O(2^n)
+- **Dynamic Programming Approach**: O(n)
+
+```python
+def fibonacci(n):
+    if n <= 1:
+        return n
+    return fibonacci(n - 1) + fibonacci(n - 2)
+```
+
+**Using Dynamic Programming:**
+```python
+def fibonacci_dp(n):
+    dp = [0] * (n + 1)
+    dp[1] = 1
+    for i in range(2, n + 1):
+        dp[i] = dp[i - 1] + dp[i - 2]
+    return dp[n]
+```
+
+## Common Dynamic Programming Problems
+
+1. **Knapsack Problem**
+2. **Longest Common Subsequence**
+3. **Edit Distance**
+4. **Coin Change Problem**
+
+## Real-World Applications of Dynamic Programming
+
+- **Resource Allocation**: Optimizing the distribution of resources in logistics and supply chain management.
+- **Finance**: Portfolio optimization and risk management.
+- **Artificial Intelligence**: Used in reinforcement learning for decision-making processes.
+
+## Conclusion
+
+Dynamic programming is an essential algorithmic technique that simplifies problem-solving by breaking down complex tasks into manageable components. By understanding its principles and common applications, you can effectively tackle optimization problems in various domains.
+
+---
diff --git a/blog/graph-algorithms-navigating-complex-relationships.md b/blog/graph-algorithms-navigating-complex-relationships.md
new file mode 100644
index 000000000..f77eb6540
--- /dev/null
+++ b/blog/graph-algorithms-navigating-complex-relationships.md
@@ -0,0 +1,78 @@
+---
+
+###  Graph Algorithms: Navigating Complex Relationships
+slug: graph-algorithms-navigating-complex-relationships  
+title: "Graph Algorithms: Navigating Complex Relationships"  
+authors: [narendra-dhangar]  
+tags: [narendra-dhangar, algorithms, dsa, graph-algorithms, data-structures, optimization, coding, programming, computer-science, learning]  
+---
+
+Graph algorithms are crucial for solving problems involving relationships and connections among entities. Graphs are widely used in computer science to model various real-world scenarios, including social networks, transportation systems, and network topology.
+
+In this blog, we’ll cover:
+
+- **What are Graph Algorithms?**
+- **Key Types of Graph Algorithms**
+- **Common Graph Algorithms**
+- **Applications of Graph Algorithms**
+
+## What are Graph Algorithms?
+
+Graph algorithms are designed to perform operations on graphs, which consist of vertices (nodes) connected by edges (lines). These algorithms can solve problems related to traversal, shortest paths, and connectivity.
+
+### Important Points:
+- Graphs can be directed or undirected, weighted or unweighted, impacting the choice of algorithm.
+
+## Key Types of Graph Algorithms
+
+1. **Traversal Algorithms**: Used to visit all the vertices in a graph. Common traversal algorithms include Depth-First Search (DFS) and Breadth-First Search (BFS).
+2. **Pathfinding Algorithms**: Determine the shortest path between two vertices. Examples include Dijkstra’s and A* algorithms.
+3. **Minimum Spanning Tree Algorithms**: Find a subset of edges that connects all vertices with the minimum total edge weight, such as Prim's and Kruskal's algorithms.
+
+## Common Graph Algorithms
+
+### 1. Depth-First Search (DFS)
+DFS explores as far as possible along each branch before backtracking.
+
+```python
+def dfs(graph, node, visited=None):
+    if visited is None:
+        visited = set()
+    visited.add(node)
+    for neighbor in graph[node]:
+        if neighbor not in visited:
+            dfs(graph, neighbor, visited)
+    return visited
+```
+
+### 2. Breadth-First Search (BFS)
+BFS explores all neighbors at the present depth prior to moving on to nodes at the next depth level.
+
+```python
+from collections import deque
+
+def bfs(graph, start):
+    visited = set()
+    queue = deque([start])
+    
+    while queue:
+        node = queue.popleft()
+        if node not in visited:
+            visited.add(node)
+            queue.extend(neighbor for neighbor in graph[node] if neighbor not in visited)
+    return visited
+```
+
+## Applications of Graph Algorithms
+
+- **Social Networks**: Analyzing connections and relationships between users.
+- **Transportation**: Finding optimal routes and traffic management.
+- **Computer Networks**: Routing and connectivity analysis.
+- **Recommendation Systems**: Suggesting products based on user interactions.
+
+## Conclusion
+
+Graph algorithms are essential for navigating complex relationships and solving problems across various domains. By understanding their types and applications, you can effectively apply graph algorithms to enhance your programming capabilities and tackle real-world challenges.
+
+--- 
+
diff --git a/blog/graph-theory-basics.md b/blog/graph-theory-basics.md
new file mode 100644
index 000000000..1b7bab916
--- /dev/null
+++ b/blog/graph-theory-basics.md
@@ -0,0 +1,116 @@
+---
+
+slug: graph-theory-basics  
+title: "Graph Theory Basics: Understanding Graphs and Their Applications"  
+authors: [ajay-dhangar]  
+tags: [ajay-dhangar, algorithms, dsa, graph-theory, data-structures, traversal, optimization, coding, programming, computer-science, learning]  
+---
+
+Graph theory is a fundamental area of study in computer science that focuses on the representation and analysis of graphs. Graphs are versatile data structures used to model relationships between objects, making them essential for various applications, from social networks to transportation systems. In this blog, we’ll delve into the basics of graph theory, including key concepts, types of graphs, and common algorithms for graph traversal.
+
+In this blog, we’ll cover:
+
+- **Why Graph Theory Matters**
+- **Basic Concepts in Graph Theory**
+- **Types of Graphs**
+- **Graph Traversal Algorithms**
+
+## Why Graph Theory Matters
+
+Understanding graph theory is crucial for solving complex problems in computer science and related fields. Graphs allow us to represent and analyze relationships and connections in various real-world scenarios. Here are a few applications of graph theory:
+
+- **Social Networks**: Modeling relationships between users and their connections.
+- **Transportation**: Optimizing routes in logistics and navigation systems.
+- **Computer Networks**: Analyzing network connections and data flow.
+- **Recommendation Systems**: Suggesting products based on user preferences and connections.
+
+## Basic Concepts in Graph Theory
+
+### 1. **Vertices and Edges**
+- A **graph** is composed of **vertices** (or nodes) and **edges** (connections between vertices). For example, in a social network, users are vertices, and their friendships are edges.
+
+### 2. **Directed vs. Undirected Graphs**
+- **Directed Graphs**: Edges have a direction, indicating a one-way relationship (e.g., A → B).
+- **Undirected Graphs**: Edges have no direction, indicating a two-way relationship (e.g., A ↔ B).
+
+### 3. **Weighted vs. Unweighted Graphs**
+- **Weighted Graphs**: Edges have weights or costs associated with them, representing the distance or cost between nodes (e.g., a map with distances).
+- **Unweighted Graphs**: All edges are considered equal, with no specific weight.
+
+### 4. **Degree of a Vertex**
+- The **degree** of a vertex is the number of edges connected to it. In a directed graph, we differentiate between **in-degree** (incoming edges) and **out-degree** (outgoing edges).
+
+## Types of Graphs
+
+Graphs can be classified into several categories:
+
+- **Simple Graphs**: No loops or multiple edges between two vertices.
+- **Complete Graphs**: Every pair of vertices is connected by a unique edge.
+- **Cyclic Graphs**: Contain at least one cycle (a path that starts and ends at the same vertex).
+- **Acyclic Graphs**: No cycles are present; trees are a common example.
+- **Bipartite Graphs**: Vertices can be divided into two disjoint sets, with edges only connecting vertices from different sets.
+
+## Graph Traversal Algorithms
+
+Graph traversal algorithms are essential for exploring the nodes and edges of a graph. Two of the most common traversal methods are:
+
+### 1. **Depth-First Search (DFS)**
+- **Description**: DFS explores as far as possible along each branch before backtracking. It uses a stack (either implicitly via recursion or explicitly) to keep track of vertices to visit next.
+- **Time Complexity**: O(V + E), where V is the number of vertices and E is the number of edges.
+
+#### Example of DFS in Python:
+
+```python
+def dfs(graph, vertex, visited=None):
+    if visited is None:
+        visited = set()
+    visited.add(vertex)
+    print(vertex)
+    for neighbor in graph[vertex]:
+        if neighbor not in visited:
+            dfs(graph, neighbor, visited)
+
+# Example usage
+graph = {
+    'A': ['B', 'C'],
+    'B': ['A', 'D', 'E'],
+    'C': ['A', 'F'],
+    'D': ['B'],
+    'E': ['B', 'F'],
+    'F': ['C', 'E']
+}
+dfs(graph, 'A')
+```
+
+### 2. **Breadth-First Search (BFS)**
+- **Description**: BFS explores all neighbors at the present depth before moving on to nodes at the next depth level. It uses a queue to keep track of vertices to visit.
+- **Time Complexity**: O(V + E).
+
+#### Example of BFS in Python:
+
+```python
+from collections import deque
+
+def bfs(graph, start):
+    visited = set()
+    queue = deque([start])
+    visited.add(start)
+
+    while queue:
+        vertex = queue.popleft()
+        print(vertex)
+
+        for neighbor in graph[vertex]:
+            if neighbor not in visited:
+                visited.add(neighbor)
+                queue.append(neighbor)
+
+# Example usage
+bfs(graph, 'A')
+```
+
+## Conclusion
+
+Graph theory is a powerful tool for understanding complex relationships and connections in various domains. By grasping the basic concepts, types of graphs, and common traversal algorithms, you can apply graph theory effectively in your programming and problem-solving endeavors. Whether you’re working with social networks, transportation systems, or data structures, a solid foundation in graph theory will enhance your ability to tackle challenges and optimize solutions.
+
+--- 
diff --git a/blog/greedy-algorithm.md b/blog/greedy-algorithm.md
new file mode 100644
index 000000000..fbecd1e1c
--- /dev/null
+++ b/blog/greedy-algorithm.md
@@ -0,0 +1,66 @@
+---
+
+###  Greedy Algorithms: Making the Best Local Choice
+slug: greedy-algorithms-making-the-best-local-choice  
+title: "Greedy Algorithms: Making the Best Local Choice"  
+authors: [AKSHITHA-CHILUKA]  
+tags: [AKSHITHA-CHILUKA, algorithms, dsa, greedy-algorithms, optimization, problem-solving, coding, programming, computer-science, learning]  
+---
+
+Greedy algorithms are a class of algorithms that make locally optimal choices at each stage with the hope of finding a global optimum. This approach is often used in optimization problems where the goal is to find the best solution among many feasible ones.
+
+In this blog, we’ll cover:
+
+- **What are Greedy Algorithms?**
+- **Key Characteristics of Greedy Algorithms**
+- **Common Greedy Algorithm Problems**
+- **When to Use Greedy Algorithms**
+
+## What are Greedy Algorithms?
+
+Greedy algorithms build up a solution piece by piece, always choosing the next piece that offers the most immediate benefit. This approach works well for certain problems but may not yield the optimal solution for others.
+
+### Important Points:
+- Greedy algorithms are generally easier to implement and understand than other methods like dynamic programming.
+- They do not always guarantee an optimal solution, so careful analysis is necessary.
+
+## Key Characteristics of Greedy Algorithms
+
+1. **Locally Optimal Choice**: At each step, the algorithm chooses the best option available at that moment.
+2. **Irrevocable Decisions**: Once a choice is made, it cannot be changed later.
+3. **Feasibility**: The chosen option must satisfy the problem's constraints.
+
+## Common Greedy Algorithm Problems
+
+1. **Activity Selection Problem**
+2. **Huffman Coding**
+3. **Minimum Spanning Tree (Kruskal's and Prim's Algorithms)**
+4. **Dijkstra's Shortest Path Algorithm**
+
+### Example: Activity Selection Problem
+
+Suppose you have a set of activities with start and end times, and you want to select the maximum number of activities that don’t overlap.
+
+```python
+def activity_selection(activities):
+    activities.sort(key=lambda x: x[1])  # Sort by end time
+    selected_activities = [activities[0]]
+    last_end_time = activities[0][1]
+
+    for i in range(1, len(activities)):
+        if activities[i][0] >= last_end_time:
+            selected_activities.append(activities[i])
+            last_end_time = activities[i][1]
+
+    return selected_activities
+```
+
+## When to Use Greedy Algorithms
+
+Greedy algorithms are ideal for problems that exhibit the **greedy choice property** and **optimal substructure**. When you can prove that making a local optimal choice leads to a global optimum, a greedy approach is appropriate.
+
+## Conclusion
+
+Greedy algorithms are powerful tools in algorithm design, particularly for optimization problems. By understanding their characteristics and applications, you can effectively apply them to various challenges in programming and computer science.
+
+---
diff --git a/blog/hashing-the-art-of-fast-data-retrieval.md b/blog/hashing-the-art-of-fast-data-retrieval.md
new file mode 100644
index 000000000..bf53ca30b
--- /dev/null
+++ b/blog/hashing-the-art-of-fast-data-retrieval.md
@@ -0,0 +1,58 @@
+---
+
+###  Hashing: The Art of Fast Data Retrieval
+slug: hashing-the-art-of-fast-data-retrieval  
+title: "Hashing: The Art of Fast Data Retrieval"  
+authors: [LOKESH-BIJARNIYA]  
+tags: [LOKESH-BIJARNIYA, algorithms, dsa, hashing, data-structures, optimization, coding, programming, computer-science, learning]  
+---
+
+Hashing is a powerful technique used to optimize data retrieval by mapping data to a fixed-size value called a hash code. This method allows for efficient data access and is widely used in various applications, such as databases, caches, and cryptography.
+
+In this blog, we’ll cover:
+
+- **What is Hashing?**
+- **Key Concepts in Hashing**
+- **Common Hashing Techniques**
+- **Real-World Applications of Hashing**
+
+## What is Hashing?
+
+Hashing transforms input data into a fixed-size string of characters, which is typically a numeric value. This transformation helps to achieve constant-time complexity for data retrieval, making it a valuable technique in computer science.
+
+### Important Points:
+
+
+- Hashing can lead to **collisions**, where two different inputs produce the same hash code. Proper handling of collisions is crucial for effective hashing.
+
+## Key Concepts in Hashing
+
+1. **Hash Function**: A function that takes an input and produces a hash code. The quality of the hash function affects the efficiency and performance of the hashing process.
+2. **Collision Resolution**: Techniques to manage instances when two different inputs produce the same hash value. Common methods include:
+   - **Chaining**: Storing multiple values at the same index using a data structure like a linked list.
+   - **Open Addressing**: Finding the next available slot in the hash table for storing the colliding value.
+
+## Common Hashing Techniques
+
+1. **Direct Address Tables**: Uses an array where the index is the hash code.
+2. **Separate Chaining**: Each slot in the hash table contains a linked list to handle collisions.
+3. **Open Addressing**: Probes the table to find an empty slot when a collision occurs.
+
+### Example of a Simple Hash Function:
+
+```python
+def simple_hash(key):
+    return sum(ord(char) for char in key) % 100
+```
+
+## Real-World Applications of Hashing
+
+- **Databases**: Efficiently storing and retrieving data using hash tables.
+- **Caching**: Quickly accessing frequently used data.
+- **Cryptography**: Ensuring data integrity through hash functions in security protocols.
+
+## Conclusion
+
+Hashing is an essential technique for optimizing data retrieval and management. By understanding its principles and applications, you can effectively utilize hashing in your programming projects and enhance data processing efficiency.
+
+---
diff --git a/blog/recursion-embracing-the-power-of-self-referencing.md b/blog/recursion-embracing-the-power-of-self-referencing.md
new file mode 100644
index 000000000..243dd9262
--- /dev/null
+++ b/blog/recursion-embracing-the-power-of-self-referencing.md
@@ -0,0 +1,67 @@
+---
+
+### Recursion: Embracing the Power of Self-Referencing
+slug: recursion-embracing-the-power-of-self-referencing  
+title: "Recursion: Embracing the Power of Self-Referencing"  
+authors: [ajay-dhangar]  
+tags: [ajay-dhangar, algorithms, dsa, recursion, programming, coding, computer-science, learning]  
+---
+
+Recursion is a fundamental programming concept where a function calls itself to solve a problem. It is a powerful technique that can simplify complex problems by breaking them down into smaller, more manageable components.
+
+In this blog, we’ll cover:
+
+- **What is Recursion?**
+- **Key Concepts of Recursion**
+- **Common Use Cases for Recursion**
+- **Best Practices for Writing Recursive Functions**
+
+## What is Recursion?
+
+Recursion occurs when a function solves a problem by dividing it into smaller instances of the same problem. Each recursive call moves closer to a base case, where the function stops calling itself and begins returning values.
+
+### Important Points:
+- A recursive function must have a **base case** to terminate the recursion and prevent infinite loops.
+- Recursive solutions can be less efficient in terms of time and space complexity compared to iterative solutions due to function call overhead.
+
+## Key Concepts of Recursion
+
+1. **Base Case**: The condition under which the recursion ends. This is essential for preventing infinite recursion.
+2. **Recursive Case**: The part of the function that includes the recursive call, which breaks the problem into smaller subproblems.
+
+### Example: Factorial Calculation
+
+#### Iterative Approach:
+```python
+def factorial_iterative(n):
+    result = 1
+    for i in range(1, n + 1):
+        result *= i
+    return result
+```
+
+#### Recursive Approach:
+```python
+def factorial_recursive(n):
+    if n == 0 or n == 1:  # Base case
+        return 1
+    return n * factorial_recursive(n - 1)  # Recursive case
+```
+
+## Common Use Cases for Recursion
+
+1. **Tree Traversal**: Recursion is commonly used to traverse data structures like trees (e.g., binary trees).
+2. **Backtracking Algorithms**: Problems like generating permutations or combinations often leverage recursion.
+3. **Dynamic Programming**: Many dynamic programming solutions can be expressed recursively before optimizing with memoization.
+
+## Best Practices for Writing Recursive Functions
+
+- Ensure that you have a clear base case to avoid infinite recursion.
+- Optimize recursive solutions using memoization when applicable.
+- Be mindful of the maximum recursion depth in your programming language, as deep recursion can lead to stack overflow errors.
+
+## Conclusion
+
+Recursion is a powerful and elegant solution for solving complex problems by leveraging self-referential function calls. By understanding its principles and applications, you can effectively use recursion to simplify your programming tasks and improve code readability.
+
+---
diff --git a/blog/searching-algorithms-finding-your-way-through-data.md b/blog/searching-algorithms-finding-your-way-through-data.md
new file mode 100644
index 000000000..bb8f5d70d
--- /dev/null
+++ b/blog/searching-algorithms-finding-your-way-through-data.md
@@ -0,0 +1,70 @@
+
+
+### Searching Algorithms: Finding Your Way Through Data
+slug: searching-algorithms-finding-your-way-through-data  
+title: "Searching Algorithms: Finding Your Way Through Data"  
+authors: [Rishi-Verma]  
+tags: [Rishi-Verma, algorithms, dsa, searching-algorithms, data-structures, optimization, coding, programming, computer-science, learning]  
+---
+
+Searching algorithms are essential for retrieving data from data structures efficiently. They enable us to find specific elements within a dataset, which is a fundamental operation in computer science and programming.
+
+In this blog, we’ll cover:
+
+- **What are Searching Algorithms?**
+- **Types of Searching Algorithms**
+- **Common Searching Algorithms**
+- **Performance Considerations**
+
+## What are Searching Algorithms?
+
+Searching algorithms are methods used to locate a specific value or set of values within a data structure. The choice of algorithm depends on the structure and organization of the data, as well as the required performance characteristics.
+
+## Types of Searching Algorithms
+
+1. **Linear Search**: A straightforward method that checks each element in a list sequentially until the target value is found or the list is exhausted.
+2. **Binary Search**: A more efficient method that works on sorted lists by repeatedly dividing the search interval in half.
+
+### Example of Linear Search:
+
+```python
+def linear_search(arr, target):
+    for index, value in enumerate(arr):
+        if value == target:
+            return index
+    return -1
+```
+
+### Example of Binary Search:
+
+```python
+def binary_search(arr, target):
+    left, right = 0, len(arr) - 1
+    while left <= right:
+        mid = left + (right - left) // 2
+        if arr[mid] == target:
+            return mid
+        elif arr[mid] < target:
+            left = mid + 1
+        else:
+            right = mid - 1
+    return -1
+```
+
+## Common Searching Algorithms
+
+1. **Linear Search**: O(n)
+2. **Binary Search**: O(log n) (requires a sorted array)
+3. **Ternary Search**: Similar to binary search but divides the array into three parts.
+4. **Interpolation Search**: A refined version of binary search that uses a probe position to improve search efficiency.
+
+## Performance Considerations
+
+- **Time Complexity**: Analyzing the time complexity helps determine the efficiency of a searching algorithm. For large datasets, binary search is preferable due to its logarithmic time complexity.
+- **Space Complexity**: Consider how much additional memory an algorithm uses. Most searching algorithms have a space complexity of O(1).
+
+## Conclusion
+
+Searching algorithms are vital for efficiently accessing and retrieving data in various applications. By understanding the different types and their use cases, you can choose the most appropriate searching method for your programming tasks.
+
+---
diff --git a/blog/sorting-algorithms-from bubblesort-to-quicksort.md b/blog/sorting-algorithms-from bubblesort-to-quicksort.md
new file mode 100644
index 000000000..e9015310f
--- /dev/null
+++ b/blog/sorting-algorithms-from bubblesort-to-quicksort.md	
@@ -0,0 +1,101 @@
+---
+
+slug: sorting-algorithms-from-bubble-sort-to-quick-sort  
+title: "Sorting Algorithms: From Bubble Sort to Quick Sort"  
+authors: [ADITYA-JANI]  
+tags: [ADITYA-JANI, algorithms, dsa, sorting, time-complexity, performance, optimization, coding, programming, computer-science, learning]  
+---
+
+Sorting is a fundamental concept in computer science that involves arranging data in a specific order. Understanding various sorting algorithms is essential for any programmer, as they are frequently used in applications ranging from data processing to machine learning. In this blog, we'll explore different sorting algorithms, their time complexities, and real-world use cases.
+
+In this blog, we’ll cover:
+
+- **Why Sorting Algorithms Matter**
+- **Common Sorting Algorithms**
+- **Time Complexities of Sorting Algorithms**
+- **Comparative Analysis and Performance Tips**
+
+## Why Sorting Algorithms Matter
+
+Sorting algorithms play a crucial role in optimizing data retrieval and improving the efficiency of various applications. A well-chosen sorting algorithm can significantly reduce the time complexity of data operations, making it faster to search, merge, or manipulate data. 
+
+By understanding the strengths and weaknesses of different sorting algorithms, you can make informed decisions when implementing them in your code.
+
+## Common Sorting Algorithms
+
+### 1. **Bubble Sort**
+- **Description**: A simple comparison-based algorithm that repeatedly steps through the list, compares adjacent elements, and swaps them if they are in the wrong order.
+- **Time Complexity**: O(n²) in the average and worst cases, O(n) in the best case (when the array is already sorted).
+- **Use Case**: Educational purposes and small datasets due to its simplicity.
+
+### 2. **Selection Sort**
+- **Description**: Divides the input list into two parts: a sorted and an unsorted part. It repeatedly selects the smallest (or largest) element from the unsorted portion and moves it to the sorted portion.
+- **Time Complexity**: O(n²) for all cases.
+- **Use Case**: Small lists and scenarios where memory write is a costly operation.
+
+### 3. **Insertion Sort**
+- **Description**: Builds a sorted array one element at a time by repeatedly taking the next element from the unsorted portion and inserting it into the correct position in the sorted portion.
+- **Time Complexity**: O(n²) on average, O(n) in the best case (when the array is nearly sorted).
+- **Use Case**: Small datasets or nearly sorted datasets, as it is efficient for small inputs.
+
+### 4. **Merge Sort**
+- **Description**: A divide-and-conquer algorithm that divides the array into halves, recursively sorts them, and then merges the sorted halves.
+- **Time Complexity**: O(n log n) for all cases.
+- **Use Case**: Large datasets and when stability is required (equal elements maintain their relative order).
+
+### 5. **Quick Sort**
+- **Description**: Another divide-and-conquer algorithm that selects a 'pivot' element and partitions the other elements into those less than and greater than the pivot, recursively sorting the partitions.
+- **Time Complexity**: O(n log n) on average, O(n²) in the worst case (when the smallest or largest element is consistently chosen as the pivot).
+- **Use Case**: Large datasets and general-purpose sorting, often faster in practice than other O(n log n) algorithms.
+
+### 6. **Heap Sort**
+- **Description**: A comparison-based sorting algorithm that utilizes a binary heap data structure to sort elements. It involves building a max heap and repeatedly extracting the maximum element.
+- **Time Complexity**: O(n log n) for all cases.
+- **Use Case**: When memory usage is a concern, as it sorts in place.
+
+## Time Complexities of Sorting Algorithms
+
+Understanding the time complexities of sorting algorithms helps in selecting the right algorithm based on the dataset size and characteristics. Here’s a quick overview:
+
+| Algorithm      | Best Case    | Average Case | Worst Case   | Space Complexity |
+|----------------|--------------|--------------|--------------|------------------|
+| Bubble Sort    | O(n)        | O(n²)       | O(n²)       | O(1)             |
+| Selection Sort | O(n²)       | O(n²)       | O(n²)       | O(1)             |
+| Insertion Sort | O(n)        | O(n²)       | O(n²)       | O(1)             |
+| Merge Sort     | O(n log n)  | O(n log n)  | O(n log n)  | O(n)             |
+| Quick Sort     | O(n log n)  | O(n log n)  | O(n²)       | O(log n)         |
+| Heap Sort      | O(n log n)  | O(n log n)  | O(n log n)  | O(1)             |
+
+## Comparative Analysis and Performance Tips
+
+When choosing a sorting algorithm, consider the following:
+
+- **Data Size**: For small datasets, simpler algorithms like Bubble Sort or Insertion Sort may be efficient enough. For larger datasets, prefer Quick Sort or Merge Sort.
+- **Data Characteristics**: If the data is nearly sorted, Insertion Sort can be quite effective. Conversely, Quick Sort is generally faster for random data.
+- **Memory Usage**: If memory usage is a concern, Heap Sort is an excellent choice as it sorts in place.
+
+### Example: Sorting with Quick Sort
+
+Here's a simple implementation of Quick Sort in Python:
+
+```python
+def quick_sort(arr):
+    if len(arr) <= 1:
+        return arr
+    pivot = arr[len(arr) // 2]
+    left = [x for x in arr if x < pivot]
+    middle = [x for x in arr if x == pivot]
+    right = [x for x in arr if x > pivot]
+    return quick_sort(left) + middle + quick_sort(right)
+
+# Example usage
+numbers = [10, 7, 8, 9, 1, 5]
+sorted_numbers = quick_sort(numbers)
+print("Sorted array:", sorted_numbers)  # Output: [1, 5, 7, 8, 9, 10]
+```
+
+## Conclusion
+
+Sorting algorithms are foundational tools in computer science that help in organizing data effectively. By understanding the characteristics, time complexities, and best-use cases of different sorting algorithms, you can make informed decisions to optimize your code for various applications. Whether you’re working with small datasets or large volumes of information, the right sorting algorithm can significantly enhance performance and efficiency in your programs.
+
+--- 
diff --git a/src/data/problemData.ts b/src/data/problemData.ts
index 02a389dc6..7816119e6 100644
--- a/src/data/problemData.ts
+++ b/src/data/problemData.ts
@@ -60,6 +60,8 @@ const problemsData = {
               
               res[num] = i`,
     },
+    timeComplexity: { cpp: "O(n)", java: "O(n)", python: "O(n)" },
+    spaceComplexity: { cpp: "O(1)", java: "O(1)", python: "O(1)" }
   },
   containerWithMostWater: {
     title: "2. Container With Most Water",
@@ -125,6 +127,16 @@ class Solution:
           
           return max_area`,
     },
+    timeComplexity: {
+        cpp: "O(n)",
+        java: "O(n)",
+        python: "O(n)",
+      },
+      spaceComplexity: {
+        cpp: "O(1)",
+        java: "O(1)",
+        python: "O(1)",
+      },
   },
   threeSum: {
     title: "3. 3Sum",
@@ -210,6 +222,16 @@ class Solution:
                     k -= 1
         return res`,
     },
+    timeComplexity: {
+        cpp: "O(n^2)",
+        java: "O(n^2)",
+        python: "O(n^2)",
+    },
+    spaceComplexity: {
+        cpp: "O(1)",
+        java: "O(1)",
+        python: "O(1)",
+    },
   },
 
   isValidParentheses: {
@@ -268,6 +290,17 @@ class Solution:
                 stack.append(char)
         return not stack`,
     },
+    timeComplexity: {
+        cpp: "O(n)",
+        java: "O(n)",
+        python: "O(n)",
+    },
+    spaceComplexity: {
+        cpp: "O(n)",
+        java: "O(n)",
+        python: "O(n)",
+    },
+    
   },
 
   mergeTwoLists: {
@@ -323,6 +356,17 @@ class Solution:
             l2.next = self.mergeTwoLists(l1, l2.next)
             return l2`,
     },
+    timeComplexity: {
+        cpp: "O(n + m)",
+        java: "O(n + m)",
+        python: "O(n + m)",
+    },
+    spaceComplexity: {
+        cpp: "O(1)",
+        java: "O(1)",
+        python: "O(1)",
+    },
+    
   },
 
   nextPermutation: {
@@ -383,6 +427,17 @@ class Solution:
             nums[i], nums[j] = nums[j], nums[i]
         nums[i + 1:] = nums[i + 1:][::-1]`,
     },
+    timeComplexity: {
+    cpp: "O(n)",
+    java: "O(n)",
+    python: "O(n)",
+},
+spaceComplexity: {
+    cpp: "O(1)",
+    java: "O(1)",
+    python: "O(1)",
+},
+
   },
   searchInsert: {
     title: "7. Search Insert Position",
@@ -435,6 +490,17 @@ class Solution:
                 low = mid + 1
         return low`,
     },
+    timeComplexity: {
+        cpp: "O(log n)",
+        java: "O(log n)",
+        python: "O(log n)",
+    },
+    spaceComplexity: {
+        cpp: "O(1)",
+        java: "O(1)",
+        python: "O(1)",
+    },
+    
   },
 
   isValidSudoku: {
@@ -501,6 +567,17 @@ class Solution:
           blocks[(i//3)*3+j//3].add(curr)
       return True`,
     },
+    timeComplexity: {
+        cpp: "O(1)",
+        java: "O(1)",
+        python: "O(1)",
+    },
+    spaceComplexity: {
+        cpp: "O(1)",
+        java: "O(1)",
+        python: "O(1)",
+    },
+    
   },
 
   firstMissingPositive: {
@@ -554,6 +631,17 @@ class Solution:
         if not present[i]: return i
       return n + 1`,
     },
+    timeComplexity: {
+        cpp: "O(n)",
+        java: "O(n)",
+        python: "O(n)",
+    },
+    spaceComplexity: {
+        cpp: "O(n)",
+        java: "O(n)",
+        python: "O(n)",
+    },
+    
   },
 
   maxSubArray: {
@@ -599,6 +687,17 @@ class Solution:
         max_sum = max(max_sum, curr_sum)
       return max_sum`,
     },
+    timeComplexity: {
+        cpp: "O(n)",
+        java: "O(n)",
+        python: "O(n)",
+    },
+    spaceComplexity: {
+        cpp: "O(1)",
+        java: "O(1)",
+        python: "O(1)",
+    },
+    
   },
   mySqrt: {
     title: "11. Sqrt(x)",
@@ -657,6 +756,17 @@ class Solution:
         return res
     `,
     },
+    timeComplexity: {
+        cpp: "O(log n)",
+        java: "O(log n)",
+        python: "O(log n)",
+    },
+    spaceComplexity: {
+        cpp: "O(1)",
+        java: "O(1)",
+        python: "O(1)",
+    },
+    
   },
 
   searchMatrix: {
@@ -714,6 +824,17 @@ class Solution:
         return False
     `,
     },
+    timeComplexity: {
+        cpp: "O(log(m * n))",
+        java: "O(log(m * n))",
+        python: "O(log(m * n))",
+    },
+    spaceComplexity: {
+        cpp: "O(1)",
+        java: "O(1)",
+        python: "O(1)",
+    },
+    
   },
 
   deleteDuplicates: {
@@ -764,6 +885,17 @@ class Solution:
         return head
     `,
     },
+    timeComplexity: {
+        cpp: "O(n)",
+        java: "O(n)",
+        python: "O(n)",
+    },
+    spaceComplexity: {
+        cpp: "O(1)",
+        java: "O(1)",
+        python: "O(1)",
+    },
+    
   },
 
   mergeTwoSortedLists: {
@@ -812,6 +944,17 @@ class Solution:
         nums1.sort()
     `,
     },
+    timeComplexity: {
+        cpp: "O((m+n) log(m+n))",
+        java: "O((m+n) log(m+n))",
+        python: "O((m+n) log(m+n))",
+    },
+    spaceComplexity: {
+        cpp: "O(1)",
+        java: "O(1)",
+        python: "O(1)",
+    },
+    
   },
   inorderTraversal: {
     title: "15. Binary Tree Inorder Traversal",
@@ -862,6 +1005,17 @@ class Solution:
         return ans
     `,
     },
+    timeComplexity: {
+        cpp: "O(n)",
+        java: "O(n)",
+        python: "O(n)",
+    },
+    spaceComplexity: {
+        cpp: "O(h)",
+        java: "O(h)",
+        python: "O(h)",
+    },
+    
   },
 
   isSymmetric: {
@@ -912,6 +1066,17 @@ class Solution:
         return self.isSymmetricTest(p.left, q.right) and self.isSymmetricTest(p.right, q.left)
     `,
     },
+    timeComplexity: {
+        cpp: "O(n)",
+        java: "O(n)",
+        python: "O(n)",
+    },
+    spaceComplexity: {
+        cpp: "O(h)",
+        java: "O(h)",
+        python: "O(h)",
+    },
+    
   },
 
   levelOrderTraversal: {
@@ -988,6 +1153,17 @@ class Solution:
         return ans
     `,
     },
+    timeComplexity: {
+        cpp: "O(n)",
+        java: "O(n)",
+        python: "O(n)",
+    },
+    spaceComplexity: {
+        cpp: "O(w)",
+        java: "O(w)",
+        python: "O(w)",
+    },
+    
   },
 
   maxDepthBinaryTree: {
@@ -1027,6 +1203,17 @@ class Solution:
         return max(leftDepth, rightDepth) + 1
     `,
     },
+    timeComplexity: {
+        cpp: "O(n)",
+        java: "O(n)",
+        python: "O(n)",
+    },
+    spaceComplexity: {
+        cpp: "O(h)",
+        java: "O(h)",
+        python: "O(h)",
+    },
+    
   },
   hasPathSum: {
     title: "19. Path Sum",
@@ -1074,6 +1261,17 @@ class Solution:
         return self.hasPathSum(root.left, sum - root.val) or self.hasPathSum(root.right, sum - root.val)
     `,
     },
+    timeComplexity: {
+        cpp: "O(n)",
+        java: "O(n)",
+        python: "O(n)",
+    },
+    spaceComplexity: {
+        cpp: "O(h)",
+        java: "O(h)",
+        python: "O(h)",
+    },
+    
   },
 
   generatePascalTriangle: {
@@ -1134,6 +1332,17 @@ class Solution:
         return res
     `,
     },
+    timeComplexity: {
+        cpp: "O(n^2)",
+        java: "O(n^2)",
+        python: "O(n^2)",
+    },
+    spaceComplexity: {
+        cpp: "O(n^2)",
+        java: "O(n^2)",
+        python: "O(n^2)",
+    },
+    
   },
 
   maxProfit: {
@@ -1185,6 +1394,17 @@ class Solution:
         return result
     `,
     },
+    timeComplexity: {
+        cpp: "O(n)",
+        java: "O(n)",
+        python: "O(n)",
+    },
+    spaceComplexity: {
+        cpp: "O(1)",
+        java: "O(1)",
+        python: "O(1)",
+    },
+    
   },
 
   hasCycle: {
@@ -1257,6 +1477,17 @@ class Solution:
         return False
     `,
     },
+    timeComplexity: {
+        cpp: "O(n)",
+        java: "O(n)",
+        python: "O(n)",
+    },
+    spaceComplexity: {
+        cpp: "O(1)",
+        java: "O(1)",
+        python: "O(1)",
+    },
+    
   },
   preorderTraversal: {
     title: "23. Binary Tree Preorder Traversal",
@@ -1319,6 +1550,17 @@ class Solution:
           self.preorder(node.right, result)
       `,
     },
+    timeComplexity: {
+        cpp: "O(n)",
+        java: "O(n)",
+        python: "O(n)",
+    },
+    spaceComplexity: {
+        cpp: "O(h)",
+        java: "O(h)",
+        python: "O(h)",
+    },
+    
   },
 
   postorderTraversal: {
@@ -1382,6 +1624,17 @@ class Solution:
           result.append(node.val)
       `,
     },
+    timeComplexity: {
+        cpp: "O(n)",
+        java: "O(n)",
+        python: "O(n)",
+    },
+    spaceComplexity: {
+        cpp: "O(h)",
+        java: "O(h)",
+        python: "O(h)",
+    },
+    
   },
 
   removeElements: {
@@ -1428,6 +1681,17 @@ class Solution:
           return head
       `,
     },
+    timeComplexity: {
+        cpp: "O(n)",
+        java: "O(n)",
+        python: "O(n)",
+    },
+    spaceComplexity: {
+        cpp: "O(h)",
+        java: "O(h)",
+        python: "O(h)",
+    },
+    
   },
 
   reverseList: {
@@ -1497,6 +1761,17 @@ class Solution:
           return head
       `,
     },
+    timeComplexity: {
+        cpp: "O(n)",
+        java: "O(n)",
+        python: "O(n)",
+    },
+    spaceComplexity: {
+        cpp: "O(n)",
+        java: "O(n)",
+        python: "O(n)",
+    },
+    
   },
 
   findKthLargest: {
@@ -1534,6 +1809,17 @@ class Solution:
           return nums[-k]
       `,
     },
+    timeComplexity: {
+        cpp: "O(n log n)",
+        java: "O(n log n)",
+        python: "O(n log n)",
+    },
+    spaceComplexity: {
+        cpp: "O(1)",
+        java: "O(1)",
+        python: "O(1)",
+    },
+    
   },
 
   containsDuplicate: {
@@ -1573,6 +1859,17 @@ class Solution:
           return len(nums) > len(set(nums))
       `,
     },
+    timeComplexity: {
+        cpp: "O(n)",
+        java: "O(n)",
+        python: "O(n)",
+    },
+    spaceComplexity: {
+        cpp: "O(n)",
+        java: "O(n)",
+        python: "O(n)",
+    },
+    
   },
 
   invertBinaryTree: {
@@ -1619,6 +1916,17 @@ class Solution:
           return root
       `,
     },
+    timeComplexity: {
+        cpp: "O(n)",
+        java: "O(n)",
+        python: "O(n)",
+    },
+    spaceComplexity: {
+        cpp: "O(h)",
+        java: "O(h)",
+        python: "O(h)",
+    },
+    
   },
 
   MyQueue: {
@@ -1725,6 +2033,17 @@ class Solution:
           return not self.s1
       `,
     },
+    timeComplexity: {
+        cpp: "O(n) for push, O(1) for pop and peek",
+        java: "O(n) for push, O(1) for pop and peek",
+        python: "O(n) for push, O(1) for pop and peek",
+    },
+    spaceComplexity: {
+        cpp: "O(n)",
+        java: "O(n)",
+        python: "O(n)",
+    },
+    
   },
 
   isAnagram: {
@@ -1785,6 +2104,17 @@ class Solution:
           return all(c == 0 for c in count)
       `,
     },
+    timeComplexity: {
+        cpp: "O(n)",
+        java: "O(n)",
+        python: "O(n)",
+    },
+    spaceComplexity: {
+        cpp: "O(1)",
+        java: "O(1)",
+        python: "O(1)",
+    },
+    
   },
 
   missingNumber: {
@@ -1829,6 +2159,17 @@ class Solution:
           return n * (n + 1) // 2 - sum(nums)
       `,
     },
+    timeComplexity: {
+        cpp: "O(n)",
+        java: "O(n)",
+        python: "O(n)",
+    },
+    spaceComplexity: {
+        cpp: "O(1)",
+        java: "O(1)",
+        python: "O(1)",
+    },
+    
   },
 
   guessNumber: {
@@ -1895,6 +2236,17 @@ class Solution:
                   start = mid + 1
       `,
     },
+    timeComplexity: {
+        cpp: "O(log n)",
+        java: "O(log n)",
+        python: "O(log n)",
+    },
+    spaceComplexity: {
+        cpp: "O(1)",
+        java: "O(1)",
+        python: "O(1)",
+    },
+    
   },
 
   intersect: {
@@ -1976,6 +2328,17 @@ class Solution:
           return result
       `,
     },
+    timeComplexity: {
+        cpp: "O(n log n + m log m)",
+        java: "O(n log n + m log m)",
+        python: "O(n log n + m log m)",
+    },
+    spaceComplexity: {
+        cpp: "O(1) or O(min(n, m)) depending on the result size",
+        java: "O(n + m)",
+        python: "O(min(n, m))",
+    },
+    
   },
 
   runningSum: {
@@ -2015,6 +2378,17 @@ class Solution:
           return nums
       `,
     },
+    timeComplexity: {
+        cpp: "O(n)",
+        java: "O(n)",
+        python: "O(n)",
+    },
+    spaceComplexity: {
+        cpp: "O(1)",
+        java: "O(1)",
+        python: "O(1)",
+    },
+    
   },
 
   shuffleString: {
@@ -2060,6 +2434,17 @@ class Solution:
           return ''.join(res)
       `,
     },
+    timeComplexity: {
+        cpp: "O(n)",
+        java: "O(n)",
+        python: "O(n)",
+    },
+    spaceComplexity: {
+        cpp: "O(n)",
+        java: "O(n)",
+        python: "O(n)",
+    },
+    
   },
 
   maxLevelSum: {
@@ -2166,6 +2551,17 @@ class Solution:
           return result_level
       `,
     },
+    timeComplexity: {
+        cpp: "O(n)",
+        java: "O(n)",
+        python: "O(n)",
+    },
+    spaceComplexity: {
+        cpp: "O(w)",
+        java: "O(w)",
+        python: "O(w)",
+    },
+    
   },
 
   firstAlphabet: {
@@ -2219,6 +2615,16 @@ class Solution:
           return result
       `,
     },
+    "timeComplexity": {
+        "cpp": "O(n)",
+        "java": "O(n)",
+        "python": "O(n)"
+    },
+    "spaceComplexity": {
+        "cpp": "O(w)",
+        "java": "O(w)",
+        "python": "O(w)"
+    }
   },
 
   countLeaves: {
@@ -2260,6 +2666,16 @@ class Solution:
           return self.countLeaves(root.left) + self.countLeaves(root.right)
       `,
     },
+    "timeComplexity": {
+        "cpp": "O(n)",
+        "java": "O(n)",
+        "python": "O(n)"
+    },
+    "spaceComplexity": {
+        "cpp": "O(h)",
+        "java": "O(h)",
+        "python": "O(h)"
+    }
   },
 
   generateBinaryNumbers: {
@@ -2320,6 +2736,16 @@ class Solution:
           return result
       `,
     },
+    "timeComplexity": {
+        "cpp": "O(N)",
+        "java": "O(N)",
+        "python": "O(N)"
+    },
+    "spaceComplexity": {
+        "cpp": "O(N)",
+        "java": "O(N)",
+        "python": "O(N)"
+    }
   },
 
   minimumDifference: {
@@ -2371,6 +2797,16 @@ class Solution:
           return minm
       `,
     },
+    "timeComplexity": {
+        "cpp": "O(n log n)",
+        "java": "O(n log n)",
+        "python": "O(n log n)"
+    },
+    "spaceComplexity": {
+        "cpp": "O(1)",
+        "java": "O(1)",
+        "python": "O(1)"
+    }
   },
 
   mthHalf: {
@@ -2403,6 +2839,16 @@ class Solution:
           return N // (2 ** (M - 1))
           `,
     },
+    "timeComplexity": {
+        "cpp": "O(1)",
+        "java": "O(1)",
+        "python": "O(1)"
+    },
+    "spaceComplexity": {
+        "cpp": "O(1)",
+        "java": "O(1)",
+        "python": "O(1)"
+    }
   },
 
   removeChars: {
@@ -2462,6 +2908,16 @@ class Solution:
           return ''.join(ans)
           `,
     },
+    "timeComplexity": {
+        "cpp": "O(m + n)",
+        "java": "O(m + n)",
+        "python": "O(m + n)"
+    },
+    "spaceComplexity": {
+        "cpp": "O(1)",
+        "java": "O(1)",
+        "python": "O(1)"
+    }
   },
 
   rotateArray: {
@@ -2526,6 +2982,16 @@ class Solution:
           return arr[d:] + arr[:d]
           `,
     },
+    "timeComplexity": {
+        "cpp": "O(n)",
+        "java": "O(n)",
+        "python": "O(n)"
+    },
+    "spaceComplexity": {
+        "cpp": "O(n)",
+        "java": "O(n)",
+        "python": "O(n)"
+    }
   },
 };
 
diff --git a/src/pages/blogs/index.tsx b/src/pages/blogs/index.tsx
index 1fddc52e4..353c22296 100644
--- a/src/pages/blogs/index.tsx
+++ b/src/pages/blogs/index.tsx
@@ -142,6 +142,105 @@ Conclusion:
 Graph theory provides a powerful framework for solving a wide variety of problems in computer science. By understanding basic concepts such as vertices, edges, graph types, and key algorithms like BFS, DFS, and Dijkstra’s algorithm, you can tackle problems related to networks, shortest paths, and efficient data organization. Whether it’s social media, navigation systems, or scheduling tasks, graphs play a crucial role in modeling and solving complex real-world scenarios.
       `,
     },
+    {
+      id: 4,
+      title: "Mastering Graph Algorithms",
+      tag: "Graphs",
+      summary: "These questions cover fundamental to advanced graph topics and are great for preparing for interviews where algorithm efficiency and optimization are key.",
+      content: `
+     Here are some top interview questions on graph algorithms that are frequently asked in tech interviews:
+
+ 1. Breadth-First Search (BFS) and Depth-First Search (DFS)
+    Example Question: "Implement BFS and DFS for a given graph. Explain the differences and use cases for each traversal method."
+    Follow-up: "How would you use BFS or DFS to detect cycles in a directed or undirected graph?"
+
+ 2. Cycle Detection in Graphs
+    Example Question: "Write an algorithm to detect cycles in a directed graph using DFS."
+    Follow-up: "How would you modify your algorithm to detect cycles in an undirected graph?"
+
+ 3. Shortest Path Algorithms
+    Example Question: "Find the shortest path in an unweighted graph using BFS."
+    Follow-up: "Implement Dijkstra’s Algorithm to find the shortest path in a weighted graph. How does it compare to Bellman-Ford for graphs with negative weights?"
+
+ 4. Topological Sorting
+    Example Question: "Implement topological sorting for a Directed Acyclic Graph (DAG). Why is topological sorting important in scheduling problems?"
+    Follow up: "How would you use topological sorting to detect cycles in a directed graph?"
+
+ 5. Connected Components in an Undirected Graph
+    Example Question: "Find all connected components in an undirected graph using DFS or BFS."
+    Follow up: "How would you modify this approach for a directed graph to find strongly connected components?"
+
+ 6. Strongly Connected Components (SCC)
+   Example Question: "Implement Kosaraju’s or Tarjan’s algorithm to find all strongly connected components in a directed graph."
+   Follow-up: "Discuss the applications of SCCs and why they’re important."
+
+ 7. Graph Coloring
+   Example Question: "Check if a given graph can be colored using 2 colors. Explain how BFS or DFS can be used to solve this problem."
+   Follow-up: "Extend your solution to handle k-colorable graphs. Discuss real-world applications of graph coloring."
+
+ 8. Minimum Spanning Tree (MST)
+    Example Question: "Implement Kruskal’s and Prim’s algorithms to find the Minimum Spanning Tree of a graph. Discuss the differences between the two algorithms."
+    Followup: "Explain how MST algorithms are used in network design and optimization problems."
+
+ 9. Network Flow and Ford-Fulkerson Algorithm
+    Example Question: "Explain the FordFulkerson algorithm for finding the maximum flow in a flow network."
+    Followup: "What are some practical applications of network flow algorithms?"
+
+ 10. Union-Find (Disjoint Set) for Graph Problems
+    Example Question: "Use the Union-Find algorithm to detect cycles in an undirected graph."
+    Follow-up: "Explain how Union-Find can be optimized with path compression and union by rank."
+
+ 11. Cheapest Path with K Stops (Modified Dijkstra)
+    Example Question: "Given a weighted, directed graph, find the cheapest path between two nodes with at most K stops. Explain how you’d modify Dijkstra’s algorithm for this."
+    Follow-up: "What are some optimizations you could apply to improve performance?"
+
+ 12. Finding Bridges and Articulation Points
+    Example Question: "Explain and implement an algorithm to find all bridges in an undirected graph."
+    Follow-up: "How would you identify articulation points in a graph, and what are their applications?"
+
+  Conclusion:
+These questions cover fundamental to advanced graph topics and are great for preparing for interviews where algorithm efficiency and optimization are key.
+Graph theory provides a powerful framework for solving a wide variety of problems in computer science. By understanding basic concepts such as vertices, edges, graph types, and key algorithms like BFS, DFS, and Dijkstra’s algorithm, you can tackle problems related to networks, shortest paths, and efficient data organization. Whether it’s social media, navigation systems, or scheduling tasks, graphs play a crucial role in modeling and solving complex real-world scenarios.
+      `
+      ,
+    },
+    {
+      id: 5,
+      title: "Top 5 Game theory Algorithms",
+      tag: "Algorithms",
+      summary: "Game theory algorithms optimize strategic decisions in competitive scenarios, enabling smarter AI, economic models, and real-world applications..",
+      content: `
+     Game theory algorithms focus on finding optimal strategies in situations where multiple agents (players) interact, with each player's choices potentially affecting the outcomes for others. Here’s a rundown of some of the most interesting and impactful algorithms in game theory:
+
+1. Minimax Algorithm
+Overview: The Minimax algorithm is used to find optimal moves in competitive, two-player, zero-sum games (like Tic-Tac-Toe, Chess, or Connect Four) where one player's gain is the other's loss.
+How It Works: Minimax considers all possible moves, assigning a score based on the outcome, and then picks the move that maximizes the player’s minimum payoff (or, equivalently, minimizes the opponent’s maximum gain).
+Applications: Common in AI for turn-based games. Often enhanced with alpha-beta pruning to reduce the number of nodes evaluated in the decision tree.
+
+2. Nash Equilibrium
+Overview: Named after mathematician John Nash, a Nash Equilibrium is a set of strategies where no player benefits from changing their strategy unilaterally. It’s used in scenarios where players choose strategies simultaneously, and each player’s optimal decision depends on the others’ choices.
+How It Works: Algorithms like Lemke-Howson or Support Enumeration are used to find Nash Equilibria in games with two or more players. Nash Equilibrium can be pure or mixed (where players randomize over multiple strategies).
+Applications: Economics, online bidding, and auctions, where agents aim for strategies that stabilize based on others’ choices.
+
+3. Monte Carlo Tree Search (MCTS)
+Overview: A heuristic search algorithm used to make decisions by random simulations. MCTS builds a search tree iteratively by simulating the game from a node, choosing moves based on possible outcomes.
+How It Works: MCTS expands the most promising nodes, simulates random playouts to the end of the game, and backpropagates the results to adjust the values of nodes.
+Applications: Game AI for complex games like Go, where the branching factor is too large for traditional Minimax. Notably, MCTS was a core technique behind AlphaGo.
+
+4. Alpha-Beta Pruning
+Overview: An optimization for the Minimax algorithm, Alpha-Beta Pruning reduces the number of nodes that need to be evaluated by cutting off branches that can’t influence the final decision.
+How It Works: As the Minimax algorithm explores game states, it keeps track of two values—alpha (best already found for the maximizer) and beta (best already found for the minimizer). If a branch cannot provide a better outcome, it’s pruned.
+Applications: Used to enhance performance in games like Chess and Checkers by limiting unnecessary exploration.
+
+5. Bayesian Nash Equilibrium
+Overview: This algorithm handles situations where players have incomplete information about other players (e.g., each player’s exact payoffs are unknown but distributed according to a known probability).
+How It Works: Players have beliefs about the types of other players and maximize their expected payoffs based on these beliefs. A Bayesian Nash Equilibrium is achieved when no player can increase their expected payoff by unilaterally deviating.
+Applications: Economics, auctions, and situations where uncertainty and information asymmetry play a critical role.
+
+Conclusion:
+ By leveraging game theory algorithms, we can create systems that adapt and optimize strategies based on interactions, paving the way for advancements in AI, economics, and real-world applications where strategic decision-making is key.
+  `,
+    },
     // Add more blog posts here
   ];
 
@@ -151,7 +250,7 @@ Graph theory provides a powerful framework for solving a wide variety of problem
     return matchesTag && matchesSearch;
   });
 
-  const tags = ["All", "Theory", "Sorting", "Graphs"];
+  const tags = ["All", "Theory", "Sorting", "Graphs","Algorithms"];
 
   const handleReadMore = (content: string) => {
     setModalContent(content);
diff --git a/src/pages/dsa-interview/index.tsx b/src/pages/dsa-interview/index.tsx
index 7637a1f88..ac3d54a11 100644
--- a/src/pages/dsa-interview/index.tsx
+++ b/src/pages/dsa-interview/index.tsx
@@ -1,8 +1,8 @@
 import React, { useState } from "react";
 import { motion, AnimatePresence } from "framer-motion";
 import Layout from "@theme/Layout";
-import Tabs from "@theme/Tabs"; // Import Tabs component
-import TabItem from "@theme/TabItem"; // Import TabItem component
+import Tabs from "@theme/Tabs";
+import TabItem from "@theme/TabItem";
 import problemsData from "../../data/problemData";
 
 const DSAQuestions: React.FC = () => {
@@ -127,6 +127,17 @@ const DSAQuestions: React.FC = () => {
                             <pre className="whitespace-pre-wrap bg-gray-200 dark:bg-gray-800 p-3 rounded-md text-sm font-mono mt-2 overflow-auto">
                               {problemsData[key].solution.cpp}
                             </pre>
+                            {/* Time and Space Complexity */}
+                            {problemsData[key].timeComplexity?.cpp && (
+                              <div className="mt-2 text-gray-700 dark:text-gray-300">
+                                <p><strong>Time Complexity:</strong> {problemsData[key].timeComplexity.cpp}</p>
+                              </div>
+                            )}
+                            {problemsData[key].spaceComplexity?.cpp && (
+                              <div className="mt-2 text-gray-700 dark:text-gray-300">
+                                <p><strong>Space Complexity:</strong> {problemsData[key].spaceComplexity.cpp}</p>
+                              </div>
+                            )}
                           </div>
                         </TabItem>
                         <TabItem value="java" label="Java">
@@ -149,6 +160,17 @@ const DSAQuestions: React.FC = () => {
                             <pre className="whitespace-pre-wrap bg-gray-200 dark:bg-gray-800 p-3 rounded-md text-sm font-mono mt-2 overflow-auto">
                               {problemsData[key].solution.java}
                             </pre>
+                            {/* Time and Space Complexity */}
+                            {problemsData[key].timeComplexity?.java && (
+                              <div className="mt-2 text-gray-700 dark:text-gray-300">
+                                <p><strong>Time Complexity:</strong> {problemsData[key].timeComplexity.java}</p>
+                              </div>
+                            )}
+                            {problemsData[key].spaceComplexity?.java && (
+                              <div className="mt-2 text-gray-700 dark:text-gray-300">
+                                <p><strong>Space Complexity:</strong> {problemsData[key].spaceComplexity.java}</p>
+                              </div>
+                            )}
                           </div>
                         </TabItem>
                         <TabItem value="python" label="Python">
@@ -171,6 +193,17 @@ const DSAQuestions: React.FC = () => {
                             <pre className="whitespace-pre-wrap bg-gray-200 dark:bg-gray-800 p-3 rounded-md text-sm font-mono mt-2 overflow-auto">
                               {problemsData[key].solution.python}
                             </pre>
+                            {/* Time and Space Complexity */}
+                            {problemsData[key].timeComplexity?.python && (
+                              <div className="mt-2 text-gray-700 dark:text-gray-300">
+                                <p><strong>Time Complexity:</strong> {problemsData[key].timeComplexity.python}</p>
+                              </div>
+                            )}
+                            {problemsData[key].spaceComplexity?.python && (
+                              <div className="mt-2 text-gray-700 dark:text-gray-300">
+                                <p><strong>Space Complexity:</strong> {problemsData[key].spaceComplexity.python}</p>
+                              </div>
+                            )}
                           </div>
                         </TabItem>
                       </Tabs>