Visual Algorithm
No in-app products collected for this app.
| Rating | |||
|---|---|---|---|
| China | 100%1 | 5.00 | |
| United Arab Emirates | <1%0 | — | |
| Afghanistan | <1%0 | — | |
| Antigua And Barbuda | <1%0 | — | |
| Anguilla | <1%0 | — | |
| Albania | <1%0 | — | |
| Armenia | <1%0 | — | |
| Angola | <1%0 | — | |
| Argentina | <1%0 | — | |
| Austria | <1%0 | — |
Description
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