Top 8 DSA Project Ideas in 2024 [With Source Code]

Are you an aspiring software engineer or computer science student looking to sharpen your data structures and algorithms (DSA) skills in 2024? One of the best ways to do that is by working on hands-on DSA projects. Not only will these projects help solidify your understanding of key concepts, but they also make great additions to your portfolio to showcase to potential employers.

In this blog post, we’ve curated a list of the top 8 DSA project ideas for 2024, complete with source code to get you started. These projects cover a range of difficulty levels and real-world applications, from basic data structures to more advanced algorithms.

So let’s dive in and explore these exciting DSA project ideas that will help take your skills to the next level!

1. Implement a Custom Hash Table

Project Idea: Build your own hash table implementation from scratch. Hash tables are an essential data structure that enable fast insertion, deletion, and lookup of key-value pairs. By creating your own, you’ll gain a deeper understanding of how they work under the hood.

Key Features:

• Support insertion, deletion, and lookup operations
• Handle collisions using a technique like separate chaining or open addressing
• Dynamically resize the hash table when the load factor exceeds a certain threshold
• Provide a clean and intuitive API for users of the hash table

Difficulty Level: Beginner to Intermediate

Real-World Application: Hash tables are used in many real-world systems, such as:

• Database indexes for fast data retrieval
• Caches to speed up data access (e.g. web browser caches, CPU caches)
• Uniqueness checks (e.g. tracking visited URLs, finding duplicate entries)

Source Code:

Here’s a simple hash table implementation in Python to get you started:

class HashTable:
    def __init__(self, size):
        self.size = size
        self.buckets = [[] for _ in range(size)]

    def _hash_function(self, key):
        return hash(key) % self.size

    def insert(self, key, value):
        hash_key = self._hash_function(key)
        bucket = self.buckets[hash_key]
        for i, (k, v) in enumerate(bucket):
            if k == key:
                bucket[i] = (key, value)
                return
        bucket.append((key, value))

    def get(self, key):
        hash_key = self._hash_function(key)
        bucket = self.buckets[hash_key]
        for k, v in bucket:
            if k == key:
                return v
        raise KeyError(key)

    def delete(self, key):
        hash_key = self._hash_function(key)
        bucket = self.buckets[hash_key]
        for i, (k, v) in enumerate(bucket):
            if k == key:
                del bucket[i]
                return
        raise KeyError(key)

This basic implementation uses separate chaining to handle collisions, where each bucket is a list of key-value pairs. The _hash_function method computes the index of the bucket for a given key using the built-in hash function and modulo operator.

To use this hash table, you can create an instance and perform insertions, lookups, and deletions:

ht = HashTable(size=10)<br>ht.insert("apple", 5)<br>ht.insert("banana", 10)<br>print(ht.get("apple"))  # Output: 5<br>ht.delete("banana")<br>print(ht.get("banana"))  # Raises KeyError

Enhancements:

• Implement dynamic resizing to grow the hash table when the load factor exceeds a threshold
• Experiment with different collision resolution techniques (e.g. linear probing, quadratic probing)
• Add support for more data types as keys (e.g. integers, tuples)
• Implement an iterator to allow looping over the key-value pairs in the hash table

2. Create a Trie Data Structure

Project Idea: Implement a trie (prefix tree) data structure that efficiently stores and retrieves strings. Tries are commonly used for tasks involving string searches and prefix matching.

Key Features:

• Insert strings into the trie
• Search for exact string matches
• Perform prefix searches to find all strings with a given prefix
• Delete strings from the trie
• Implement efficient traversal and visualization of the trie structure

Difficulty Level: Beginner to Intermediate

Real-World Application: Tries have various applications, including:

• Autocomplete and search suggestions (e.g. search engines, IDEs)
• Spell checkers and dictionary implementations
• IP routing tables
• Solving word games (e.g. Scrabble, Boggle)

Source Code:

Here’s a basic trie implementation in Python:

class TrieNode:
    def __init__(self):
        self.children = {}
        self.is_end_of_word = False

