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 ~12h 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.18 min soon
Module 4
Sorting
- 12Bubble and insertion sortThe O(n squared) sorts, watched - simple, slow, and a perfect warm-up.18 min soon
- 13Merge sortDivide, sort halves, merge - the O(n log n) workhorse, animated end to end.18 min soon
- 14Quick sortPartitioning around a pivot, the average O(n log n), and the worst case to avoid.18 min soon
- 15Which sort, whenStability, memory, and why your language's built-in sort makes its choices.18 min soon
Module 5
Searching and hashing
- 16Binary search, properlyOff-by-one traps, and searching on the answer instead of the array.18 min soon
- 17Hash maps from scratchBuckets, collisions, and how a good hash turns O(n) lookups into O(1).18 min soon
- 18Solving with hashingCounting, de-duplicating, and the 'seen before?' pattern that kills nested loops.18 min soon
Module 6
Linked lists
- 19Building a linked listNodes and pointers, and the O(1) insert that arrays can't match.18 min soon
- 20Reversing and detecting cyclesPointer surgery and Floyd's tortoise-and-hare, step by step.18 min soon
Module 7
Stacks and queues
- 21StacksLast in, first out - matching brackets, undo, and the call stack you've been watching.18 min soon
- 22Queues and dequesFirst in, first out, and the double-ended queue behind sliding-window maxima.18 min soon
Module 8
Trees
- 23Trees and traversalParents, children, and the three ways to walk a tree - drawn as it happens.18 min soon
- 24Binary search treesOrdered trees, O(log n) lookups, and the balance problem.18 min soon
- 25Common tree problemsHeight, diameter, and lowest common ancestor, solved with clean recursion.18 min soon
Module 9
Heaps and priority queues
- 26The heapA tree in an array that always knows its smallest element - in O(log n).18 min soon
- 27Top-K and streamingUsing a heap to answer 'the k best' without sorting everything.18 min soon
Module 10
Graphs
- 28Representing graphsAdjacency lists vs matrices, and the shape of almost every hard problem.18 min soon
- 29BFS and DFSThe two ways to explore a graph, animated - and when each one wins.18 min soon
- 30Shortest pathsDijkstra's algorithm, watched as the frontier expands out from the source.18 min soon
- 31Graph problem patternsConnected components, cycle detection, and topological order.18 min soon
Module 11
Greedy algorithms
- 32The greedy ideaTaking the locally best step - when it works, and the trap when it doesn't.18 min soon
- 33Classic greedy problemsInterval scheduling and coin change, with the proof of why greedy is safe.18 min soon
Module 12
Dynamic programming
- 34What DP really isOverlapping subproblems and memoization - recursion that stops repeating itself.18 min soon
- 35Bottom-up tablesFilling a grid instead of recursing, watched cell by cell.18 min soon
- 36The DP patternsKnapsack, longest common subsequence, and how to spot a DP in the wild.18 min soon
Module 13
Putting it together
- 37Cracking the interviewTurning a vague question into a plan: clarify, brute-force, optimise, test.18 min soon
- 38Mixed problem gauntletA final set that mixes every tool - and the animation to prove your solution.18 min soon
Start 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