Four basics — stack, line up, link
Last-in-first-out on a stack, first-in-first-out on a queue, the shifting that follows an array insert or delete, and arrows rewired in a linked list. The fundamentals, in motion.
// DATARAKU — Data Structure Visualizer
Data structures make sense
when you see them move.
Understand data structures by watching them, not by reading about them. Stacks, queues, trees, and hash tables come alive as animations where the structure itself reshapes in response to your operations. Comparisons glow orange, targets turn green — nothing teleports, so you see every push, link, and lookup as it happens.
$ Watch hash collisions — HASH TABLE
Seven buckets with separate chaining. h(k) = k mod 7 picks the bucket in one jump, and keys that land in the same bucket join the end of its chain. You see why lookups are "O(1) on average" — and what happens when keys collide.
- 01Insert. The key goes through the hash function and its bucket lights up orange.
- 02Collide. If the bucket is taken, the key is appended to the chain — you watch the chain grow.
- 03Search. Jump straight to the bucket, then walk the chain one node at a time to find the key.
- 04Read the log. Which bucket, whether it collided, and how many chain nodes were walked — all in the operation log.
$ dataraku hash insert 58 24 94 52 key h(k)=k mod 7 bucket 58 2 [2] 58 24 3 [3] 24 94 3 collision [3] 24 → 94 52 3 collision [3] 24 → 94 → 52 $ dataraku hash search 52 [3] 24 → 94 → 52 ✓ found # walked 3 chain nodes
$ Features — FEATURES
Don't read it — run it. Put values in, take them out, walk the structure, and do it again.
Four advanced — branch, climb, jump, connect
A binary search tree where values branch left or right into place, a max heap whose parents and children swap, a hash table that jumps to a bucket, and an undirected graph explored with BFS.
Feel the complexity
An array reaches index k in O(1); a linked list walks there node by node in O(n). Same question — "what's the k-th item?" — and you can see how different the work is.
Operation log
"searched 62 — found in 6 comparisons from the root." "inserted 95 — sifting up (up-heap)." Look back at what happened, line by line.
An explanation for every structure
Tap ⓘ for how it works, its complexity (access / search / insert / delete), strengths and weaknesses, and real-world uses — plus which ARURAKU algorithms build on it.
No ads while you visualize
Visualization screens never show ads. Banners sit only at the bottom of the structure list and explanation screens, and a full-screen ad may appear, at most once a minute, only when you open a different structure. Every feature is free.
$ legend
idle
comparing / target bucket
target / found
$ Structures — STRUCTURES
The eight classics from CS courses and IT certification exams, in four basic and four advanced structures.
| Level | Structure | Typical complexity | What to watch |
|---|---|---|---|
| Basic | Stack | push / pop O(1) | Last in, first out (LIFO); the last item stacked comes off first |
| Basic | Queue | enqueue / dequeue O(1) | First in, first out (FIFO); separate entry and exit ends |
| Basic | Array | access O(1) / insert O(n) | Jump to any index; inserts and deletes shift what follows |
| Basic | Linked list | traverse O(n) | Nodes joined by arrows; inserts and deletes rewire them |
| Advanced | Tree (binary search tree) | search O(log n) avg. | Values branch left or right by comparison until they settle |
| Advanced | Heap (max heap) | insert / extract O(log n) | Complete binary tree; up-heap and down-heap swap parent and child |
| Advanced | Hash table | search O(1) avg. | 7 buckets with chaining; h(k) = k mod 7 makes collisions visible |
| Advanced | Graph (undirected) | BFS O(V+E) | Add nodes and edges, then watch BFS spread out nearest-first |
$ Together with ARURAKU — WITH ARURAKU
The second information-systems title in the Raku Series. Pair it with the first, ARURAKU (algorithm visualization), to learn both the motion of computation and the structures it runs on. The heap underlies heap sort; the graph is where BFS, DFS, and Dijkstra's algorithm walk.
$ Who it's for — FOR
studentsAnyone just starting to learn programming
examPeople preparing for IT certification exams
engineersEngineers who want to re-grasp data structures visually
curiousAnyone who simply enjoys watching things move
$ Screenshots — GALLERY
