Master Data Structures
by Seeing Them in Action.
Learn concepts, visualize every operation, run algorithms step by step and practise interactively — like a lab, not a textbook.
- Learnthe idea
- Visualizethe structure
- Interactchange the data
- Runstep by step
- Understandwhy it works
- Practicetest yourself
- Assessprove it
10 modules, one visual lab
Pass each module's quiz (70% or more), then take the final exam to earn your certificate.
-
Module 1
Introduction
What data structures are, why they matter, and how we measure speed with Big-O.
- What is a Data Structure?
- Abstract Data Types
- Time & Space Complexity
- Big-O Notation
- Count the steps
-
Module 2
Arrays
Contiguous memory and instant access by index. Insert, delete, search and update — step by step.
- Memory representation
- Traversal
- Insertion
- Deletion
- Linear Search
- Updating
-
Module 3
Linked Lists
Nodes connected by pointers — singly, doubly, circular and doubly circular lists, plus polynomials stored as linked lists.
- Singly Linked List
- Doubly Linked List
- Circular Linked List
- Doubly Circular Linked List
- Insert & Delete
- Reverse a List
- Polynomial Representation
- Polynomial Add & Multiply
-
Module 4
Stacks
LIFO — push, pop and peek, with overflow and underflow, then real uses of a stack: balanced brackets, converting infix / postfix / prefix expressions, and the Tower of Hanoi with its call stack and call tree.
- Push & Pop
- Peek
- Overflow & Underflow
- Balanced Brackets
- Infix ⇄ Postfix ⇄ Prefix
- Tower of Hanoi
-
Module 5
Queues
FIFO queues — and why the circular queue fixes the wasted space of a linear one — then the priority queue (the most urgent item leaves first) and the double-ended queue (insert and delete at both ends).
- Enqueue & Dequeue
- Front & Rear
- Wasted space
- Circular Queue
- Priority Queue
- Double-Ended Queue
-
Module 6
Trees
Eight kinds of tree in one lab, in learning order: binary trees and traversals (and rebuilding a tree from them), the variants of the binary tree (strict, complete, perfect, extended, threaded), expression trees, Huffman coding, binary search trees, the B-trees and B+ trees behind databases, and self-balancing AVL trees.
- Binary Tree & Traversals
- Variants of Binary Tree
- Expression Tree
- Huffman Tree
- Binary Search Tree
- B-Tree
- B+ Tree
- AVL Tree
-
Module 7
Heaps
Min-heaps and max-heaps: the tree stored in an array, insert with sift-up, extract with sift-down, and building a heap in O(n).
- Min Heap
- Max Heap
- Array Representation
- Insert & Extract
- Build Heap
-
Module 8
Graphs
Six topics in learning order: directed and undirected graphs, how to store them (adjacency list, adjacency matrix, incidence matrix), traversal with BFS and DFS, minimum spanning trees (Kruskal and Prim), and shortest paths (Floyd–Warshall for all pairs, Dijkstra from one source).
- Directed / Undirected Graphs
- Adjacency List
- Adjacency Matrix
- Incidence Matrix
- BFS
- DFS
- Kruskal's Algorithm
- Prim's Algorithm
- Floyd–Warshall (All Pairs)
- Dijkstra (Single Source)
-
Module 9
Searching
Linear search, binary search with low, mid and high pointers, and jump search — counting every comparison.
- Linear Search
- Binary Search
- Jump Search
- O(n) vs O(log n)
-
Module 10
Sorting
Eight algorithms on the same array: bubble, selection, insertion, merge, quick, heap, radix and bucket sort — every comparison and swap.
- Bubble
- Selection
- Insertion
- Merge
- Quick
- Heap
- Radix
- Bucket