DSA Trainer

The curated path

Everything a CS degree teaches about DSA, without the overwhelm

One concept at a time, start to finish: learn it, drill it, pass the test, then solve real problems with the guidance fading step by step, until you can spot the pattern in a problem you have never seen. Learn any concept for free. Practice and testing unlock with premium.

New here? Start at the beginning.

The path is ordered. Begin with Big-O Notation and work straight down, one module at a time.

Start →

You’re not signed in. Your progress here won’t be saved.

1

Big-O Notation

Given a short piece of code, state its time complexity and explain why, out loud, without guessing.

3 steps
2

Hash Maps

Spot when a problem needs lookup by key, and explain why a hash map turns an O(n) search into an O(1) lookup.

12 steps
3

Two Pointers

Spot when two indices walking an array can replace a nested loop, and tell whether they move toward each other or in the same direction.

12 steps
4

Sliding Window

Recognize a contiguous-subarray problem and maintain a window that grows and shrinks in one pass, instead of re-checking every subarray.

11 steps
5

Prefix Sum

Precompute cumulative sums so any range total is O(1), and combine prefix sums with a hash map to count subarrays.

9 steps
6

Recursion

Read and write a simple recursive function by naming its base case and recursive case, and trace how the call stack unwinds.

12 steps
7

Binary Search

Explain why binary search needs sorted input, how halving gives O(log n), and the off-by-one traps that break it.

12 steps
8

Linked Lists

Explain how nodes and pointers form a list, why reaching an element is O(n) but inserting at a known spot is O(1), and when to pick one over an array.

12 steps
9

Stacks and Queues

Describe LIFO and FIFO ordering, the core operations of each, and recognize which problems call for a stack versus a queue.

12 steps
10

Trees and Binary Search Trees

Describe a binary tree, the BST ordering property, what in-order traversal yields, and why a balanced BST searches in O(log n) while an unbalanced one degrades to O(n).

12 steps
11

Heaps and Priority Queues

Explain why a heap gives O(1) access to the min or max with O(log n) inserts and removals, why it is not fully sorted, and when to reach for one.

12 steps
12

Union-Find

Maintain groups under merges and answer 'are these two connected?' in near-constant time, and tell when union-find beats a fresh BFS or DFS.

9 steps
13

Graphs (BFS and DFS)

Describe nodes and edges, pick between an adjacency list and matrix, and choose BFS or DFS based on what the problem needs.

12 steps
14

Greedy

Decide when taking the locally-best choice at each step is provably safe, and recognize when it isn't and you need dynamic programming instead.

10 steps
15

Sorting

Explain why naive sorts are O(n^2), the divide-and-conquer idea that gets merge sort to O(n log n), and what sorted data unlocks.

12 steps
16

Dynamic Programming

Recognize overlapping subproblems, use memoization to compute each subproblem once, and tell when a problem is a DP candidate.

12 steps
17

Bit Manipulation

Use the bitwise operators (especially XOR) to solve specific structured problems in O(1) space, and recognize when bits are the wrong tool.

11 steps
Big-O Notation and Hash Maps are fully free — 2 complete modules, 3 real coding problems, the whole loop. Practice and testing on the rest unlock with premium.