# Visual Algorithm — See algorithms in motion

> See algorithms in motion (iPhone/iPad app by 皖鹏 任.)

- Source: https://appshunter.io/ios/app/visual-algorithm/id6758951850 (this page in markdown: same URL + `.md`)
- Developer: [皖鹏 任](https://appshunter.io/developer/1521482837)
- Category: Education
- Price: Free with in-app purchases
- Age rating: 4+
- Requires: iOS 17.0 · 20 MB
- Languages: American English, French (France), German (Germany), Japanese, Chinese (Simplified, China), Chinese (Traditional, Taiwan)
- Released: 2026-02-14
- Data updated: 2026-08-13
- User reviews in markdown: https://appshunter.io/ios/app/visual-algorithm/id6758951850/reviews.md

## What is Visual Algorithm?

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

## Pricing and in-app purchases

Base price: Free.

**One-time purchases**

| Purchase | Price | Type |
| --- | --- | --- |
| Lifetime Member | $29.99 | one-time |



## Version history (last 2 releases)

### 1.1 — 2026-03-05

Added new frequently asked algorithm interview questions.

### 1.0 — 2026-02-16

No release notes.

## More apps by 皖鹏 任

- [止鼾训练](https://appshunter.io/ios/app/id1530130864)
- [Mechanical Principle](https://appshunter.io/ios/app/mechanical-principle/id1539315757)
- [Purine Food Lookup](https://appshunter.io/ios/app/purine-food-lookup/id1573204956)
- [手机字体大全-超多个性字体](https://appshunter.io/ios/app/id1574146745)
- [宝宝辅食-健康营养](https://appshunter.io/ios/app/id1577576145)
- [颜文字输入法](https://appshunter.io/ios/app/id1581561920)

All apps by 皖鹏 任: https://appshunter.io/developer/1521482837

---

*Data collected daily from the US App Store and indexed by [AppsHunter](https://appshunter.io/). User reviews are verbatim App Store reviews. Ratings, prices and chart positions refresh continuously; this snapshot is from 2026-08-13.*