A structured roadmap to mastering algorithms, powered by interactive visualizations and AI tutoring.
Introduction to coding, how computers understand code, and the role of programming languages.
Visualizing program flow using standard symbols and diagrams.
Writing logic without syntax constraints using pseudocode.
Understanding how computers store and manipulate data.
Iterating through data and repeating actions efficiently.
Functions that call themselves to solve problems.
Understanding algorithm efficiency and complexity analysis.
Fundamental data structures for storing sequences of data.
Dynamic data structure with nodes connected by pointers.
LIFO data structure for managing elements.
FIFO data structure for managing elements.
Efficient data storage and retrieval using hash functions.
Simple search algorithm that checks each element sequentially.
Efficient search algorithm for sorted arrays.
Simple sorting algorithm that repeatedly steps through the list, comparing adjacent elements and swapping them if needed.
Simple sorting algorithm that finds the minimum element and places it at the beginning.
Efficient algorithm for small datasets, works like sorting playing cards in your hands.
Efficient divide-and-conquer sorting algorithm with guaranteed O(n log n) performance.
Efficient divide-and-conquer algorithm, often faster than Merge Sort in practice.
Tree data structure where each node has at most two children, maintaining sorted order.
Complete binary tree that maintains heap property - used for priority queues and efficient sorting.
Self-balancing binary search tree that maintains O(log n) height through rotations.
Tree-like data structure for efficient string storage and prefix matching.
Different ways to represent graphs: adjacency list, adjacency matrix, and edge list.
Graph traversal algorithm that explores nodes level by level using a queue.
Graph traversal algorithm that explores as far as possible along each branch before backtracking.
Linear ordering of vertices in a DAG such that for every edge (u, v), u comes before v.
Finds shortest paths from a source vertex to all other vertices in a weighted graph with non-negative edges.
Finds shortest paths from a source vertex, can handle negative weights and detect negative cycles.
Greedy algorithm to find Minimum Spanning Tree (MST) of a connected, weighted graph.
Efficient data structure for tracking disjoint sets, used for cycle detection and connected components.
Making locally optimal choices at each step.
Solving complex problems by breaking them into simpler subproblems.
Classic optimization problem using dynamic programming.
Finding the longest subsequence common to two sequences.
Systematic method for solving constraint satisfaction problems.
Efficient data structure for range queries and updates.
Binary Indexed Tree for efficient prefix sum queries.
Efficient algorithms using bitwise operations.