JavaScript developers
You already build with JavaScript, but you’re unsure which structure to reach for when requirements shift from “store data” to “store it efficiently.” This course gives you a reliable decision-making toolkit.
JavaScript Data Structures - The Fundamentals
Learn all the core basics about JS data structures - both built-in ones like Maps, Sets or Arrays as well as custom ones like Linked Lists, Trees, Graphs etc.
Course Overview
About This Course
You can write JavaScript that “works” and still feel stuck the moment you need to choose the right structure to store, search, or organize data. Arrays and Objects are familiar—until performance questions, interview prompts, or more complex relationships show up.
In this course, you’ll connect the dots between what JavaScript gives you out of the box and what you can build yourself when the built-ins aren’t enough. You’ll get clear explanations of how each structure behaves, paired with practical examples that make the trade-offs feel obvious instead of abstract.
By the end, you’ll be able to pick a structure with confidence, implement it when needed, and explain why it’s the right choice. You’ll also be ready to reason about runtime costs as you work, so you can write solutions that scale and communicate your decisions in interviews and real projects.
What You'll Learn
A focused tour of JavaScript’s built-in structures plus the custom ones you’re expected to recognize, implement, and analyze in real problem-solving.
Use built-ins well
Choose between Arrays, Objects, Maps, and Sets based on the operations you need, and explain the practical consequences of each choice when storing and retrieving data.
Implement linked structures
Build Linked Lists and use them as a foundation for other patterns, so you can model data that changes frequently without relying on contiguous array storage.
Build stacks and queues
Create Stacks and Queues from scratch and apply them to problems where order of processing matters, such as LIFO vs FIFO workflows.
Create hash tables
Implement a Hash Table and understand how hashing affects lookup behavior, so you can reason about fast access patterns beyond plain Objects.
Work with trees
Construct Basic Trees, Binary Search Trees (BST), and AVL Trees, and decide when you need ordering, balancing, or hierarchical modeling for your data.
Model graphs and heaps
Build Graphs as well as Heaps and Priority Queues, and use them to represent networks and prioritized processing where “next best” selection is central.
Ready to get started?
See enrollment optionsPrerequisites
Basic understanding of JavaScript algorithms.
You should understand time complexity and Big O notation.
Who Is This Course For?
Interview candidates
You’re preparing for technical interviews and want to confidently explain how structures work and why you’d choose one over another. This course helps you speak clearly about trade-offs and performance.
Algorithm learners
You’ve started learning algorithms and keep running into unfamiliar structures like trees, heaps, or graphs. This course fills that gap so the problems stop feeling like they’re written in a different language.
Curriculum Overview
Start NowPreview the structure and pacing of this course before you begin.
Getting Started1h 36m
- 01Welcome to the Course!1:11 min
- 02What are "Data Structures"?4:58 min
- 03Course Resources0:00 min
- 04Arrays: Recap8:57 min
- 05Sets: Recap5:46 min
- 06Arrays vs Sets1:34 min
- 07Objects: Recap7:05 min
- 08Maps: Recap7:37 min
- 09Objects vs Maps1:43 min
- 10WeakSet and WeakMap2:16 min
- 11Linked Lists (A First Custom Data Structures)2:46 min
- 12Starting with Linked Lists and "append"13:19 min
- 13Outputting the Linked List4:58 min
- 14Prepend to Linked Lists4:09 min
- 15Deleting Nodes10:31 min
- 16"find" and "insertAfter"6:56 min
- 17Linked Lists: Why and Time Complexity5:28 min
- 18Linked Lists vs Arrays7:06 min
- 19Module Resources0:00 min
- 20The Academind Pro Referral Program0:00 min
Lists & Tables2h 2m
- 01Module Introduction0:55 min
- 02What are "Lists" and "Tables"?4:22 min
- 03Built-in Lists and Tables3:42 min
- 04Introducing "Stacks"5:51 min
- 05Building a "Stack" Data Structure7:01 min
- 06Considering a Linked List Stack2:41 min
- 07Stacks with Linked Lists9:12 min
- 08Stacks: Time Complexity4:50 min
- 09Introducing Queues3:24 min
- 10Building a Queue4:34 min
- 11Linked Lists & Queues5:09 min
- 12Queue Time Complexity4:45 min
- 13Introducing Hash Tables4:18 min
- 14Why we need Tables9:54 min
- 15Building a Basic Hash Table12:20 min
- 16Understanding Hash Collisions4:58 min
- 17Solving Collisions with Chaining11:51 min
- 18Solving Collisions with Open Addressing10:42 min
- 19Hash Tables: Time Complexity7:04 min
- 20Hash Tables: Summary4:46 min
- 21Module Resources0:00 min
Trees3h 29m
- 01Module Introduction1:35 min
- 02What are "Trees"?3:28 min
- 03Core Terminology8:58 min
- 04An Example Tree2:43 min
- 05A First Tree in Code11:16 min
- 06A Better Filesystem Tree14:10 min
- 07Removing Tree Nodes7:06 min
- 08Describing Our Tree6:49 min
- 09Trees: Time Complexity4:42 min
- 10Depth-first vs Breadth-first Search2:21 min
- 11Implementing Depth-first Search6:01 min
- 12Implementing Breadth-first Search3:27 min
- 13Depth-first Search vs Breadth-first Search5:06 min
- 14Introducing Binary Search Trees (BST)3:34 min
- 15Adding Values to BST6:27 min
- 16Finding Values in BST10:13 min
- 17Removing Leaf Nodes in BST7:46 min
- 18Removing "One-Child" Nodes in BST5:12 min
- 19Removing "Multi-Child" Nodes in BST12:09 min
- 20BST Time Complexity3:38 min
- 21Introducing AVL Trees3:08 min
- 22Balancing Trees with Rotations4:05 min
- 23Understanding Balance Factors2:59 min
- 24Adding Depth and Balance Factors6:25 min
- 25Finding the Right Rotation8:07 min
- 26Implementing Left Rotation9:50 min
- 27Implementing Right Rotation3:21 min
- 28Implementing Left-Right Rotation8:10 min
- 29Implementing Right-Left Rotation3:28 min
- 30Testing the AVL Tree3:06 min
- 31AVL vs BST1:05 min
- 32Introducing Tries3:35 min
- 33Building a Trie12:01 min
- 34Finding Nodes in a Trie3:24 min
- 35Deleting Keys3:57 min
- 36Tries: Time Complexity and Comparison to Hash Tables5:41 min
- 37Module Resources0:00 min
Priority Queues & Heaps59m
- 01Module Introduction0:37 min
- 02Understanding Priority Queues2:03 min
- 03Building a Regular Queue4:22 min
- 04Building a Basic Priority Queue7:33 min
- 05Priority Queues & Time Complexity2:07 min
- 06Introducing Heaps3:22 min
- 07Exploring the Heap Concept5:50 min
- 08Building a Heap11:20 min
- 09Processing Items11:51 min
- 10A Heap-based Priority Queue4:34 min
- 11Heaps & Time Complexity5:53 min
- 12Module Resources0:00 min
Graphs1h 5m
- 01Module Introduction0:37 min
- 02Graphs: What and Why?6:01 min
- 03Graphs with an Adjacency Matrix9:56 min
- 04Using Adjacency Lists Instead4:27 min
- 05Adjacency Lists vs Matrices5:44 min
- 06Building a Graph Structure7:06 min
- 07Adding Graph Methods7:01 min
- 08Removing Nodes & Edges10:47 min
- 09Using Sets in Graphs7:14 min
- 10Summary1:08 min
- 11Building a Social Network Graph5:53 min
- 12Module Resources0:00 min
Summary & Next Steps1m
- 01Course Slides0:00 min
- 02Next Steps0:00 min
Ready to Get Started?
Choose the option that works best for you.
Single Course
JavaScript Data Structures - The Fundamentals
One Payment. Lifetime Access.
$89one-time
- One-time payment
- All future updates for this course
- Downloadable resources & code
- Certificate of completion
- Hands-on exercises & projects
- Self-paced learning
- English captions on all videos
- Lifetime access
Most Popular
All-Access Membership
Everything we teach. One subscription.
$25/mo
$4,729+ worth of courses
- Full access to all courses
- All future courses included
- Downloadable resources & code
- Certificates of completion
- Hands-on exercises & projects
- Self-paced learning
- English captions on all videos
- Cancel anytime