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.

1. 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)

1. 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

1. 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)

1. 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)

1. 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

1. 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