class Trie:
    def __init__(self):
        self.root = TrieNode()

    def insert(self, word):
        node = self.root
        for char in word:
            if char not in node.children:
                node.children[char] = TrieNode()
            node = node.children[char]
        node.is_end_of_word = True

    def search(self, word):
        node = self.root
        for char in word:
            if char not in node.children:
                return False
            node = node.children[char]
        return node.is_end_of_word

    def starts_with(self, prefix):
        node = self.root
        for char in prefix:
            if char not in node.children:
                return False
            node = node.children[char]
        return True

In this implementation, each TrieNode represents a node in the trie, with a dictionary children to store its child nodes and a boolean is_end_of_word to mark the end of a word.

The Trie class provides methods to insert words, search for exact matches, and check for prefix matches:

trie = Trie()
trie.insert("apple")
trie.insert("app")
print(trie.search("apple"))  # Output: True
print(trie.search("app"))    # Output: True
print(trie.search("banana")) # Output: False
print(trie.starts_with("ap"))  # Output: True
print(trie.starts_with("ba"))  # Output: False

Enhancements:

• Implement a method to delete words from the trie
• Add support for wildcard or regex searches
• Implement auto-completion functionality
• Optimize the trie by compressing common prefixes
• Visualize the trie structure for easier understanding and debugging

3. Build a Least Recently Used (LRU) Cache

Project Idea: Create an efficient cache implementation using the Least Recently Used (LRU) eviction policy. An LRU cache discards the least recently used items when the cache reaches its capacity.

Key Features:

• Support a fixed cache capacity
• Provide methods to insert key-value pairs into the cache
• Retrieve values from the cache by key
• Automatically evict the least recently used item when the cache is full
• Optimize for fast insertion, retrieval, and eviction operations

Difficulty Level: Intermediate

Real-World Application: LRU caches are widely used for caching and optimizing performance in various systems, such as:

• Web browsers for caching web pages and resources
• Operating systems for caching disk pages in memory
• Database systems for caching query results
• Content Delivery Networks (CDNs) for caching frequently accessed content

Source Code:

Here’s an implementation of an LRU cache in Python using a dictionary and a doubly linked list:

class Node:
    def __init__(self, key=None, value=None):
        self.key = key
        self.value = value
        self.prev = None
        self.next = None

class LRUCache:
    def __init__(self, capacity):
        self.capacity = capacity
        self.cache = {}
        self.head = Node()
        self.tail = Node()
        self.head.next = self.tail
        self.tail.prev = self.head

    def get(self, key):
        if key in self.cache:
            node = self.cache[key]
            self._remove(node)
            self._add(node)
            return node.value
        return None

    def put(self, key, value):
        if key in self.cache:
            self._remove(self.cache[key])
        node = Node(key, value)
        self._add(node)
        self.cache[key] = node
        if len(self.cache) > self.capacity:
            lru_node = self.head.next
            self._remove(lru_node)
            del self.cache[lru_node.key]

    def _remove(self, node):
        node.prev.next = node.next
        node.next.prev = node.prev

    def _add(self, node):
        node.prev = self.tail.prev
        node.next = self.tail
        self.tail.prev.next = node
        self.tail.prev = node

The Node class represents a node in the doubly linked list, storing a key-value pair and references to the previous and next nodes.

The LRUCache class maintains a dictionary cache to map keys to nodes and uses a doubly linked list to keep track of the order of nodes. The head and tail dummy nodes simplify the insertion and removal operations.

The get method retrieves the value associated with a key. If the key exists, it moves the corresponding node to the tail (most recently used) and returns the value. Otherwise, it returns None.

The put method inserts a key-value pair into the cache. If the key already exists, it removes the existing node. It creates a new node, adds it to the tail, and updates the cache dictionary. If the cache exceeds the capacity, it removes the least recently used node (head.next) and deletes it from the dictionary.

The _remove and _add helper methods handle the removal and insertion of nodes in the doubly linked list.

Usage example:

cache = LRUCache(capacity=3)
cache.put(1, "One")
cache.put(2, "Two")
cache.put(3, "Three")
print(cache.get(1))  # Output: "One"
cache.put(4, "Four")
print(cache.get(2))  # Output: None (evicted)
print(cache.get(3))  # Output: "Three"
print(cache.get(4))  # Output: "Four"

Enhancements:

• Implement thread safety for concurrent access to the cache
• Add support for time-based eviction (e.g. expiring items after a certain time)
• Implement cache statistics (e.g. hit ratio, miss ratio, total accesses)
• Consider using a more efficient data structure for the eviction policy (e.g. min-heap)

