JavaScript Algorithms and Data Structures Masterclass

Introduction

Curriculum Walkthrough

What Order Should You Watch In?

How I'm Running My Code

Big O Notation

Intro to Big O

Timing Our Code

Counting Operations

Visualizing Time Complexities

Official Intro to Big O

Simplifying Big O Expressions

Big O Time Complexity Quiz

Big O Time Complexity Quiz 2

Space Complexity

Big O Space Complexity Quiz

Logs and Section Recap

Analyzing Performance of Arrays and Objects

PREREQUISITES

Section Introduction

The BIG O of Objects

Object Operations Quiz

When are Arrays Slow?

Big O of Array Methods

Array Operations Quiz

Problem Solving Approach

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

Problem Solving Patterns

PREREQUISITES

Intro to Problem Solving Patterns

Frequency Counter Pattern

Frequency Counter: Anagram Challenge

Frequency Counter - validAnagram

Anagram Challenge Solution

Multiple Pointers Pattern

Multiple Pointers: Count Unique Values Challenge

Multiple Pointers - countUniqueValues

Count Unique Values Solution

Sliding Window Pattern

Divide And Conquer Pattern

100% OPTIONAL Challenges

IMPORTANT NOTE!

Frequency Counter - sameFrequency

Frequency Counter / Multiple Pointers - areThereDuplicates

SOLUTIONS PART 1

Multiple Pointers - averagePair

Multiple Pointers - isSubsequence

SOLUTIONS PART 2

Sliding Window - maxSubarraySum

Sliding Window - minSubArrayLen

Sliding Window - findLongestSubstring

SOLUTIONS PART 3

Recursion

PREREQUISITES

Story Time: Martin & The Dragon

Why Use Recursion?

The Call Stack

Our First Recursive Function

Recursion Quiz

Our Second Recursive Function

Writing Factorial Iteratively

Writing Factorial Recursively

Common Recursion Pitfalls

Helper Method Recursion

Pure Recursion

Recursion Problem Set

START HERE!

power

factorial

productOfArray

recursiveRange

fib

SOLUTIONS FOR THIS SECTION

Bonus CHALLENGING Recursion Problems

NOTE ON THIS SECTION

reverse

isPalindrome

someRecursive

flatten

SOLUTIONS PART 1

capitalizeFirst

nestedEvenSum

capitalizeWords

stringifyNumbers

collectStrings

SOLUTIONS PART 2

Searching Algorithms

PREREQUISITES

Intro to Searching

Intro to Linear Search

Linear Search Exercise

Linear Search Solution

Linear Search BIG O

Intro to Binary Search

Binary Search PseudoCode

Binary Search Exercise

Binary Search Solution

Binary Search BIG O

Naive String Search

Naive String Search Implementation

KNP COMING SOON

Bubble Sort

PREREQUISITES

Introduction to Sorting Algorithms

Built-In JavaScript Sorting

Bubble Sort: Overview

Bubble Sort: Implementation

Bubble Sort: Optimization

Bubble Sort: BIG O Complexity

Selection Sort

PREREQUISITES

Selection Sort: Introduction

Selection Sort: Implementation

Selection Sort: Big O Complexity

Insertion Sort

PREREQUISITES

Insertion Sort: Introduction

Insertion Sort: Implementation

Insertion Sort: BIG O Complexity

Comparing Bubble, Selection, and Insertion Sort

Comparing Bubble, Selection, and Insertion Sort

Merge 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

Quick Sort

PREREQUISITES

Introduction to Quick Sort

Pivot Helper Introduction

Pivot Helper Implementation

Quick Sort Implementation

Quick Sort Call Stack Walkthrough

Quick Sort Big O Complexity

Radix Sort

PREREQUISITES

Radix Sort: Introduction

Radix Sort: Helper Methods

Radix Sort: Pseudocode

Radix Sort: Implementation

Radix Sort: BIG O Complexity

Data Structures Introduction

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

Singly Linked Lists

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

Doubly Linked Lists

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

DLL push - Exercise

DLL unshift - Exercise

DLL shift - Exercise

DLL set - Exercise

DLL- remove Exercise

DLL pop - Exercise

DLL get - Exercise

Doubly Linked Lists insert / remove - Exercise

DLL reverse - Exercise

Stacks + Queues

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

Binary Search Trees

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

Tree Traversal

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

Binary Heaps

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

Hash Tables

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

Graphs

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

Graph Traversal

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

Dijkstra's Algorithm!

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

Dynamic Programming

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

The Wild West

VERY IMPORTANT NOTE! PLEASE READ!

SLL - push Exercise

SLL - pop exercise

SLL - get Exercise

SLL - insert Exercise

SLL - Rotate Exercise

SLL - set Exercise

Divide and Conquer - countZeroes

Divide and Conquer - sortedFrequency

Divide and Conquer - findRotatedIndex

Bubble Sort

Selection Sort

SLL - remove Exercise

Insertion Sort

Sorting Exercise - merge helper

Merge Sort

Sorting Exercise - pivot helper

Quick Sort

Radix Sort Helper - getDigit

Radix Sort Helper - digitCount

Radix Sort Helper - mostDigits

Radix Sort

Stacks - push Exercise

Stacks - pop Exercise

Stack with 2 Queues

Queues - enqueue Exercise

Binary Search Tree - insert Exercise

BinarySearchTree - find

Binary Search Tree - DFS Exercise

Binary Search Tree - BFS Exercise

Binary Search Tree - remove Exercise

Binary Search Tree Exercise - Find 2nd largest node

Binary Search Tree Exercise - Check if balanced

BinaryHeap - insert Exercise

BinaryHeap - extractMax Exercise

Graphs Exercise - addVertex

Graphs Exercise - removeEdge

Graphs Exercise - removeVertex

Graphs - DFS Exercise

Graphs Exercise - addEdge

Graphs - BFS Exercise

Graphs - Dijkstra Exercise

Dynamic Programming - Coin Change

Coin Change - Greedy Algorithm

Frequency Counter - constructNote

Frequency Counter - findAllDuplicates

Frequency Counter / Multiple Pointer - findPair

Trie Exercise - addWord

Trie Exercise - removeWord

Trie Exercise - findWord

Trie Exercise - getWords

Trie - autocomplete