4.71 (12866 reviews)
☑ 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!
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
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.
This is a 2 year old course but there are some section that are never really finished. But overall very informative.
A little slow/simple up to now, as I have done this before...just trying to retool after long time in management
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 :) :) :)
There is no support on this course, Its been more than a week and still no answer to the questions I asked.
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.
Very excited to learn data structure and algorithms from an awesome instructor like Colt! His approach to explaining complex things is world-class.
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.
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.
Instructions are clear and concise. I have a degree in computer science, but we never practiced problems or prepared for interviews
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.
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.
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.
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.
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.