Mô tả

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!

Bạn sẽ học được gì

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

Yêu cầu

  • Basic knowledge of JavaScript syntax
  • NO experience with data structures or computer science needed!

Nội dung khoá học

30 sections

Introduction

4 lectures
Curriculum Walkthrough
07:43
Join The Community!
00:19
What Order Should You Watch In?
02:52
How I'm Running My Code
03:21

Big O Notation

11 lectures
Intro to Big O
07:41
Timing Our Code
10:19
Counting Operations
04:36
Visualizing Time Complexities
04:25
Official Intro to Big O
09:58
Simplifying Big O Expressions
09:32
Big O Time Complexity Quiz
5 questions
Big O Time Complexity Quiz 2
5 questions
Space Complexity
06:26
Big O Space Complexity Quiz
5 questions
Logs and Section Recap
08:46

Analyzing Performance of Arrays and Objects

7 lectures
PREREQUISITES
00:05
Section Introduction
01:42
The BIG O of Objects
05:31
Object Operations Quiz
3 questions
When are Arrays Slow?
06:25
Big O of Array Methods
05:56
Array Operations Quiz
3 questions

Problem Solving Approach

8 lectures
PREREQUISITES
00:05
Introduction to Problem Solving
07:08
Step 1: Understand The Problem
07:59
Step 2: Concrete Examples
06:19
Step 3: Break It Down
07:44
Step 4: Solve Or Simplify
10:32
Step 5: Look Back and Refactor
16:57
Recap and Interview Strategies
04:12

Problem Solving Patterns

12 lectures
PREREQUISITES
00:06
Intro to Problem Solving Patterns
02:55
Frequency Counter Pattern
15:11
Frequency Counter: Anagram Challenge
02:33
Frequency Counter - validAnagram
1 question
Anagram Challenge Solution
06:18
Multiple Pointers Pattern
09:42
Multiple Pointers: Count Unique Values Challenge
04:29
Multiple Pointers - countUniqueValues
1 question
Count Unique Values Solution
06:30
Sliding Window Pattern
13:14
Divide And Conquer Pattern
07:02

100% OPTIONAL Challenges

11 lectures
IMPORTANT NOTE!
00:14
Frequency Counter - sameFrequency
1 question
Frequency Counter / Multiple Pointers - areThereDuplicates
1 question
SOLUTIONS PART 1
00:33
Multiple Pointers - averagePair
1 question
Multiple Pointers - isSubsequence
1 question
SOLUTIONS PART 2
00:21
Sliding Window - maxSubarraySum
1 question
Sliding Window - minSubArrayLen
1 question
Sliding Window - findLongestSubstring
1 question
SOLUTIONS PART 3
00:48

Recursion

12 lectures
PREREQUISITES
00:05
Story Time: Martin & The Dragon
07:06
Why Use Recursion?
05:53
The Call Stack
07:07
Our First Recursive Function
05:11
Recursion Quiz
2 questions
Our Second Recursive Function
07:54
Writing Factorial Iteratively
02:19
Writing Factorial Recursively
03:15
Common Recursion Pitfalls
05:06
Helper Method Recursion
06:23
Pure Recursion
07:45

Recursion Problem Set

7 lectures
START HERE!
00:12
power
1 question
factorial
1 question
productOfArray
1 question
recursiveRange
1 question
fib
1 question
SOLUTIONS FOR THIS SECTION
00:15

Bonus CHALLENGING Recursion Problems

12 lectures
NOTE ON THIS SECTION
00:11
reverse
1 question
isPalindrome
1 question
someRecursive
1 question
flatten
1 question
SOLUTIONS PART 1
00:16
capitalizeFirst
1 question
nestedEvenSum
1 question
capitalizeWords
1 question
stringifyNumbers
1 question
collectStrings
1 question
SOLUTIONS PART 2
00:45

Searching Algorithms

13 lectures
PREREQUISITES
00:05
Intro to Searching
04:04
Intro to Linear Search
04:47
Linear Search Exercise
1 question
Linear Search Solution
05:18
Linear Search BIG O
01:55
Intro to Binary Search
05:47
Binary Search PseudoCode
02:40
Binary Search Exercise
1 question
Binary Search Solution
16:41
Binary Search BIG O
06:09
Naive String Search
04:38
Naive String Search Implementation
12:29

Bubble Sort

7 lectures
PREREQUISITES
00:05
Introduction to Sorting Algorithms
08:35
Built-In JavaScript Sorting
04:40
Bubble Sort: Overview
07:21
Bubble Sort: Implementation
09:58
Bubble Sort: Optimization
04:22
Bubble Sort: BIG O Complexity
01:28

Selection Sort

4 lectures
PREREQUISITES
00:10
Selection Sort: Introduction
06:18
Selection Sort: Implementation
11:14
Selection Sort: Big O Complexity
01:40

Insertion Sort

4 lectures
PREREQUISITES
00:11
Insertion Sort: Introduction
03:17
Insertion Sort: Implementation
10:42
Insertion Sort: BIG O Complexity
02:24

Comparing Bubble, Selection, and Insertion Sort

