All topics, step by step.

Every topic on this site in one list: Big O notation, 31 data structures and algorithms, and comparisons of those most often confused, in seven groups, a binary search tree to insert your own keys into, and a game to practice them in. Each page explains its topic with step-by-step animations from the VisiGrab app.

Fundamentals

  • Big O Notation — How the steps of an algorithm grow with its input: O(1), O(log n), O(n), O(n²) and more, built from step counts.

Data structures

  • Array — Access by index in O(1), static vs dynamic arrays, and how a full array resizes.
  • Linked List — Nodes joined by next links: insertion and deletion without shifting.
  • Doubly Linked List — A prev and a next link in every node, so the list can be walked both ways.
  • Stack — Last in, first out: push and pop at the top.
  • Queue — First in, first out: enqueue at the rear, dequeue at the front.
  • Hash Table — Keys hashed into buckets, with collisions handled by separate chaining and linear probing.
  • Graph — Vertices and edges: directed and weighted graphs, adjacency matrix vs adjacency list.

Trees

  • Binary Search Tree — Smaller keys to the left, larger to the right: insertion and the three deletion cases.
  • AVL Tree — A binary search tree that keeps itself balanced with rotations.
  • Red-Black Tree — A binary search tree kept balanced by node colors, recoloring and rotations.
  • B-Tree — Many keys per node: splits on insertion, borrowing and merging on deletion.
  • Min-Heap — The smallest key at the root: insert, extract-min and build-heap.
  • Trie — A prefix tree: words that share a prefix share a path.

Sorting

  • Bubble Sort — Swaps neighboring values that are out of order, pass after pass.
  • Selection Sort — Finds the minimum of the unsorted part and swaps it to the front.
  • Insertion Sort — Takes each value in turn and shifts it left into the sorted part.
  • Merge Sort — Splits the array into halves and merges them back in order, in O(n log n).
  • Heap Sort — Builds a max heap, then moves the largest value to the end, again and again.
  • Quick Sort — Partitions the array around a pivot, then sorts both parts.

Graph algorithms

Tree traversals

Comparisons

  • BFS vs DFS — A queue against a stack: both searches step by step on one tree, and when to use each.
  • Merge Sort vs Quick Sort — Split by position or by value: both sorts step by step on one array, and when to use each.
  • Dijkstra vs Bellman-Ford — Closest first against every edge: both on one graph with a negative edge, and when to use each.
  • Prim vs Kruskal — One tree against a forest: both build the same minimum spanning tree on one graph, and when to use each.
  • Stack vs Queue — Newest out against oldest out: the same six operations on both, and when to use each.

Visualizations

  • Binary Search Tree Visualization — Insert your own keys and watch each insertion step by step: every comparison on the way down, then the new node in its place.
  • AVL Tree Visualization — Insert your own keys and watch each insertion step by step: every comparison on the way down, the new node, then every rotation that restores the balance.

Practice

  • Data Structures Game — Fly a ship to orbit by choosing an array, a linked list, a stack or a queue for each job, with every step counted.

All 30+ topics
in the app.

Download VisiGrab and step through every topic yourself, at your own pace.