Interactive algorithm learning
Learn every algorithm, visually
Interactive visualizations, real code, complexity analysis, and quizzes for 55+ algorithms. Step through each one at your own pace.
Live — Sorting Visualizer
Auto
55+Algorithms/
9Categories/
6Visualizer Types/
3Languages/
YesStep-by-step/
Built-inQuizzes/
AnalyzedComplexity/
TrackedProgress/
55+Algorithms/
9Categories/
6Visualizer Types/
3Languages/
YesStep-by-step/
Built-inQuizzes/
AnalyzedComplexity/
TrackedProgress
01 — Everything you need
What’s inside AlgoLab
Interactive Visualizers
6 types: sort, search, tree, graph, linked list, DP
Watch algorithms execute step by step. Pause, rewind, adjust speed, and hear each operation with sound feedback.
Code in 3 Languages
C++, JavaScript, and Python implementations for every algorithm.
PythonJSC++
# Merge Sort
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr) // 2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
return merge(left, right)Step-by-Step Chapters
Each algorithm is explained in digestible sections.
01Divide and Conquer
02The Merge Step
03Stability
04Space Complexity
Complexity Analysis
Time and space complexity for every algorithm.
BestAvgWorst
Mergen log nn log nn log n
Quickn log nn log nn²
Bubblenn²n²
Test Your Knowledge
Quizzes after every algorithm to reinforce learning.
What is the time complexity of Merge Sort?
O(n)
O(n log n)
O(n²)
O(log n)
The best way to understand an algorithm is to watch it run. AlgoLab turns abstract pseudocode into something you can see, hear, and step through.
02 — Explore by category
9 categories, 55 algorithms
Algorithms that arrange elements in a specific order
Algorithms for finding elements in data structures
Operations on linked node structures
Hierarchical data structures and their algorithms
Graph traversal, shortest paths, and spanning trees
Optimization using memoization and tabulation
Locally optimal choices that yield global solutions
03 — How it works
Every algorithm, explained
Each algorithm comes with interactive visualizations, code in three languages, step-by-step explanations, and quizzes. Here’s what a typical page looks like.
Sortingintermediate
Merge Sort
Merge Sort is a classic divide-and-conquer algorithm. It recursively splits the array into halves until each piece has one element, then merges those pieces back in sorted order. It guarantees O(n log n) performance in all cases and is stable, making it the preferred sort for linked lists and external sorting.
MetricBestAverageWorst
TimeO(n log n)O(n log n)O(n log n)
SpaceO(n)
01
Divide and Conquer — Merge Sort splits the array in half repeatedly until each subarray has one eleme...
02
The Merge Step — Merging two sorted arrays takes O(n) time. We use two pointers, one into each ha...
03
Stability — Merge Sort is stable because equal elements from the left half are always placed...
04
Space Complexity — Merge Sort requires O(n) auxiliary space for the temporary arrays used during me...
05
External Sorting — Merge Sort is ideal for external sorting (data too large for RAM) because it acc...
PythonJavaScriptC++
def merge_sort(arr):
if len(arr) <= 1:
return arr
mid = len(arr) // 2
left = merge_sort(arr[:mid])
right = merge_sort(arr[mid:])
return merge(left, right)
def merge(left, right):
result = []
i = j = 0
while i < len(left) and j < len(right):
if left[i] <= right[j]:
result.append(left[i]); i += 1
else:
result.append(right[j]); j += 1
return result + left[i:] + right[j:]55+
Algorithms
6
Visualizer types
3
Languages per algo
∞
Free forever
04 — Full collection
Algorithm Index
Sorting
10Bubble SortRepeatedly swaps adjacent elements that are out of order until the array is sorted.
O(n²)beginnerSelection SortFinds the minimum element in the unsorted portion and places it at the beginning each pass.
O(n²)beginnerInsertion SortBuilds a sorted array one element at a time by inserting each new element into its correct position.
O(n²)beginnerMerge SortDivides the array in half recursively, then merges the sorted halves back together.
O(n log n)intermediateQuick SortPicks a pivot element and partitions the array around it, then recursively sorts each partition.
O(n log n)intermediateHeap SortUses a binary heap data structure to sort elements with guaranteed O(n log n) performance.
O(n log n)intermediateCounting SortSorts integers by counting occurrences of each value, achieving linear time for bounded integer ranges.
O(n+k)intermediateRadix SortSorts integers digit by digit from least significant to most significant using a stable subroutine.
O(nk)intermediateShell SortAn improved insertion sort that compares elements separated by a gap, reducing the gap until it reaches 1.
O(n log² n)intermediateTim SortA hybrid sort combining Merge Sort and Insertion Sort, used in Python and Java standard libraries.
O(n log n)advancedSearching
5Linear SearchScans each element one by one until the target is found or the array ends.
O(n)beginnerBinary SearchSearches a sorted array by repeatedly halving the search space, achieving O(log n) time.
O(log n)beginnerJump SearchJumps ahead by fixed steps to find a block, then does linear search within that block.
O(√n)intermediateInterpolation SearchImproves binary search by using the value distribution to estimate the probe position.
O(log log n)intermediateExponential SearchFinds a range where the target exists by doubling the index, then binary searches that range.
O(log n)intermediateLinked Lists
5Linked List TraversalVisits each node of a linked list in sequence by following next pointers.
O(n)beginnerLinked List InsertionInserts a new node at the head, tail, or a specific position in a linked list.
O(n)beginnerLinked List DeletionRemoves a node from a linked list by updating the previous node's next pointer.
O(n)beginnerLinked List ReversalReverses a linked list in-place by redirecting all next pointers to point backward.
O(n)intermediateFloyd's Cycle DetectionDetects cycles in a linked list using two pointers moving at different speeds.
O(n)intermediateTrees
8BST Insert & SearchInsert and search operations on a Binary Search Tree using the BST ordering property.
O(log n)intermediateBST DeletionRemoves a node from a BST while maintaining the binary search tree ordering property.
O(log n)intermediateInorder TraversalVisits left subtree, then root, then right subtree — produces sorted output for BSTs.
O(n)beginnerPreorder & PostorderPreorder visits root before children; postorder visits root after children.
O(n)beginnerLevel Order TraversalVisits all nodes level by level from top to bottom using a queue.
O(n)beginnerAVL TreeA self-balancing BST that maintains height balance through rotations after each insert or delete.
O(log n)advancedSegment TreeA tree for efficiently answering range queries and performing range updates on an array.
O(log n)advancedFenwick Tree (BIT)A space-efficient data structure supporting prefix sum queries and point updates in O(log n).
O(log n)advancedGraphs
11Breadth-First SearchExplores all neighbors at the current depth before moving deeper, using a queue.
O(V+E)intermediateDepth-First SearchExplores as far as possible along each branch before backtracking, using a stack or recursion.
O(V+E)intermediateDijkstra's AlgorithmFinds shortest paths from a source to all vertices in a weighted graph with non-negative edges.
O((V+E) log V)intermediateBellman-FordFinds shortest paths from a source handling negative edge weights and detecting negative cycles.
O(VE)intermediateFloyd-WarshallFinds shortest paths between all pairs of vertices using dynamic programming.
O(V³)intermediateA* SearchFinds the shortest path using a heuristic to guide search toward the goal efficiently.
O(E log V)advancedPrim's MSTBuilds a minimum spanning tree by greedily adding the cheapest edge connecting the tree to a new vertex.
O(E log V)intermediateKruskal's MSTBuilds a minimum spanning tree by sorting all edges and adding them greedily using Union-Find.
O(E log E)intermediateTopological SortOrders vertices of a DAG so that every directed edge goes from earlier to later in the order.
O(V+E)intermediateKosaraju's SCCFinds all strongly connected components of a directed graph using two DFS passes.
O(V+E)advancedTarjan's SCCFinds all strongly connected components in a single DFS pass using a stack and low-link values.
O(V+E)advancedDynamic Programming
8Fibonacci (DP)Computes Fibonacci numbers efficiently using memoization or tabulation to avoid redundant calls.
O(n)beginner0/1 KnapsackMaximizes the value of items that fit in a knapsack where each item can be taken at most once.
O(nW)intermediateLongest Common SubsequenceFinds the longest subsequence common to two strings using a 2D DP table.
O(mn)intermediateLongest Increasing SubsequenceFinds the longest strictly increasing subsequence in an array.
O(n log n)intermediateCoin ChangeFinds the minimum number of coins needed to make a target amount.
O(amount × coins)intermediateEdit DistanceComputes the minimum edit operations (insert, delete, replace) to transform one string into another.
O(mn)intermediateMatrix Chain MultiplicationFinds the optimal parenthesization of matrix products to minimize total scalar multiplications.
O(n³)advancedDP on TreesApplies dynamic programming on tree structures to solve subtree-based optimization problems.
O(n)advancedGreedy
4Activity SelectionSelects the maximum number of non-overlapping activities from a set of activities with start/end times.
O(n log n)intermediateFractional KnapsackMaximizes value in a knapsack by allowing fractional items, solvable greedily by value-to-weight ratio.
O(n log n)intermediateHuffman EncodingBuilds an optimal prefix-free binary code by greedily merging the two lowest-frequency symbols.
O(n log n)intermediateJob SequencingSchedules jobs with deadlines to maximize total profit, assigning at most one job per time slot.
O(n²)intermediateBacktracking
4N-QueensPlaces N queens on an N×N chessboard so no two queens attack each other.
O(n!)intermediateSudoku SolverSolves a 9×9 Sudoku puzzle using backtracking with constraint propagation.
O(9^m)intermediateGenerate PermutationsGenerates all permutations of an array using backtracking and swapping.
O(n! × n)intermediateSubset SumFinds all subsets of an array that sum to a given target using backtracking.
O(2^n)intermediateStart learning algorithms today
55 algorithms with interactive visualizations, code in three languages, and built-in quizzes. Completely free.