Skip to content
elevatedevco

Free mini-course · 30 parts

Data Structures & Algorithms: The Complete Course

A free, book-quality DSA course — Big-O, arrays, linked lists, trees, graphs, sorting, dynamic programming and more, with complexity tables, pseudocode and worked examples for every topic.

Self-paced and completely free — each lesson is a ~10-minute read and ends with one concrete exercise. All lessons are live. Part of the Learn AI & Data Science hub.

Start lesson 1

The lessons

  1. How to Think About Data Structures & Algorithms (A Beginner's Mental Model)DSA isn't memorization — it's a small set of trade-offs you learn to recognize. Here's the mental model that makes everything after this lesson easier.Available now — read lesson 1
  2. Big-O Notation Explained: Time & Space Complexity from ScratchO(n), O(log n), O(n²) — here's what the notation actually means, how to derive it for any piece of code, and the traps (amortized cost, hidden loops) that catch beginners.Available now — read lesson 2
  3. Arrays & Dynamic Arrays: How They Work, Complexity, and When to Use ThemArrays are the structure every other structure is built on. Here's how they live in memory, why indexing is instant, and how dynamic arrays pull off O(1) append.Available now — read lesson 3
  4. Strings & String Algorithms: Immutability, Building, Searching, and Classic PatternsStrings look simple and hide more interview traps than any other basic type. Immutability, O(n²) concatenation, substring search, anagrams — all covered here.Available now — read lesson 4
  5. Linked Lists Explained: Singly, Doubly & Circular — Operations, Complexity, PatternsNodes, pointers, and no contiguous memory: how linked lists work, why insertion is O(1) but access is O(n), and the pointer patterns every interviewer asks about.Available now — read lesson 5
  6. Stacks Explained: LIFO, Operations, and the Problems Stacks SolvePush, pop, peek — three O(1) operations that solve an outsized share of problems: matching brackets, undo systems, expression evaluation, and the monotonic stack pattern.Available now — read lesson 6
  7. Queues & Deques Explained: FIFO, Circular Buffers, and Sliding-Window MaximumFirst In, First Out: how queues actually get O(1) at both ends (the circular-buffer trick), what deques add, and the monotonic deque behind sliding-window maximum.Available now — read lesson 7
  8. Recursion & the Call Stack: How It Really Works, Base Cases, and ComplexityRecursion stops being magic the moment you see the call stack doing the bookkeeping. Frames, base cases, recursion trees, and the complexity rules — all here.Available now — read lesson 8
  9. Hashing & Hash Tables: How O(1) Lookup Really Works (Collisions, Load Factor, Resizing)The most-used data structure in modern programming: how a hash function turns keys into array indices, what happens when two keys collide, and why 'O(1)' comes with fine print.Available now — read lesson 9
  10. Trees & Binary Trees: Terminology, Traversals (In/Pre/Post/Level-Order), and RecursionHierarchy enters the course: tree anatomy, the four traversals every interview assumes you know cold, and why tree code is recursion's home turf.Available now — read lesson 10
  11. Binary Search Trees (BST): Search, Insert, Delete — and Why Order Changes EverythingOne rule — smaller keys left, larger keys right — turns a binary tree into a searchable, sorted, dynamic structure. Here's every operation, including the deletion case everyone fumbles.Available now — read lesson 11
  12. Balanced Trees: AVL & Red-Black Trees Explained by Intuition (Rotations, Not Rote)Plain BSTs collapse to O(n) on sorted input. Self-balancing trees fix that with one elegant move — the rotation — applied under two different philosophies: AVL's strictness and red-black's pragmatism.Available now — read lesson 12
  13. Heaps & Priority Queues: The Array-Backed Tree Behind 'Always Get the Smallest'Drop the full sorted order of a BST and keep only 'smallest on top', and the tree collapses into a plain array — the heap: O(1) peek, O(log n) insert and extract.Available now — read lesson 13
  14. Tries (Prefix Trees): Autocomplete, Prefix Search, and When the Path Is the KeyA trie stores keys not in nodes but along the path to them — which makes prefix queries and autocomplete trivial and lookup speed independent of how many words you've stored.Available now — read lesson 14
  15. Graphs & Their Representations: Adjacency List vs Matrix, and the Vocabulary You NeedTrees were a special case; graphs are the general one. Here's the vocabulary, the two ways to store a graph, and the trade-off that decides which to pick.Available now — read lesson 15
  16. Graph Traversal: BFS and DFS Explained (Shortest Paths, Cycles, Topological Sort)Two traversals underlie almost every graph algorithm. Swap a queue for a stack and BFS becomes DFS — but that one swap changes what each is good for entirely.Available now — read lesson 16
  17. Shortest Paths: Dijkstra's Algorithm and Bellman-Ford ExplainedWhen edges have weights, BFS isn't enough. Dijkstra greedily grows a shortest-path tree with a priority queue; Bellman-Ford relaxes every edge repeatedly and even handles negative weights.Available now — read lesson 17
  18. Minimum Spanning Trees: Kruskal's and Prim's Algorithms ExplainedConnect every vertex at the lowest total cost with no redundant links: the minimum spanning tree. Two greedy algorithms solve it — Kruskal's from the edges out, Prim's from a vertex out.Available now — read lesson 18
  19. Sorting I: Merge Sort, Quicksort, and Heapsort — The O(n log n) AlgorithmsSorting is the most-studied problem in computing. Here are the three O(n log n) heavyweights — merge sort, quicksort, heapsort — and the trade-offs (stability, space, worst case) that decide between them.Available now — read lesson 19
  20. Sorting II: Counting Sort, Radix Sort, and Bucket Sort — Beating O(n log n)The O(n log n) barrier only binds sorts that compare elements. Counting, radix, and bucket sort don't compare — they use the values themselves — and can sort in linear time.Available now — read lesson 20
  21. Binary Search Patterns: The Template, Boundaries, and 'Search on the Answer'Binary search is trivial to describe and famously hard to get right. Here's a bug-resistant template, the boundary variants, and the 'search on the answer' trick that turns optimization into search.Available now — read lesson 21
  22. Two Pointers & Sliding Window: Turning O(n²) Scans into O(n)Two pointers and the sliding window solve an enormous share of array and string problems in O(n). Here's how they work, why they're linear, and how to spot which one a problem wants.Available now — read lesson 22
  23. Divide and Conquer: The Paradigm Behind Merge Sort, Binary Search, and Fast MultiplicationSplit the problem, solve the pieces, combine the results. Divide and conquer is behind merge sort, binary search, and fast multiplication — and the Master Theorem tells you the cost at a glance.Available now — read lesson 23
  24. Greedy Algorithms: When Local Choices Are Globally Optimal (and When They Aren't)Greedy algorithms make the choice that looks best right now and never look back. Sometimes that's provably optimal (scheduling, Huffman, MST); sometimes it's disastrously wrong. Knowing which is the skill.Available now — read lesson 24
  25. Dynamic Programming: Foundations, Patterns, and How to Recognize a DP ProblemDynamic programming is just recursion that stops repeating itself. Master the two conditions, the two implementations, and the handful of patterns, and the scary reputation disappears.Available now — read lesson 25
  26. Backtracking: Systematic Search with Pruning (Permutations, N-Queens, Sudoku)Backtracking explores all possibilities like brute force, but abandons a path the instant it can't lead to a solution. That pruning is what makes searching enormous spaces feasible.Available now — read lesson 26
  27. Bit Manipulation: The Operators, the Tricks, and When Bits Beat Data StructuresBitwise operators let you pack, flag, and compute at the level of individual bits — often replacing a whole data structure with a single integer and an O(1) operation.Available now — read lesson 27
  28. Union-Find (Disjoint Set Union): Near-Constant Connectivity with Two OptimizationsUnion-Find answers 'are these two things connected?' and 'connect them' in almost O(1) — thanks to two beautifully simple optimizations that make the trees nearly flat.Available now — read lesson 28
  29. P vs NP and Complexity Classes: What 'Hard' Really Means (Intuition, No Proofs)Why do some problems have fast algorithms and others resist every attempt? P vs NP is the deepest open question in computer science — here's the intuition, minus the proofs.Available now — read lesson 29
  30. Coding Interview Strategy: A Framework for Solving Problems Under PressureKnowing algorithms isn't enough — you have to deploy them under pressure. Here's a repeatable framework for solving unseen problems and a study plan that builds durable skill.Available now — read lesson 30

Practice each lesson in AI Learning

Every lesson ends with a small exercise — the app is where it becomes a daily practice. A private, offline app to learn Artificial Intelligence, Machine Learning & Data Science at your own level: ~10,000 Q&A, illustrated guides, cheat sheets, quizzes and mock tests.

  • Free
  • No account
  • Works offline
Coming soon toGoogle Play