4. Implement a Graph Traversal Algorithm

Project Idea: Choose a graph traversal algorithm (e.g. BFS, DFS) and implement it from scratch. Graph traversal algorithms are fundamental for exploring and analyzing graph structures.

Key Features:

• Implement the chosen graph traversal algorithm (BFS or DFS)
• Support both directed and undirected graphs
• Allow input of graphs in various formats (e.g. adjacency list, adjacency matrix)
• Provide options for starting the traversal from a specific node or traversing the entire graph
• Return the traversal order or perform specific actions during the traversal

Difficulty Level: Beginner to Intermediate

Real-World Application: Graph traversal algorithms have numerous applications, such as:

• Path finding and shortest path algorithms (e.g. GPS navigation, network routing)
• Web crawling and indexing by search engines
• Social network analysis (e.g. friend recommendations, influence propagation)
• Topological sorting of dependencies (e.g. build systems, task scheduling)

Source Code:

Here’s an implementation of Breadth-First Search (BFS) in Python using an adjacency list representation of a graph:

from collections import deque

def bfs(graph, start):
    visited = set()
    queue = deque([start])
    visited.add(start)
    while queue:
        node = queue.popleft()
        print(node, end=" ")
        for neighbor in graph[node]:
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append(neighbor)

# Example usage
graph = {
    'A': ['B', 'C'],
    'B': ['A', 'D', 'E'],
    'C': ['A', 'F'],
    'D': ['B'],
    'E': ['B', 'F'],
    'F': ['C', 'E']
}

print("BFS traversal:")
bfs(graph, 'A')  # Output: A B C D E F

he bfs function takes the graph (represented as an adjacency list) and the starting node as input. It initializes a set visited to keep track of visited nodes, a queue queue to store the nodes to be visited, and marks the starting node as visited.

The function enters a loop that continues until the queue is empty. In each iteration, it removes the front node from the queue, prints it, and adds its unvisited neighbors to the queue and the visited set.

The time complexity of BFS is O(V + E), where V is the number of vertices (nodes) and E is the number of edges in the graph. The space complexity is O(V) to store the visited set and the queue.

Here’s an implementation of Depth-First Search (DFS) using recursion:

def dfs(graph, node, visited=None):
    if visited is None:
        visited = set()
    visited.add(node)
    print(node, end=" ")
    for neighbor in graph[node]:
        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']
}

print("DFS traversal:")
dfs(graph, 'A')  # Output: A B D E F C

The dfs function takes the graph, the current node, and an optional visited set as input. It marks the current node as visited, prints it, and recursively calls dfs on each unvisited neighbor.

The time complexity of DFS is also O(V + E), and the space complexity is O(V) for the visited set and the recursion stack.

Enhancements:

• Implement iterative versions of BFS and DFS
• Add support for weighted graphs and modify the traversal algorithms accordingly
• Implement additional graph algorithms (e.g. Dijkstra’s shortest path, Prim’s minimum spanning tree)
• Visualize the graph and the traversal process for better understanding

5. Create a Text Compression Algorithm

Project Idea: Implement a text compression algorithm, such as Huffman coding or Lempel-Ziv-Welch (LZW), to efficiently compress and decompress text data.

Key Features:

• Implement the chosen text compression algorithm (Huffman coding or LZW)
• Compress input text into a compact representation
• Decompress the compressed data back into the original text
• Analyze the compression ratio and efficiency of the algorithm
• Handle various types of text data (e.g. plain text, source code, structured data)

Difficulty Level: Intermediate to Advanced

Real-World Application: Text compression algorithms are widely used to reduce the size of data for storage and transmission, such as:

• File compression utilities (e.g. zip, gzip)
• Network protocols (e.g. HTTP compression)
• Database compression for efficient storage
• Data archival and backup systems

Source Code:

Here’s an implementation of Huffman coding in Python:

def build_frequency_dict(text):
   freq_dict = {}
   for char in text:
       if char in freq_dict:
           freq_dict[char] += 1
       else:
           freq_dict[char] = 1
   return freq_dict

