Course · beginner$4.49 (≈ ₹550) · lifetime
DSA in Java, visualized
Data structures and algorithms you actually see run - line by line, in Java.
Taught by Faisal Ahmad · Founder, Flame
The complete DSA course, taught the Flame way: every algorithm runs on screen in Java, one step at a time, so you watch the variables move and feel why one approach is fast and another crawls. From Big-O to graphs and dynamic programming, built for interviews and for actually understanding. Chapter 1 is free; unlock the rest once.
13 modules38 lessons ~14h total
What you'll be able to do
- Read any algorithm's Big-O cost on sight, and pick the faster approach
- Implement the core data structures in Java from scratch, not from memory
- Recognise the pattern behind an interview problem and reach for the right tool
- Debug your own code by watching exactly what it does, step by step
Syllabus
Module 1
Big-O and how to think about cost
- 01What 'fast' really meansSpeed isn't about a fast laptop. It's about how much WORK your code does. Learn to count the work - and watch a search do it, one step at a time.16 min
- 02When loops nest: O(n squared)Put a loop inside a loop and the work explodes. See why comparing every item to every other item gets slow shockingly fast - and watch it happen.18 min
- 03Cutting the work in half: O(log n)The opposite of slow. When you can throw away half the remaining data every step, a million items takes about twenty steps. Watch binary search do it.18 min
Module 2
Arrays and the patterns they unlock
- 04Arrays under the hoodWhy reading arr[500] is instant but inserting in the middle is slow. The one idea - contiguous memory - that explains an array's every strength and weakness.16 min
- 05The two-pointer techniqueOne of the highest-value tricks in all of DSA: walk two indices toward each other and collapse an O(n squared) problem into a single O(n) pass. Watch it reverse an array.18 min
- 06The sliding windowStop recomputing from scratch. Keep a running answer over a moving range and update it in O(1) as it slides - turning an O(n*k) scan into O(n). Watch the window move.18 min
- 07Strings are arrays tooA String is a row of characters wearing a suit - indexable like an array, but immutable. Learn charAt, why building strings in a loop bites, and watch two pointers prove 'racecar' is a palindrome.20 min
Module 3
Recursion and the call stack
New- 08Thinking recursivelyA function that calls itself sounds like a trick. It's actually the most natural way to solve a whole family of problems - once you learn to trust the smaller call. Watch factorial build a tower of calls and unwind it.22 min
- 09Reading the call stack: fib and the exploding treeOne extra self-call changes everything. Fibonacci makes TWO recursive calls - and the work explodes exponentially. Watch 15 calls bloom out of fib(5), learn to read any stack, and meet the fix.24 min
- 10Recursion in action: counting grid pathsYour first real interview problem solved recursively, end to end: how many ways can a robot walk a grid? One clean insight, seven lines of Java, 118 steps of execution to watch - and the full method for solving problems you've never seen.24 min
- 11BacktrackingTrying, failing, and undoing - the recursive pattern behind permutations and puzzles.24 min
Module 4
Sorting
New- 12Bubble and insertion sortThe O(n squared) sorts, watched - simple, slow, and a perfect warm-up.22 min
- 13Merge sortDivide, sort halves, merge - the O(n log n) workhorse, animated end to end.24 min
- 14Quick sortPartitioning around a pivot, the average O(n log n), and the worst case to avoid.24 min
- 15Which sort, whenStability, memory, and why your language's built-in sort makes its choices.20 min
Module 5
Searching and hashing
New- 16Binary search, properlyOff-by-one traps, and searching on the answer instead of the array.24 min
- 17Hash maps from scratchBuckets, collisions, and how a good hash turns O(n) lookups into O(1).24 min
- 18Solving with hashingCounting, de-duplicating, and the 'seen before?' pattern that kills nested loops.22 min
Module 6
Linked lists
NewModule 7
Stacks and queues
NewModule 8
Trees
NewModule 9
Heaps and priority queues
NewModule 10
Graphs
New- 28Representing graphsAdjacency lists vs matrices, and the shape of almost every hard problem.22 min
- 29BFS and DFSThe two ways to explore a graph, animated - and when each one wins.24 min
- 30Shortest pathsDijkstra's algorithm, watched as the frontier expands out from the source.24 min
- 31Graph problem patternsConnected components, cycle detection, and topological order.22 min
Module 11
Greedy algorithms
NewModule 12
Dynamic programming
NewStart Chapter 1 free
The first chapter is yours to watch, in full, at no cost. Chapters release over time; one $4.49 (≈ ₹550) lifetime payment unlocks every chapter after it - including the ones still being written. No subscription.
Start free