1 lectures
Comparing Bubble, Selection, and Insertion Sort
05:33

Merge Sort

8 lectures
PREREQUISITES
00:12
Intro to the "Crazier" Sorts
06:05
Merge Sort: Introduction
05:25
Merging Arrays Intro
05:11
Merging Arrays: Implementation
06:55
Writing Merge Sort Part 1
02:21
Writing Merge Sort Part 2
12:37
Merge Sort BIG O Complexity
06:22

Quick Sort

7 lectures
PREREQUISITES
00:13
Introduction to Quick Sort
09:00
Pivot Helper Introduction
08:06
Pivot Helper Implementation
08:08
Quick Sort Implementation
08:46
Quick Sort Call Stack Walkthrough
04:15
Quick Sort Big O Complexity
04:06

Radix Sort

6 lectures
PREREQUISITES
00:13
Radix Sort: Introduction
09:22
Radix Sort: Helper Methods
11:09
Radix Sort: Pseudocode
04:18
Radix Sort: Implementation
10:24
Radix Sort: BIG O Complexity
03:51

Data Structures Introduction

5 lectures
Which Data Structure Is The Best?
12:38
ES2015 Class Syntax Overview
05:14
Data Structures: The Class Keyword
06:36
Data Structures: Adding Instance Methods
09:49
Data Structures: Adding Class Methods
07:11

Singly Linked Lists

21 lectures
PREREQUISITES
00:06
Intro to Singly Linked Lists
07:46
Starter Code and Push Intro
07:22
Singly Linked List: Push Solution
04:24
Singly Linked List: Pop Intro
06:14
Singly Linked List: Pop Solution
07:35
Singly Linked List: Shift Intro
01:31
Singly Linked List: Shift Solution
03:22
Singly Linked List: Unshift Intro
01:34
Singly Linked List: Unshift Solution
05:58
Singly Linked List: Get Intro
02:32
Singly Linked List: Get Solution
03:32
Singly Linked List: Set Intro
01:26
Singly Linked List: Set Solution
02:10
Singly Linked List: Insert Intro
04:27
Singly Linked List: Insert Solution
07:49
Singly Linked List: Remove Intro
01:56
Singly Linked List: Remove Solution
03:15
Singly Linked List: Reverse Intro
04:46
Singly Linked List: Reverse Solution
08:58
Singly Linked List: BIG O Complexity
05:41

Doubly Linked Lists

29 lectures
PREREQUISITES
00:07
Doubly Linked Lists Introduction
04:43
Setting Up Our Node Class
03:00
Push
02:10
Push Solution
04:04
Pop
03:20
Pop Solution
06:23
Shift
02:44
Shift Solution
04:12
Unshift
01:36
Unshift Solution
02:19
Get
04:02
Get Solution
07:04
Set
01:18
Set Solution
02:08
Insert
02:50
Insert Solution
06:48
Remove
02:18
Remove Solution
06:28
Comparing Singly and Doubly Linked Lists
04:32
DLL push - Exercise
1 question
DLL unshift - Exercise
1 question
DLL shift - Exercise
1 question
DLL set - Exercise
1 question
DLL- remove Exercise
1 question
DLL pop - Exercise
1 question
DLL get - Exercise
1 question
Doubly Linked Lists insert / remove - Exercise
1 question
DLL reverse - Exercise
1 question

Stacks + Queues

9 lectures
PREREQUISITES
00:12
Intro to Stacks
06:19
Creating a Stack with an Array
07:05
Writing Our Own Stack From Scratch
11:33
BIG O of Stacks
02:14
Intro to Queues
04:14
Creating Queues Using Arrays
03:25
Writing Our Own Queue From Scratch
10:24
BIG O of Queues
02:30

Binary Search Trees

12 lectures
PREREQUISITES
00:13
Introduction to Trees
06:45
Uses For Trees
06:32
Intro to Binary Trees
05:54
POP QUIZ!
01:13
Searching A Binary Search Tree
02:55
Our Tree Classes
02:44
BST: Insert
03:50
BST: Insert Solution
11:53
BST: Find
04:42
BST: Find Solution
05:36
Big O of Binary Search Trees
05:58

Tree Traversal

11 lectures
PREREQUISITES
00:14
Intro To Tree Traversal
04:50
Breadth First Search Intro
05:51
Breadth First Search Solution
06:20
Depth First PreOrder Intro
05:37
Depth First PreOrder Solution
06:50
Depth First PostOrder Intro
04:02
Depth First PostOrder Solution
02:38
Depth First InOrder Intro
02:07
Depth First InOrder Solution
02:32
When to Use BFS and DFS
07:37

Binary Heaps

11 lectures
PREREQUISITES
00:15
Intro to Heaps
07:30
Storing Heaps
07:05
Heap: Insert Intro
09:14
Heap: Insert Solution
10:51
Heap: ExtractMax Intro
08:28
Heap: ExtractMax Solution
17:56
Priority Queue Intro
08:59
Priority Queue Pseudocode
03:43
Priority Queue Solution
09:21
BIG O of Binary Heaps
08:54

Hash Tables