def build_huffman_tree(freq_dict):
   heap = [[weight, [char, ""]] for char, weight in freq_dict.items()]
   heapq.heapify(heap)
   while len(heap) > 1:
       lo = heapq.heappop(heap)
       hi = heapq.heappop(heap)
       for pair in lo[1:]:
           pair[1] = '0' + pair[1]
       for pair in hi[1:]:
           pair[1] = '1' + pair[1]
       heapq.heappush(heap, [lo[0] + hi[0]] + lo[1:] + hi[1:])
   return heap[0]

def build_huffman_dict(huffman_tree):
   huffman_dict = {}
   for pair in huffman_tree[1:]:
       huffman_dict[pair[0]] = pair[1]
   return huffman_dict

def compress(text):
   freq_dict = build_frequency_dict(text)
   huffman_tree = build_huffman_tree(freq_dict)
   huffman_dict = build_huffman_dict(huffman_tree)
   
   compressed_text = "".join([huffman_dict[char] for char in text])
   return compressed_text, huffman_tree

def decompress(compressed_text, huffman_tree):
   huffman_dict = build_huffman_dict(huffman_tree)
   inv_huffman_dict = {v: k for k, v in huffman_dict.items()}
   
   decompressed_text = ""
   current_code = ""
   for bit in compressed_text:
       current_code += bit
       if current_code in inv_huffman_dict:
           decompressed_text += inv_huffman_dict[current_code]
           current_code = ""
   
   return decompressed_text

# Example usage
text = "This is an example text to be compressed using Huffman coding!"
print("Original text:", text)

compressed_text, huffman_tree = compress(text)
print("Compressed text:", compressed_text)

decompressed_text = decompress(compressed_text, huffman_tree)
print("Decompressed text:", decompressed_text)

This implementation of Huffman coding consists of several functions:

1. build_frequency_dict: This function takes the input text and builds a dictionary that maps each character to its frequency count in the text.
2. build_huffman_tree: This function takes the frequency dictionary and builds the Huffman tree. It creates a heap of nodes, where each node is a list containing the character’s frequency and a list of the character and its Huffman code. The function repeatedly pops the two nodes with the lowest frequencies from the heap, assigns ‘0’ to the left branch and ‘1’ to the right branch, and pushes the merged node back onto the heap until only one node remains, which represents the root of the Huffman tree.
3. build_huffman_dict: This function takes the Huffman tree and builds a dictionary that maps each character to its corresponding Huffman code.
4. compress: This function compresses the input text using Huffman coding. It builds the frequency dictionary, constructs the Huffman tree, and generates the Huffman codes for each character. It then encodes the text by replacing each character with its corresponding Huffman code.
5. decompress: This function decompresses the compressed text using the Huffman tree. It builds the Huffman dictionary and its inverse mapping. It then iterates over the compressed text, accumulating the bits until a valid Huffman code is found, and replaces the code with the corresponding character in the decompressed text.

The example usage demonstrates compressing a sample text using Huffman coding, printing the compressed text, and then decompressing it back to the original text.

Enhancements:

• Handle input texts with non-ASCII characters or binary data.
• Optimize the compression and decompression processes for better performance.
• Implement file I/O to read input text from a file and write the compressed data to a file.
• Compare the compression ratio and speed with other compression algorithms.
• Implement adaptive Huffman coding to handle dynamic changes in character frequencies.

Huffman coding is a popular and efficient lossless compression algorithm that assigns variable-length codes to characters based on their frequencies. It achieves good compression ratios, especially for texts with skewed character distributions. However, it requires the Huffman tree or code dictionary to be transmitted along with the compressed data for decompression.

7. Implement a Minimum Spanning Tree Algorithm

Project Idea: Implement a minimum spanning tree algorithm, such as Kruskal’s algorithm or Prim’s algorithm, to find the minimum spanning tree of a weighted graph.

Key Features:

• Implement the chosen minimum spanning tree algorithm (Kruskal’s or Prim’s)
• Take a weighted graph as input, represented using an appropriate data structure
• Find the minimum spanning tree of the graph
• Handle disconnected graphs and return the minimum spanning forest
• Analyze the time complexity and compare it with other minimum spanning tree algorithms
• Visualize the input graph and the resulting minimum spanning tree

Difficulty Level: Intermediate to Advanced

Real-World Application: Minimum spanning tree algorithms have various applications in network design and optimization problems, such as:

