Programming Languages


JavaScript Algorithms and Data Structures Masterclass

The Missing Computer Science and Coding Interview Bootcamp

4.71 (12866 reviews)



22 hours


Nov 2018

Last Update
Regular Price

What you will learn

Learn everything you need to ace difficult coding interviews

Master dozens of popular algorithms, including 6 sorting algorithms!

Implement 10+ data structures from scratch

Improve your problem solving skills and become a stronger developer


Updated in November 2018 with brand new section on Dynamic Programming!

This course crams months of computer science and interview prep material into 20 hours of video. The content is based directly on last semester of my in-person coding bootcamps, where my students go on to land 6-figure developer jobs. I cover the exact same computer science content that has helped my students ace interviews at huge companies like Google, Tesla, Amazon, and Facebook. Nothing is watered down for an online audience; this is the real deal :)   We start with the basics and then eventually cover “advanced topics” that similar courses shy away from like Heaps, Graphs, and Dijkstra’s Shortest Path Algorithm

I start by teaching you how to analyze your code’s time and space complexity using Big O notation.  We cover the ins and outs of Recursion.  We learn a 5-step approach to solving any difficult coding problem. We cover common programming patterns. We implement popular searching algorithms. We write 6 different sorting algorithms: Bubble, Selection, Insertion, Quick, Merge, and Radix Sort.   Then, we switch gears and implement our own data structures from scratch, including linked lists, trees, heaps, hash tables, and graphs.  We learn to traverse trees and graphs, and cover Dijkstra's Shortest Path Algorithm.  The course also includes an entire section devoted to Dynamic Programming.

Here's why this course is worth your time:

  • It's interactive -  I give you a chance to try every problem before I show you my solution.

  • Every single problem has a complete solution walkthrough video as well as accompanying solution file.

  • I cover helpful "tips and tricks" to solve common problems, but we also focus on building an approach to ANY problem.

  • It's full of animations and beautiful diagrams!

Are you looking to level-up your developer skills? Sign up today!


JavaScript Algorithms and Data Structures Masterclass
JavaScript Algorithms and Data Structures Masterclass
JavaScript Algorithms and Data Structures Masterclass
JavaScript Algorithms and Data Structures Masterclass



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


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


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


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


Frequency Counter - sameFrequency

Frequency Counter / Multiple Pointers - areThereDuplicates


Multiple Pointers - averagePair

Multiple Pointers - isSubsequence


Sliding Window - maxSubarraySum

Sliding Window - minSubArrayLen

Sliding Window - findLongestSubstring




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








Bonus CHALLENGING Recursion Problems













Searching Algorithms


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


Bubble Sort


Introduction to Sorting Algorithms

Built-In JavaScript Sorting

Bubble Sort: Overview

Bubble Sort: Implementation

Bubble Sort: Optimization

Bubble Sort: BIG O Complexity

Selection Sort


Selection Sort: Introduction

Selection Sort: Implementation

Selection Sort: Big O Complexity

Insertion Sort


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


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


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


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


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


Doubly Linked Lists Introduction

Setting Up Our Node Class


Push Solution


Pop Solution


Shift Solution


Unshift Solution


Get Solution


Set Solution


Insert Solution


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


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


Introduction to Trees

Uses For Trees

Intro to Binary Trees


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


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


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


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



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


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!


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


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


Pratap9 October 2020

I am developer with no background in Computer Science and this course has elevated my developer skills. I always wondered to find out the right material to crack the coding interviews and this course is it. Although this course might not be good enough to crack the coding the interviews by tech giants like Google, Facebook, Amazon, Apple, Tesla ... but it would definitely help you to crack peer-peer coding interviews by all other companies and boosts your confidence. I wish there is more stuff on Dynamic Programming because there are some tech companies out there which concentrate their interviews on DP, ofCourse I can't expect everything to be in the same course. This course will help those individuals without any prior knowledge on Algorithms and Datastructures just like me. In a brief, Colt Steele has done a wonderful job in designing this course and I look forward following new updates on this course and new courses of him.

Tamer6 October 2020

This is a 2 year old course but there are some section that are never really finished. But overall very informative.

Ravi29 September 2020

A little slow/simple up to now, as I have done this before...just trying to retool after long time in management

Tim28 September 2020

Yea. The instruction from the teacher is real clear and concise. The examples are great. Soaking up a lot here. Hoping I get a job offer :) :) :)

Priyansh27 September 2020

There is no support on this course, Its been more than a week and still no answer to the questions I asked.

Gerome25 February 2020

Having taken an algorithms course before at uni, it puts me at ease that hes covering all the gotchas that I'm aware of. He also takes time to explain concepts in a way that isn't overly scientific, to build up a baseline before referencing what he did, and that he uses tools that are relevant to the problem space.

Leo23 February 2020

Very excited to learn data structure and algorithms from an awesome instructor like Colt! His approach to explaining complex things is world-class.

Troy19 February 2020

Took a boot camp course that really didn't cover algorithms and data structures in detail. Found this course to be the missing piece of my CS knowledge. Colt is an excellent teacher, he thoroughly covers each subject without making it boring. He has some great suggestions for general problem solving, interview prep, and the clearest explanation I have come across for understanding Big O. If you went to a boot camp you need this course if you need a way to brush up on your skills you won't regret this course.

Kieran15 February 2020

I'm using the course as a primer for an upcoming university-level algorithms and data structures subject. I'm finding Colt's teaching style is making it very easy to grasp the concepts I have learnt so far. I've even been able to start using his problem-solving approach when facing issues in my side projects. Excellent work from the teacher, I will no doubt be using it as a learning resource next semester.

Hashim13 February 2020

Instructions are clear and concise. I have a degree in computer science, but we never practiced problems or prepared for interviews

Dhirendra13 February 2020

not that tough u know most ppl here have done stuff b4 all they want is to do a lot of math and little bit of theory but i guess all u guys offer is explain log, and search, not gonna help us understand an algo is it.

Fernando12 February 2020

The exercises were wrong implemented sometimes, so you had to focus on not only making the exercise, but correcting the already added code. This is a course for beginner to intermediate programmer. Overall grate course.

Nf11 February 2020

It's REALLY long but very thorough. It's the basis for many questions/meetups I go to and has plenty of real world applications.

Pallavi8 February 2020

I can say know I've got an idea of what Big O notation is this is amazing. I'm definitely going to calculate this on my every algorithm.

Connor3 February 2020

Colt is a wonderful teacher who thoroughly explains everything you need to know, even for such complex data structures and algorithms. I would recommend this course to anyone.


Udemy ID


Course created date


Course Indexed date
Course Submitted by

Android PlayStore
Apple Appstore