JavaScript Data Structures – The Fundamentals

JavaScript Data Structures – The Fundamentals
JavaScript Data Structures – The Fundamentals

English | MP4 | AVC 1920×1080 | AAC 44KHz 2ch | 9h 03m | 1.72 MB
eLearning | Skill level: All Levels


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.

When working with JavaScript, you’ll work with data structures all the time.

That includes built-in ones like Arrays, Objects, Maps or Sets but – especially if you dive deeper into JavaScript – also custom data structures like Linked Lists, Trees or Graphs.

This course covers it all!

We’ll recap the basic built-in data structures to understand how they work and when to use them, before we then explore important custom data structures.

In detail, this course covers the following structures:

  • Arrays (built-in)
  • Objects (built-in)
  • Sets (built-in)
  • Maps (built-in)
  • Linked Lists (custom)
  • Stacks (custom)
  • Queues (custom)
  • Hash Tables (custom)
  • Basic Trees (custom)
  • Binary Search Trees (BST, custom)
  • AVL Trees (custom)
  • Priority Queues (custom)
  • Heaps (custom)
  • Graphs (custom

You will learn how those different data structures work, when they might be helpful, how to build them and of course we’ll also explore their time complexity (Big O notation)!

You’ll get both the theory as well as practical examples to ensure that you fully understand all those key structures and you’re able to work with them on your own after you finished this course – no matter if you need them for your next project or simply to ace an upcoming job interview!

To get the most out of this course, you should ensure that you have a basic understanding of JavaScript algorithms and that you especially understand the concept of time complexity and “Big O” notation. In case you’re missing those prerequisites right now, you can explore our Algorithms course!

+ Table of Contents

1 Welcome to the Course!
2 What are “Data Structures”?
3 Arrays: Recap
4 Sets: Recap
5 Arrays vs Sets
6 Objects: Recap
7 Maps: Recap
8 Objects vs Maps
9 WeakSet and WeakMap
10 Linked Lists (A First Custom Data Structures)
11 Starting with Linked Lists and “append”
12 Outputting the Linked List
13 Prepend to Linked Lists
14 Deleting Nodes
15 “find” and “insertAfter”
16 Linked Lists: Why and Time Complexity
17 Linked Lists vs Arrays
18 Module Introduction
19 What are “Lists” and “Tables”?
20 Built-in Lists and Tables
21 Introducing “Stacks”
22 Building a “Stack” Data Structure
23 Considering a Linked List Stack
24 Stacks with Linked Lists
25 Stacks: Time Complexity
26 Introducing Queues
27 Building a Queue
28 Linked Lists & Queues
29 Queue Time Complexity
30 Introducing Hash Tables
31 Why we need Tables
32 Building a Basic Hash Table
33 Understanding Hash Collisions
34 Solving Collisions with Chaining
35 Solving Collisions with Open Addressing
36 Hash Tables: Time Complexity
37 Hash Tables: Summary
38 Module Introduction
39 What are “Trees”?
40 Core Terminology
41 An Example Tree
42 A First Tree in Code
43 A Better Filesystem Tree
44 Removing Tree Nodes
45 Describing Our Tree
46 Trees: Time Complexity
47 Depth-first vs Breadth-first Search
48 Implementing Depth-first Search
49 Implementing Breadth-first Search
50 Depth-first Search vs Breadth-first Search
51 Introducing Binary Search Trees (BST)
52 Adding Values to BST
53 Finding Values in BST
54 Removing Leaf Nodes in BST
55 Removing “One-Child” Nodes in BST
56 Removing “Multi-Child” Nodes in BST
57 BST Time Complexity
58 Introducing AVL Trees
59 Balancing Trees with Rotations
60 Understanding Balance Factors
61 Adding Depth and Balance Factors
62 Finding the Right Rotation
63 Implementing Left Rotation
64 Implementing Right Rotation
65 Implementing Left-Right Rotation
66 Implementing Right-Left Rotation
67 Testing the AVL Tree
68 AVL vs BST
69 Introducing Tries
70 Building a Trie
71 Finding Nodes in a Trie
72 Deleting Keys
73 Tries: Time Complexity and Comparison to Hash Tables
74 Module Introduction
75 Understanding Priority Queues
76 Building a Regular Queue
77 Priority Queues & Time Complexity
78 Building a Basic Priority Queue
79 Introducing Heaps
80 Exploring the Heap Concept
81 Building a Heap
82 Processing Items
83 A Heap-based Priority Queue
84 Heaps & Time Complexity
85 Module Introduction
86 Graphs: What and Why?
87 Graphs with an Adjacency Matrix
88 Using Adjacency Lists Instead
89 Adjacency Lists vs Matrices
90 Building a Graph Structure
91 Adding Graph Methods
92 Removing Nodes & Edges
93 Using Sets in Graphs
94 Summary
95 Building a Social Network Graph