• Designing efficient communication networks with minimum total connection cost
• Planning efficient road or pipeline networks connecting multiple locations
• Clustering algorithms for data analysis and pattern recognition
• Image segmentation and object recognition in computer vision

Source Code:

Here’s an implementation of Prim’s algorithm for finding the minimum spanning tree in Python:

import heapq

def prim_mst(graph, start_vertex):
    mst = []
    visited = set([start_vertex])
    edges = [(cost, start_vertex, to) for to, cost in graph[start_vertex].items()]
    heapq.heapify(edges)
    
    while edges:
        cost, frm, to = heapq.heappop(edges)
        if to not in visited:
            visited.add(to)
            mst.append((frm, to, cost))
            for to_next, cost in graph[to].items():
                if to_next not in visited:
                    heapq.heappush(edges, (cost, to, to_next))
    
    return mst

# Example usage
graph = {
    'A': {'B': 2, 'C': 3},
    'B': {'A': 2, 'C': 1, 'D': 1, 'E': 4},
    'C': {'A': 3, 'B': 1, 'F': 5},
    'D': {'B': 1, 'E': 1},
    'E': {'B': 4, 'D': 1, 'F': 1},
    'F': {'C': 5, 'E': 1}
}

start_vertex = 'A'
mst = prim_mst(graph, start_vertex)

print("Minimum Spanning Tree:")
for edge in mst:
    print(edge)

This implementation of Prim’s algorithm uses a heap to efficiently select the minimum-weight edge at each step. Here’s how it works:

1. The function prim_mst takes the graph (represented as an adjacency list) and the starting vertex as input.
2. It initializes an empty list mst to store the edges of the minimum spanning tree, a set visited to keep track of visited vertices, and a heap edges to store the edges adjacent to the visited vertices.
3. It starts with the given starting vertex, marks it as visited, and adds all its adjacent edges to the heap.
4. While there are edges in the heap, it pops the edge with the minimum weight. If the destination vertex of the edge is not yet visited, it adds the edge to the minimum spanning tree, marks the vertex as visited, and adds its adjacent edges to the heap.
5. The process continues until all vertices are visited or the heap is empty.
6. Finally, it returns the list of edges that form the minimum spanning tree.

The example usage demonstrates finding the minimum spanning tree of a given weighted graph starting from vertex ‘A’.

Prim’s algorithm has a time complexity of O((V + E) log V), where V is the number of vertices and E is the number of edges in the graph. It is efficient for dense graphs and guarantees a minimum spanning tree.

Enhancements:

• Implement Kruskal’s algorithm and compare its performance with Prim’s algorithm
• Handle graphs with negative edge weights and detect negative cycles
• Extend the implementation to find the minimum spanning forest for disconnected graphs
• Optimize the algorithm using a Fibonacci heap or other advanced data structures
• Visualize the minimum spanning tree using a graph visualization library

Minimum spanning tree algorithms have wide-ranging applications in network design, clustering, and optimization problems. They provide efficient solutions for finding the minimum-cost subgraph that connects all vertices in a weighted graph.

8. Implement a Trie Data Structure

Project Idea: Implement a trie (prefix tree) data structure that efficiently stores and retrieves strings. Tries are commonly used for tasks involving string searches and prefix matching.

Key Features:

• Implement the trie data structure with efficient insertion, search, and deletion operations
• Support prefix searching to find all strings with a given prefix
• Implement autocomplete functionality using the trie
• Efficiently count the number of strings with a given prefix
• Optimize the trie for space efficiency by compressing common prefixes
• Visualize the trie structure for better understanding and debugging

Difficulty Level: Intermediate

Real-World Application: Tries have various applications, including:

• Autocomplete and search suggestions (e.g., search engines, text editors)
• Spell checkers and dictionary implementations
• IP routing tables
• Solving word games (e.g., Scrabble, Boggle)
• Data compression techniques (e.g., Huffman coding)

Source Code:

Here’s an implementation of a trie data structure in Python:

class TrieNode:
    def __init__(self):
        self.children = {}
        self.is_end_word = False

