Data Structures in JavaScript: Master The Fundamentals

Course Curriculum

Chapter 1: Introduction

Lecture 1: Introduction

Chapter 2: Arrays

Lecture 1: Arrays vs Lists

Lecture 2: Common Array Iterations

Lecture 3: Pairwise Array Comparisons

Lecture 4: Array Functions

Lecture 5: Searching Arrays

Lecture 6: Is Sorted Challenge

Lecture 7: Is Sorted Solution

Lecture 8: 2d Arrays

Lecture 9: Iterating Over 2d Arrays

Lecture 10: 2d Bounds Checking

Lecture 11: Minesweeper Challenge

Lecture 12: Mnesweeper Solution

Lecture 13: Tally Sort Challenge

Lecture 14: Tally Sort Solution

Chapter 3: Lists

Lecture 1: Lists Out of Arrays

Lecture 2: Implementing List Push and Grow

Lecture 3: Implementing List Remove

Lecture 4: Implement List Insert

Lecture 5: List Contains Challenge

Lecture 6: List Contains Solution

Lecture 7: List Get and Set

Lecture 8: Concat Challenge

Lecture 9: Concat Solution

Chapter 4: Big o Time Space Asymptotic Analysis

Lecture 1: Intro to Big o

Lecture 2: Big o of n Squared

Lecture 3: Timing Big o of one Versus n Versus n Squared

Lecture 4: No Constants- n Big o Notation

Lecture 5: Big o Challenge

Lecture 6: Big o Solution

Chapter 5: Linked Lists

Lecture 1: Linked Lists

Lecture 2: Coding Linked Lists

Lecture 3: Linked List Manipulation Challenge

Lecture 4: Linked List Manipulation Solution

Lecture 5: Linked List Class

Lecture 6: Get at Index

Lecture 7: Remove at Index

Lecture 8: Add at Index

Lecture 9: Summarizing Arrays vs Linked Lists

Lecture 10: Prefer Manipulating Pointers to Copying Data

Chapter 6: Stacks

Lecture 1: Intro to Stacks

Lecture 2: Stack Implementations

Lecture 3: Stack out of Linked List

Lecture 4: Stack out of Array

Lecture 5: Balance Parenthesis Challenge

Lecture 6: Balance Parenthesis Solution

Lecture 7: Paren Bracket Curly Balance Challenge

Lecture 8: Paren Bracket Curly Balance Solution

Lecture 9: Condense Challenge

Lecture 10: Condense Inefficient Solution

Lecture 11: Condense Efficient Solution

Chapter 7: Queues

Lecture 1: Intro to Queues

Lecture 2: Implementing a Queue

Lecture 3: Josephus Challenge

Lecture 4: Josephus Solution

Lecture 5: Sieve of Eratosthenes Challenge

Lecture 6: Sieve of Eratosthenes Solution

Lecture 7: Native js Arrays Stacks and Queues

Chapter 8: Recursion

Lecture 1: Intro to Recursion

Lecture 2: Recursive Fibonacci

Lecture 3: Palindrome Challenge

Lecture 4: Palindrome Hints

Lecture 5: Palindrome Solution

Lecture 6: Palindrome Bonus

Chapter 9: Trees

Lecture 1: Intro to Trees

Lecture 2: Iterating Over Trees

Lecture 3: Tree Sum Challenge

Lecture 4: Tree Sum Solution

Lecture 5: Tree Contains Challenge

Lecture 6: Tree Contains Solution

Lecture 7: Tree Size Leaves Challenge

Lecture 8: Tree Size Leaves Solution

Lecture 9: Tree Min Max Height Challenge

Lecture 10: Tree Min Max Height Solution

Lecture 11: Binary Search Trees

Lecture 12: Binary Search Tree Add

Lecture 13: Binay Search Tree Contains Challenge

Lecture 14: Binary Search Tree Contains Solution

Lecture 15: Unbalanced Binary Search Trees

Lecture 16: Morse Code Challenge

Lecture 17: Morse Code Solution

Chapter 10: Hash Maps

Lecture 1: Intro to Hash Maps

Lecture 2: Handling Collisions with Linear Probing

Lecture 3: Handling Collisions by Chaining Linked Lists

Lecture 4: Coding Linked List Collisions

Chapter 11: Graphs

Lecture 1: Intro to Graphs

Lecture 2: Coding a Graph Class

Lecture 3: Breadth First and Depth First Traversals