13 lectures
PREREQUISITES
00:06
Intro to Hash Tables
05:50
More About Hash Tables
04:32
Intro to Hash Functions
06:11
Writing Our First Hash Function
08:27
Improving Our Hash Function
07:10
Handling Collisions
03:59
Hash Table Set and Get
04:02
Hash Table Set Solution
05:14
Hash Table Get Solution
06:43
Hash Table Keys and Values
01:41
Hash Table Keys and Values Solution
08:43
Hash Table Big O Complexity
05:41

Graphs

15 lectures
PREREQUISITES
00:14
Intro to Graphs
03:50
Uses for Graphs
07:57
Types of Graphs
08:48
Storing Graphs: Adjacency Matrix
03:57
Storing Graphs: Adjacency List
02:29
Adjacency Matrix Vs. List BIG O
05:51
Add Vertex Intro
02:10
Add Vertex Solution
02:54
Add Edge Intro
02:32
Add Edge Solution
02:11
Remove Edge Intro
01:35
Remove Edge Solution
02:41
Remove Vertex Intro
02:35
Remove Vertex Solution
04:34

Graph Traversal

10 lectures
PREREQUISITES
00:16
Intro to Graph Traversal
08:38
Depth First Graph Traversal
08:30
DFS Recursive Intro
07:27
DFS Recursive Solution
12:45
DFS Iterative Intro
03:37
DFS Iterative Solution
08:44
Breadth First Graph Traversal
02:59
BFS Intro
02:27
BFS Solution
08:09

Dijkstra's Algorithm!

9 lectures
PREREQUISITES
00:16
Intro to Dijkstra's and Prerequisites
02:41
Who was Dijkstra and what is his Algorithm?
09:00
Writing a Weighted Graph
05:20
Walking through the Algorithm
16:26
Introducing Our Simple Priority Queue
03:48
Dijkstra's Pseudo-Code
04:28
Implementing Dijkstra's Algorithm
21:18
Upgrading the Priority Queue
01:52

Dynamic Programming

9 lectures
Intro to Dynamic Programming
05:03
Overlapping Subproblems
05:59
Optimal Substructure
06:28
Writing A Recursive Solution
06:43
Time Complexity of Our Solution
04:11
The Problem With Our Solution
03:39
Enter Memoization!
09:00
Time Complexity of Memoized Solution
03:27
Tabulation: A Bottom Up Approach
06:59

The Wild West

52 lectures
VERY IMPORTANT NOTE! PLEASE READ!
00:20
SLL - push Exercise
1 question
SLL - pop exercise
1 question
SLL - get Exercise
1 question
SLL - insert Exercise
1 question
SLL - Rotate Exercise
1 question
SLL - set Exercise
1 question
Divide and Conquer - countZeroes
1 question
Divide and Conquer - sortedFrequency
1 question
Divide and Conquer - findRotatedIndex
1 question
Bubble Sort
1 question
Selection Sort
1 question
SLL - remove Exercise
1 question
Insertion Sort
1 question
Sorting Exercise - merge helper
1 question
Merge Sort
1 question
Sorting Exercise - pivot helper
1 question
Quick Sort
1 question
Radix Sort Helper - getDigit
1 question
Radix Sort Helper - digitCount
1 question
Radix Sort Helper - mostDigits
1 question
Radix Sort
1 question
Stacks - push Exercise
1 question
Stacks - pop Exercise
1 question
Stack with 2 Queues
1 question
Queues - enqueue Exercise
1 question
Binary Search Tree - insert Exercise
1 question
BinarySearchTree - find
1 question
Binary Search Tree - DFS Exercise
1 question
Binary Search Tree - BFS Exercise
1 question
Binary Search Tree - remove Exercise
1 question
Binary Search Tree Exercise - Find 2nd largest node
1 question
Binary Search Tree Exercise - Check if balanced
1 question
BinaryHeap - insert Exercise
1 question
BinaryHeap - extractMax Exercise
1 question
Graphs Exercise - addVertex
1 question
Graphs Exercise - removeEdge
1 question
Graphs Exercise - removeVertex
1 question
Graphs - DFS Exercise
1 question
Graphs Exercise - addEdge
1 question
Graphs - BFS Exercise
1 question
Graphs - Dijkstra Exercise
1 question
Dynamic Programming - Coin Change
1 question
Coin Change - Greedy Algorithm
1 question
Frequency Counter - constructNote
1 question
Frequency Counter - findAllDuplicates
1 question
Frequency Counter / Multiple Pointer - findPair
1 question
Trie Exercise - addWord
1 question
Trie Exercise - removeWord
1 question
Trie Exercise - findWord
1 question
Trie Exercise - getWords
1 question
Trie - autocomplete
1 question

Đánh giá của học viên

Chưa có đánh giá
Course Rating
5
0%
4
0%
3
0%
2
0%
1
0%

Bình luận khách hàng

Viết Bình Luận

Bạn đánh giá khoá học này thế nào?

image

Đăng ký get khoá học Udemy - Unica - Gitiho giá chỉ 50k!

Get khoá học giá rẻ ngay trước khi bị fix.