class Trie:
    def __init__(self):
        self.root = TrieNode()

    def insert(self, word):
        node = self.root
        for char in word:
            if char not in node.children:
                node.children[char] = TrieNode()
            node = node.children[char]
        node.is_end_word = True

    def search(self, word):
        node = self.root
        for char in word:
            if char not in node.children:
                return False
            node = node.children[char]
        return node.is_end_word

    def starts_with(self, prefix):
        node = self.root
        for char in prefix:
            if char not in node.children:
                return False
            node = node.children[char]
        return True

    def autocomplete(self, prefix):
        node = self.root
        for char in prefix:
            if char not in node.children:
                return []
            node = node.children[char]
        return self._collect_words(node, prefix)

    def _collect_words(self, node, prefix):
        words = []
        if node.is_end_word:
            words.append(prefix)
        for char, child_node in node.children.items():
            words.extend(self._collect_words(child_node, prefix + char))
        return words

# Example usage
trie = Trie()
trie.insert("apple")
trie.insert("apple pie")
trie.insert("banana")
trie.insert("banana split")
trie.insert("grape")

print(trie.search("apple"))  # True
print(trie.search("grape"))  # True
print(trie.search("orange"))  # False

print(trie.starts_with("app"))  # True
print(trie.starts_with("ban"))  # True
print(trie.starts_with("ora"))  # False

print(trie.autocomplete("a"))  # ['apple', 'apple pie']
print(trie.autocomplete("b"))  # ['banana', 'banana split']
print(trie.autocomplete("g"))  # ['grape']

This implementation defines two classes: TrieNode and Trie. The TrieNode class represents a node in the trie, storing a dictionary of its children nodes and a boolean flag indicating if it represents the end of a word. The Trie class provides methods for inserting words, searching for words, checking prefixes, and performing autocomplete.

The insert method inserts a word into the trie by iterating over each character and creating or following the corresponding child nodes. The search method checks if a word exists in the trie by traversing the trie based on the characters of the word. The starts_with method checks if any word in the trie starts with the given prefix.

The autocomplete method finds all words that start with a given prefix by traversing the trie based on the prefix characters and then collecting all the words that can be formed from the last node reached. The _collect_words method is a helper function that recursively collects the words starting from a given node.

The example usage demonstrates inserting words into the trie, searching for words, checking prefixes, and performing autocomplete.

Enhancements:

• Implement deletion of words from the trie
• Optimize the space efficiency by compressing common prefixes
• Support wildcard or regex searches in the trie
• Implement additional methods like counting the number of words with a given prefix
• Visualize the trie structure using a graphical representation

Tries provide an efficient way to store and retrieve strings based on their prefixes. They offer fast insertion, search, and prefix matching operations, making them suitable for various string-related tasks. However, tries can consume significant memory, especially when storing a large number of strings with long common prefixes.

Conclusion

These DSA project ideas cover a wide range of topics, including data structures, algorithms, compression techniques, graph algorithms, and more. Each project presents an opportunity to deepen your understanding of fundamental concepts and apply them to real-world problems.

Remember, the provided source code serves as a starting point, and there is always room for improvement and optimization. Take the time to analyze the code, understand the underlying algorithms, and experiment with different approaches and enhancements.

As you work on these projects, challenge yourself to think critically about the problem at hand, consider edge cases, and strive for efficient and elegant solutions. Don’t hesitate to refer to additional resources, such as textbooks, online tutorials, and coding communities, to expand your knowledge and seek guidance when needed.

Documenting your thought process, design decisions, and lessons learned throughout the project can be valuable for your own reference and for sharing your work with others. Consider maintaining a project repository or blog to showcase your implementations, along with clear explanations and insights.

Collaborating with fellow developers and participating in code reviews can also provide valuable feedback and help you grow as a programmer. Embrace constructive criticism and use it as an opportunity to refine your skills and learn from others’ perspectives.

Remember, the field of DSA is vast, and there is always more to learn. These projects serve as a foundation for your DSA journey, but don’t stop here. Continue exploring advanced topics, such as dynamic programming, graph algorithms, and more complex data structures like persistent data structures and self-balancing trees.

As you progress in your DSA journey, keep practicing, coding, and challenging yourself with increasingly complex problems. Participate in coding competitions, work on open-source projects, and contribute to the developer community. The more you engage with DSA, the more confident and proficient you will become.

Best of luck with your DSA projects, and happy coding!