w3docs logo
Iniciar sesión

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.

Start
  1. Courses
  3. JavaScript Data Structures - The Fundamentals

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!

Section: Getting Started

1. Welcome to the Course! (1:11)
2. What are "Data Structures"? (4:58)
3. Course Resources (1:00)
4. Arrays: Recap (8:57)
5. Sets: Recap (5:46)
6. Arrays vs Sets (1:34)
7. Objects: Recap (7:05)
8. Maps: Recap (7:37)
9. Objects vs Maps (1:43)
10. WeakSet and WeakMap (2:16)
11. Linked Lists (A First Custom Data Structures) (2:46)
12. Starting with Linked Lists and "append" (13:19)
13. Outputting the Linked List (4:58)
14. Prepend to Linked Lists (4:09)
15. Deleting Nodes (10:31)
16. "find" and "insertAfter" (6:56)
17. Linked Lists: Why and Time Complexity (5:28)
18. Linked Lists vs Arrays (7:06)
19. Module Resources (1:00)

Section: Lists & Tables

20. Module Introduction (0:55)
21. What are "Lists" and "Tables"? (4:22)
22. Built-in Lists and Tables (3:42)
23. Introducing "Stacks" (5:51)
24. Building a "Stack" Data Structure (7:01)
25. Considering a Linked List Stack (2:41)
26. Stacks with Linked Lists (9:12)
27. Stacks: Time Complexity (4:50)
28. Introducing Queues (3:24)
29. Building a Queue (4:34)
30. Linked Lists & Queues (5:09)
31. Queue Time Complexity (4:45)
32. Introducing Hash Tables (4:18)
33. Why we need Tables (9:54)
34. Building a Basic Hash Table (12:20)
35. Understanding Hash Collisions (4:58)
36. Solving Collisions with Chaining (11:51)
37. Solving Collisions with Open Addressing (10:42)
38. Hash Tables: Time Complexity (7:04)
39. Hash Tables: Summary (4:46)
40. Module Resources (1:00)

Section: Trees

41. Module Introduction (1:35)
42. What are "Trees"? (3:28)
43. Core Terminology (8:58)
44. An Example Tree (2:43)
45. A First Tree in Code (11:16)
46. A Better Filesystem Tree (14:10)
47. Removing Tree Nodes (7:06)
48. Describing Our Tree (6:49)
49. Trees: Time Complexity (4:42)
50. Depth-first vs Breadth-first Search (2:21)
51. Implementing Depth-first Search (6:01)
52. Implementing Breadth-first Search (3:27)
53. Depth-first Search vs Breadth-first Search (5:06)
54. Introducing Binary Search Trees (BST) (3:34)
55. Adding Values to BST (6:27)
56. Finding Values in BST (10:13)
57. Removing Leaf Nodes in BST (7:46)
58. Removing "One-Child" Nodes in BST (5:12)
59. Removing "Multi-Child" Nodes in BST (12:09)
60. BST Time Complexity (3:38)
61. Introducing AVL Trees (3:08)
62. Balancing Trees with Rotations (4:05)
63. Understanding Balance Factors (2:59)
64. Adding Depth and Balance Factors (6:25)
65. Finding the Right Rotation (8:07)
66. Implementing Left Rotation (9:50)
67. Implementing Right Rotation (3:21)
68. Implementing Left-Right Rotation (8:10)
69. Implementing Right-Left Rotation (3:28)
70. Testing the AVL Tree (3:06)
71. AVL vs BST (1:05)
72. Introducing Tries (3:35)
73. Building a Trie (12:01)
74. Finding Nodes in a Trie (3:24)
75. Deleting Keys (3:57)
76. Tries: Time Complexity and Comparison to Hash Tables (5:41)
77. Module Resources (1:00)

Section: Priority Queues & Heaps

78. Module Introduction (0:37)
79. Understanding Priority Queues (2:03)
80. Building a Regular Queue (4:22)
81. Priority Queues & Time Complexity (2:07)
82. Building a Basic Priority Queue (7:33)
83. Introducing Heaps (3:22)
84. Exploring the Heap Concept (5:50)
85. Building a Heap (11:20)
86. Processing Items (11:51)
87. A Heap-based Priority Queue (4:34)
88. Heaps & Time Complexity (5:53)
89. Module Resources (1:00)

Section: Graphs

90. Module Introduction (0:37)
91. Graphs: What and Why? (6:01)
92. Graphs with an Adjacency Matrix (9:56)
93. Using Adjacency Lists Instead (4:27)
94. Adjacency Lists vs Matrices (5:44)
95. Building a Graph Structure (7:06)
96. Adding Graph Methods (7:01)
97. Removing Nodes & Edges (10:47)
98. Using Sets in Graphs (7:14)
99. Summary (1:08)
100. Building a Social Network Graph (5:53)
101. Module Resources (1:00)

Section: Summary & Next Steps

102. Course Slides (1:00)
103. Next Steps (1:00)

Course Instructor

Image

Maximilian Schwarzmüller

As a self-taught professional I really know the hard parts and the difficult topics when learning new or improving on already-known languages. This background and experience enable me to focus on the most relevant key concepts and topics. My track record of many 5-star rated courses, more than 1,000,000 students worldwide as well as a successful YouTube channel is the best proof for that.

The most rewarding experience for me is to see how people find new, better jobs, build awesome web applications, work on amazing projects or simply enjoy their hobby with the help of my content. That's why, together with Manuel Lorenz, I founded Academind to offer the best possible learning experience and to share the pleasure of learning with our students.