JavaScript Algorithms and Data Structures Masterclass 

Curriculum Walkthrough

What Order Should You Watch In?

How I'm Running My Code

Intro to Big O

Timing Our Code

Counting Operations

Visualizing Time Complexities

Official Intro to Big O

Simplifying Big O Expressions

Space Complexity

Logs and Section Recap

PREREQUISITES

Section Introduction

The BIG O of Objects

When are Arrays Slow?

Big O of Array Methods

PREREQUISITES

Introduction to Problem Solving

Step 1: Understand The Problem

Step 2: Concrete Examples

Step 3: Break It Down

Step 4: Solve Or Simplify

Step 5: Look Back and Refactor

Recap and Interview Strategies

PREREQUISITES

Intro to Problem Solving Patterns

Frequency Counter Pattern

Frequency Counter: Anagram Challenge

Anagram Challenge Solution

Multiple Pointers Pattern

Multiple Pointers: Count Unique Values Challenge

Count Unique Values Solution

Sliding Window Pattern

Divide And Conquer Pattern

IMPORTANT NOTE!

SOLUTIONS PART 1

SOLUTIONS PART 2

SOLUTIONS PART 3

PREREQUISITES

Story Time: Martin & The Dragon

Why Use Recursion?

The Call Stack

Our First Recursive Function

Our Second Recursive Function

Writing Factorial Iteratively

Writing Factorial Recursively

Common Recursion Pitfalls

Helper Method Recursion

Pure Recursion

START HERE!

SOLUTIONS FOR THIS SECTION

NOTE ON THIS SECTION

SOLUTIONS PART 1

SOLUTIONS PART 2

PREREQUISITES

Intro to Searching

Intro to Linear Search

Linear Search Solution

Linear Search BIG O

Intro to Binary Search

Binary Search PseudoCode

Binary Search Solution

Binary Search BIG O

Naive String Search

Naive String Search Implementation

KNP COMING SOON

PREREQUISITES

Introduction to Sorting Algorithms

Built-In JavaScript Sorting

Bubble Sort: Overview

Bubble Sort: Implementation

Bubble Sort: Optimization

Bubble Sort: BIG O Complexity

PREREQUISITES

Selection Sort: Introduction

Selection Sort: Implementation

Selection Sort: Big O Complexity

PREREQUISITES

Insertion Sort: Introduction

Insertion Sort: Implementation

Insertion Sort: BIG O Complexity

Comparing Bubble, Selection, and Insertion Sort

PREREQUISITES

Intro to the "Crazier" Sorts

Merge Sort: Introduction

Merging Arrays Intro

Merging Arrays: Implementation

Writing Merge Sort Part 1

Writing Merge Sort Part 2

Merge Sort BIG O Complexity

PREREQUISITES

Introduction to Quick Sort

Pivot Helper Introduction

Pivot Helper Implementation

Quick Sort Implementation

Quick Sort Call Stack Walkthrough

Quick Sort Big O Complexity

PREREQUISITES

Radix Sort: Introduction

Radix Sort: Helper Methods

Radix Sort: Pseudocode

Radix Sort: Implementation

Radix Sort: BIG O Complexity

Which Data Structure Is The Best?

ES2015 Class Syntax Overview

Data Structures: The Class Keyword

Data Structures: Adding Instance Methods

Data Structures: Adding Class Methods

PREREQUISITES

Intro to Singly Linked Lists

Starter Code and Push Intro

Singly Linked List: Push Solution

Singly Linked List: Pop Intro

Singly Linked List: Pop Solution

Singly Linked List: Shift Intro

Singly Linked List: Shift Solution

Singly Linked List: Unshift Intro

Singly Linked List: Unshift Solution

Singly Linked List: Get Intro

Singly Linked List: Get Solution

Singly Linked List: Set Intro

Singly Linked List: Set Solution

Singly Linked List: Insert Intro

Singly Linked List: Insert Solution

Singly Linked List: Remove Intro

Singly Linked List: Remove Solution

Singly Linked List: Reverse Intro

Singly Linked List: Reverse Solution

Singly Linked List: BIG O Complexity

PREREQUISITES

Doubly Linked Lists Introduction

Setting Up Our Node Class

Push

Push Solution

Pop

Pop Solution

Shift

Shift Solution

Unshift

Unshift Solution

Get

Get Solution

Set

Set Solution

Insert

Insert Solution

Remove

Remove Solution

Comparing Singly and Doubly Linked Lists

PREREQUISITES

Intro to Stacks

Creating a Stack with an Array

Writing Our Own Stack From Scratch

BIG O of Stacks

Intro to Queues

Creating Queues Using Arrays

Writing Our Own Queue From Scratch

BIG O of Queues

PREREQUISITES

Introduction to Trees

Uses For Trees

Intro to Binary Trees

POP QUIZ!

Searching A Binary Search Tree

Our Tree Classes

BST: Insert

BST: Insert Solution

BST: Find

BST: Find Solution

Big O of Binary Search Trees

PREREQUISITES

Intro To Tree Traversal

Breadth First Search Intro

Breadth First Search Solution

Depth First PreOrder Intro

Depth First PreOrder Solution

Depth First PostOrder Intro

Depth First PostOrder Solution

Depth First InOrder Intro

Depth First InOrder Solution

When to Use BFS and DFS

PREREQUISITES

Intro to Heaps

Storing Heaps

Heap: Insert Intro

Heap: Insert Solution

Heap: ExtractMax Intro

Heap: ExtractMax Solution

Priority Queue Intro

Priority Queue Pseudocode

Priority Queue Solution

BIG O of Binary Heaps

PREREQUISITES

Intro to Hash Tables

More About Hash Tables

Intro to Hash Functions

Writing Our First Hash Function

Improving Our Hash Function

Handling Collisions

Hash Table Set and Get

Hash Table Set Solution

Hash Table Get Solution

Hash Table Keys and Values

Hash Table Keys and Values Solution

Hash Table Big O Complexity

PREREQUISITES

Intro to Graphs

Uses for Graphs

Types of Graphs

Storing Graphs: Adjacency Matrix

Storing Graphs: Adjacency List

Adjacency Matrix Vs. List BIG O

Add Vertex Intro

Add Vertex Solution

Add Edge Intro

Add Edge Solution

Remove Edge Intro

Remove Edge Solution

Remove Vertex Intro

Remove Vertex Solution

PREREQUISITES

Intro to Graph Traversal

Depth First Graph Traversal

DFS Recursive Intro

DFS Recursive Solution

DFS Iterative Intro

DFS Iterative Solution

Breadth First Graph Traversal

BFS Intro

BFS Solution

PREREQUISITES

Intro to Dijkstra's and Prerequisites

Who was Dijkstra and what is his Algorithm?

Writing a Weighted Graph

Walking through the Algorithm

Introducing Our Simple Priority Queue

Dijkstra's Pseudo-Code

Implementing Dijkstra's Algorithm

Upgrading the Priority Queue

Intro to Dynamic Programming

Overlapping Subproblems

Optimal Substructure

Writing A Recursive Solution

Time Complexity of Our Solution

The Problem With Our Solution

Enter Memoization!

Time Complexity of Memoized Solution

Tabulation: A Bottom Up Approach

VERY IMPORTANT NOTE! PLEASE READ!