Skip to content

Visualizers

Algorithm Visualizer

Step-through animations for sorting and pathfinding algorithms.

native (Canvas API) Client-side
Sorting

Bubble Sort

Repeatedly steps through the list, compares adjacent elements and swaps them if they are in the wrong order.

Best Time: O(n)
Worst Time: O(n²)
Avg Time: O(n²)
Space Complexity: O(1)
Open Visualizer
Sorting

Selection Sort

Divides the input list into two parts: sorted sublist and unsorted sublist, repeatedly selecting the smallest element.

Best Time: O(n²)
Worst Time: O(n²)
Avg Time: O(n²)
Space Complexity: O(1)
Open Visualizer
Sorting

Insertion Sort

Builds the final sorted array one item at a time by inserting elements into their correct position.

Best Time: O(n)
Worst Time: O(n²)
Avg Time: O(n²)
Space Complexity: O(1)
Open Visualizer
Sorting

Merge Sort

A divide-and-conquer algorithm that divides the array in half, recursively sorts them, and merges them.

Best Time: O(n log n)
Worst Time: O(n log n)
Avg Time: O(n log n)
Space Complexity: O(n)
Open Visualizer
Sorting

Quick Sort

A divide-and-conquer algorithm that picks an element as pivot and partitions the array around it.

Best Time: O(n log n)
Worst Time: O(n²)
Avg Time: O(n log n)
Space Complexity: O(log n)
Open Visualizer
Sorting

Heap Sort

A comparison-based sorting technique based on Binary Heap data structure.

Best Time: O(n log n)
Worst Time: O(n log n)
Avg Time: O(n log n)
Space Complexity: O(1)
Open Visualizer
Sorting

Counting Sort

A non-comparison sorting algorithm that counts occurrences of each unique element.

Best Time: O(n + k)
Worst Time: O(n + k)
Avg Time: O(n + k)
Space Complexity: O(k)
Open Visualizer
Searching

Binary Search

Finds the position of a target value within a sorted array by repeatedly dividing the search interval in half.

Best Time: O(1)
Worst Time: O(log n)
Avg Time: O(log n)
Space Complexity: O(1)
Open Visualizer
Searching

Linear Search

Sequential search algorithm that checks every element of the list until a match is found.

Best Time: O(1)
Worst Time: O(n)
Avg Time: O(n)
Space Complexity: O(1)
Open Visualizer
Tree Operations

Binary Search Tree (BST)

Interactive BST operations: insertion, deletion, and search with visualized path.

Best Time: O(log n)
Worst Time: O(n)
Avg Time: O(log n)
Space Complexity: O(h)
Open Visualizer
Tree Operations

Tree Traversals

Visualizes Preorder, Inorder, and Postorder tree traversals on a binary search tree.

Best Time: O(n)
Worst Time: O(n)
Avg Time: O(n)
Space Complexity: O(h)
Open Visualizer
Dynamic Programming

Fibonacci DP

Shows standard recursion vs memoized recursion and bottom-up tabulation DP array.

Best Time: O(n)
Worst Time: O(n)
Avg Time: O(n)
Space Complexity: O(1)
Open Visualizer
Dynamic Programming

LCS (Longest Common Subsequence)

Finds the longest common subsequence of two strings by building a 2D matrix.

Best Time: O(m × n)
Worst Time: O(m × n)
Avg Time: O(m × n)
Space Complexity: O(m × n)
Open Visualizer
Dynamic Programming

0/1 Knapsack

Maximizes total item value within knapsack weight capacity using a 2D DP matrix.

Best Time: O(N × W)
Worst Time: O(N × W)
Avg Time: O(N × W)
Space Complexity: O(W)
Open Visualizer
Dynamic Programming

Coin Change

Finds the minimum number of coins needed to make a target amount using a 1D DP table.

Best Time: O(A × N)
Worst Time: O(A × N)
Avg Time: O(A × N)
Space Complexity: O(A)
Open Visualizer
Recursion

Factorial Recursion

Visualizes call stack frames pushing and popping as factorial recursively computes.

Best Time: O(n)
Worst Time: O(n)
Avg Time: O(n)
Space Complexity: O(n)
Open Visualizer
Backtracking

N-Queens

Solves the N-Queens problem on an NxN chessboard using depth-first backtracking.

Best Time: O(N!)
Worst Time: O(N!)
Avg Time: O(N!)
Space Complexity: O(N)
Open Visualizer

Algorithm & Complexity Visualizer Hub

Algorithms are the heart of software engineering. Understanding how they execute step-by-step is crucial for designing efficient, scalable systems. This hub compiles 21 fundamental computer science algorithms across categories like Sorting, Searching, Graph Pathfinding, Tree Operations, Dynamic Programming, and Backtracking.

Select any algorithm to launch a dedicated, fully interactive visualizer. Customize input arrays, weights, or dimensions; adjust playback speed; step through operations frame-by-frame; and observe time and space complexities in action.

Frequently Asked Questions

What categories of algorithms are supported?

CodoKit supports 6 core categories: sorting (e.g. Quick Sort, Merge Sort), searching (Linear/Binary search), graph pathfinding (BFS, DFS, Dijkstra, A*), tree operations (BST, Tree Traversals), dynamic programming (LCS, Knapsack, Coin Change), and backtracking (N-Queens).

Are all visualizer computations client-side?

Yes. Every simulation, maze generation, recursion tree, and table computation runs 100% inside your web browser. No data or inputs are sent to any external server.

Related Tools

Big-O Visualizer

Interactive growth-curve chart for common complexity classes.

Data Structure Visualizer

Animated operations on linked lists, trees, stacks and hash tables.

Regex Visualizer

See regex matches highlighted and the pattern broken down visually.