What you can get in the app
- Step-by-step execution: Key operations such as comparisons, swaps, pointer moves, push/pop, rotations and recoloring, relaxation updates, and more are highlighted in real time.
- Full process control: Pause/resume, single-step, and replay (great for review and explanation).
- Side-by-side learning: Compare how different algorithms behave on the same input to understand why one is faster/slower, stable/unstable, and when to use each.
- Stats and metrics: In modules like sorting, display metrics such as comparison count and swap count to build complexity awareness and performance intuition.
- Data structure + operations together: Not only the “algorithm,” but also how the underlying data structure changes as operations are applied.
Content overview (by module)
1) Sorting
Ideal for bar/column visualizations with frequent, high-contrast changes. Built-in algorithms include:
- Bubble Sort, Selection Sort, Insertion Sort, Shell Sort
- Merge Sort, Quick Sort, Heap Sort
- Counting Sort, Radix Sort, Bucket Sort
- Cocktail Shaker Sort, Comb Sort
- Hybrid sorts (e.g., TimSort, for advanced extensions)
Visualization focus: comparisons and swaps, partition/merge processes, heapify operations, and behavior/metrics differences across algorithms at the same input size.
2) Searching
Demonstrates “search paths” and pointer movement using arrays, sorted sequences, and tree structures:
- Linear Search, Binary Search, Interpolation Search
- Skip List (multi-level structure + search process)
Plus structure-based searching:
- Search in BST/AVL/Red-Black Trees
- B-Tree / B+ Tree search (useful for index and disk-structure intuition)
- Hash-based search (collision handling: separate chaining, open addressing)
3) Data Structures and Core Operations
Binds “structure shape” and “operation steps” together so you understand the mechanism and cost behind each operation.
Linear structures
- Arrays: access, insert, delete (including shifting)
- Linked lists: singly/doubly/circular (insert, delete, reverse)
- Stacks: push/pop, applications like parentheses matching
- Queues: standard queue, circular queue, deque, priority queue
Tree structures
- Binary tree traversals: preorder/inorder/postorder (recursive vs iterative), level-order traversal
- BST: insert/delete/search
- AVL: LL/RR/LR/RL rotations and trigger conditions
- Red-Black Tree: rotations and recoloring during insert/delete
- Heap: insert, delete-top, heapify
- Trie: insert/search/delete
- Segment Tree / Fenwick Tree (BIT): point update, range query
Graph structure basics
- Adjacency matrix vs adjacency list
- Undirected graphs, directed graphs, weighted graphs
4) Graph Algorithms
Dynamic node-edge animations are especially intuitive for building graph theory intuition.
Traversal and connectivity
- DFS, BFS, connected components, topological sorting
Shortest paths
- Dijkstra, Bellman–Ford, Floyd–Warshall, A* search
Minimum spanning tree
- Prim, Kruskal (with Union-Find visualization)
Advanced: matching and flow
- Bipartite matching (augmenting path idea)
- Maximum flow (Ford–Fulkerson / Edmonds–Karp)
5) String Algorithms
Presented with “text + pointers/windows/tables”:
- Naive matching, KMP (prefix table), Rabin–Karp (rolling hash)
- Boyer–Moore / Horspool
- Suffix array construction, (advanced) suffix automaton / suffix tree
- LCS, longest common substring, edit distance (DP table animation)
6) Recursion and Backtracking
Shows the essence of problem-solving with “recursion tree + call stack + backtracking path”:
- Permutations/combinations/subsets
- N-Queens, Sudoku, maze paths, Tower of Hanoi
- Highlighting choice points and undo steps during backtracking
7) Dynamic Programming
Uses state tables/grids to show exactly “where each transition comes from”:
- Fibonacci (recursion vs memoization vs iteration)
- 0/1 knapsack, unbounded knapsack
- LCS, edit distance
- Grid min path / max weight path
- Advanced: interval DP, tree DP
Show more
Show less
