Section 1 : Introduction

Lecture 1 Course Breakdown 10:49
Lecture 2 Join Our Online Classroom! Text
Lecture 3 Exercise Meet The Community Text
Lecture 4 Download All Code + Solutions Text
Lecture 5 INTRODUCTION TO BRAINMEASURES PROCTOR SYSTEM Pdf

Section 2 : Arrays - Question #1 Google Interview Question

Lecture 6 Interview Question #1 Two Sum 7:14
Lecture 7 How To Approach Our Problem 11:45
Lecture 8 Writing Our Brute Force Solution 6:41
Lecture 9 Testing Our Optimal Solution With Our Test Cases 9:23
Lecture 10 Submitting To Leetcode 1:49
Lecture 11 Analyzing Space and Time Complexity 10:37
Lecture 12 Optimizing Our Solution
Lecture 13 Coding Our Optimal Solution 5:22
Lecture 14 Testing Our Optimal Solution With Our Test Cases & Space and Time Complexity 8:3
Lecture 15 Checking Performance on Leetcode 3:24
Lecture 16 Solutions In Other Languages Text

Section 3 : Arrays - Questions #2 - Container With Most

Lecture 17 Interview Question #2 - Container With Most Water 4:47
Lecture 18 Coming Up With Test Cases 4:20
Lecture 19 Thinking Through A Logical Brute Force Solution 12:49
Lecture 20 Coding Out Our Brute Force Solution 7:21
Lecture 21 Stepping Through Our Code 4:45
Lecture 22 Thinking About Our Optimal Solution 13:53
Lecture 23 Coding Our Optimal Solution And Testing On LeetCode 9:51

Section 4 : Arrays - Questions #3 - Trapping Rainwater (Hard)

Lecture 24 Interview Question #3 - Trapping Rainwater 7:19
Lecture 25 Thinking About A Logical Solution 12:45
Lecture 26 Coding Our Brute Force 8:52
Lecture 27 Figuring Out Our Optimization Strategy 24:26
Lecture 28 Coding Our Optimal Solution 13:26
Lecture 29 Optimal Code And LeetCode 2:10

Section 5 : Strings - Question #4 - Typed Out Strings (Easy)

Lecture 30 Interview Question #4 -Typed Out Strings 7:8
Lecture 31 Logic Of Our Brute Force 8:2
Lecture 32 Coding Our Brute Force 9:38
Lecture 33 Space And Time Complexity 7:23
Lecture 34 Coming Up With Optimal Solution 11:52
Lecture 35 Coding Our Optimal Solution 12:36
Lecture 36 Submitting To LeetCode 5:52

Section 6 : Strings - Question #5 - Longest Substring Without

Lecture 37 Interview Question #5 - Longest Substring Without Repeating Characters 6:39
Lecture 38 Coming Up With A Brute Force Approach 6:34
Lecture 39 Coding Our Brute Force 9:57
Lecture 40 Space And Time Complexity 3:16
Lecture 41 Sliding Window Technique 5:18
Lecture 42 Hints For Optimizing Our Solution 2:16
Lecture 43 Thinking About Optimal Solution 9:10
Lecture 44 Coding Our Optimal Solution 8:30
Lecture 45 Note Correction for explanation of +1 Text
Lecture 46 Optimal Code And LeetCode 3:18

Section 7 : Strings - Question #6 - Valid Palindrome & Almost

Lecture 47 Intro To Palindromes 9:44
Lecture 48 Interview Question #6 - Valid Palindrome 8:43
Lecture 49 Almost A Palindrome 10:15
Lecture 50 Figuring Out Our Solution 6:50
Lecture 51 Coding Our Solution 9:47

Section 8 : Introducing Linked Lists - Basics and Reverse

Lecture 52 Linked List Introduction 3:58
Lecture 53 Basic Algorithm Reverse a Linked List 8:22
Lecture 54 Thinking About Our Solution 10:55
Lecture 55 Coding Reverse A Linked List Solution 7:8

Section 9 : Linked List - Question #7 - M, N Reversals (Medium)

Lecture 56 Interview Question #7 - M, N Reversals 6:51
Lecture 57 About Certification Pdf
Lecture 58 Coding Our Solution 15:38

Section 10 : Linked List - Question #8 - Merge Multi-Level Doubly

Lecture 59 Interview Question #8 - Merge Multi-Level Doubly Linked List 8:52
Lecture 60 Figuring Out Our Test Cases 8:34
Lecture 61 Note A great visualization helper written in Python by Karen Fish Text
Lecture 62 Thinking About Our Approach 16:47
Lecture 63 Coding Out Our Solution 14:38

Section 11 : Linked List - Question #9 - Cycle Detection (Medium)

Lecture 64 Interview Question #9 - Cycle Detection 11:40
Lecture 65 What Is Floyd's Tortoise And Hare Algorithm
Lecture 66 Coding Floyd's Algorithm 8:55
Lecture 67 Optional Proof Of How And Why Floyd's Algorithm Works 25:51

Section 12 : Stacks - Question #10 - Valid Parentheses (Easy)

Lecture 68 Intro to Stacks and Queues 3:12
Lecture 69 Interview Question #10 - Valid Parentheses 9:23
Lecture 70 Walking Through Our Problem - Identifying The Need For A Stack 8:15
Lecture 71 Coding Our Solution With A Stack 9:18

Section 13 : Stacks - Question #11 - Minimum Brackets To Remove

Lecture 72 Interview Question #11 - Minimum Brackets To Remove 7:39
Lecture 73 Thinking About Our Solution 12:46
Lecture 74 Coding Our Solution 10:53

Section 14 : Queues - Question #12 - Implement Queue With Stacks (Easy)

Lecture 75 Question #12 - Implement Queue With Stacks 4:10
Lecture 76 Figuring Out Our Solution 10:19
Lecture 77 Coding Our Solution 8:28

Section 15 : Recursion (Sorting and Hoare's QuickSelect) - Question #13

Lecture 78 Introducing Recursion 3:7
Lecture 79 Optional Tail Recursion 19:55
Lecture 80 Sorting 2:23
Lecture 81 Interview Question #13 - Kth Largest Element 6:50
Lecture 82 Insights From Quick Sort 12:36
Lecture 83 Understanding Divide And Conquer 8:17
Lecture 84 Coding Quicksort Into Our Solution 14:54
Lecture 85 What Is Hoare's Quickselect Algorithm 6:55
Lecture 86 Coding Our Solution With Quickselect 11:48
Lecture 87 Correction About Time Complexity Text

Section 16 : Recursion (Binary Search) - Question #14 - Start And End

Lecture 88 Understanding Binary Search 9:32
Lecture 89 How To Code Binary Search 6:23
Lecture 90 Question #14 - Start And End Of Target In A Sorted Array 5:5
Lecture 91 Walking Through Our Solution 10:48
Lecture 92 Coding Our Solution 12:55

Section 17 : Binary Trees - Question #15 - Maximum Depth Of Binary Tree

Lecture 93 Intro to Binary Trees 1:53
Lecture 94 Question #15 - Maximum Depth of Binary Tree 6:55
Lecture 95 Learning The Process For Solving Binary Tree Problems 19:12
Lecture 96 Coding Our Solution 6:11

Section 18 : Binary Trees - Question #16 - Level Order Of Binary Tree (Medium)

Lecture 97 Question #16 - Level Order Of Binary Tree 5:29
Lecture 98 Walking Through Our Solution 17:28
Lecture 99 Coding Out Level Order Traversal 11:38

Section 19 : Binary Trees - Question #17 - Right Side View of Tree (Medium)

Lecture 100 Question #17 - Right Side View of Tree 6:43
Lecture 101 Understanding The Breadth First Search Approach 8:27
Lecture 102 Understanding The Depth First Search Approach 9:22
Lecture 103 Thinking About Pre-Order, In-Order, and Post-Order Traversals For Our Solution 12:23
Lecture 104 Completing Our DFS Solution 7:41
Lecture 105 Coding Our Final DFS Solution 11:55

Section 20 : Full & Complete Binary Trees - Question #18 - Number Of Nodes

Lecture 106 Question #18 - Number Of Nodes In Complete Tree 8:32
Lecture 107 Thinking Deeply About A Full Binary Tree 10:26
Lecture 108 Figuring Out Number Of Nodes At Last Level 15:29
Lecture 109 Coding Out Our Full Solution 20:39

Section 21 : Binary Search Tree - Question #19 - Validate Binary Search Tree

Lecture 110 Question #19 - Validate Binary Search Tree 8:50
Lecture 111 Thinking About Our Logical Solution 15:4
Lecture 112 Figuring Out Our Boundaries 6:53
Lecture 113 Coding Our Our Full Solution 7:58

Section 22 : Heaps & Priority Queues

Lecture 114 Introducing Heaps 8:45
Lecture 115 Insertion In Heaps - Understanding Sift Up 7:35
Lecture 116 Deletion In Heaps - Understanding Sift Down 10:48
Lecture 117 Starting To Code Our Priority Queue Class 10:49
Lecture 118 Coding Our Insertion And Sift Up Methods 5:50
Lecture 119 Coding Our Deletion And Sift Down Methods

Section 23 : Intro To 2D-Arrays - Basics & Traversal Algorithms

Lecture 120 Introducing 2D Arrays - What Are They 7:24
Lecture 121 Depth First Search In 2D-Arrays 13:0
Lecture 122 Coding DFS - Setting Up For DFS 9:44
Lecture 123 Coding DFS - Implementing Recursive DFS 8:40
Lecture 124 Breadth First Search In 2D-Arrays 7:49
Lecture 125 Coding BFS 10:6

Section 24 : 2D-Arrays - Question #20 Number Of Islands (Medium)

Lecture 126 A General Approach To Thinking About Most Graph Questions 9:9
Lecture 127 Question #20 Number Of Islands 7:50
Lecture 128 Approaching Our Problem - Thinking Deeply About The Values 16:12
Lecture 129 Approaching Our Problem - Thinking About Traversals 8:55
Lecture 130 Coding Our Solution 19:8
Lecture 131 Thinking About Space And Time Complexity 14:39

Section 25 : 2D-Arrays - Question #21 Rotting Oranges (Medium)

Lecture 132 Question #21 Rotting Oranges 6:57
Lecture 133 Figuring Out Our Initial Logic 11:4
Lecture 134 Figuring Out The Rest Of Our Solution 14:28
Lecture 135 Coding Out Our Solution 14:47

Section 26 : 2D-Arrays - Question #22 - Walls And Gates (Medium)

Lecture 136 Question #22 - Walls And Gates 6:20
Lecture 137 Figuring Out Our Logical Solution 12:16
Lecture 138 Coding Out Our Solution 11:45

Section 27 : Intro to Graphs - Representation & Traversal Algorithms

Lecture 139 Introduction To The Types Of Graphs 11:7
Lecture 140 Representing Our Graphs - Adjacency List & Adjacency Matrix 7:20
Lecture 141 Breadth First Search In Graphs 4:39
Lecture 142 Coding BFS 7:53
Lecture 143 Depth First Search In Graphs 3:3
Lecture 144 Coding DFS 7:4

Section 28 : Graphs - Question #23 - Time Needed to Inform All Employees

Lecture 145 Question #23 - Time Needed to Inform All Employees 12:52
Lecture 146 Verifying Our Constraints And Thinking About Test Cases 8:12
Lecture 147 How To Represent Our Graph As An Adjacency List 9:37
Lecture 148 Solving Our Problem Logically Using DFS Traversal 7:49
Lecture 149 Coding Our DFS Solution 10:2

Section 29 : Graphs - Question #24 - Course Scheduler (Medium)

Lecture 150 Question #24 - Course Scheduler 10:25
Lecture 151 Thinking About Our Initial Solution - BFS 7:57
Lecture 152 Coding Out Our Initial BFS Solution 15:28
Lecture 153 What is Topological Sort 7:57
Lecture 154 Thinking About A Solution With Topological Sort 4:50
Lecture 155 Coding Our Final Solution 15:47

Section 30 : Graphs - Question #25 - Network Time Delay (Medium)

Lecture 156 Question #25 - Network Time Delay 12:39
Lecture 157 Thinking About How To Approach The Problem 8:37
Lecture 158 Greedy Method & What Is Dijkstra's Algorithm 15:30
Lecture 159 Thinking About A Solution With Dijkstra's Algorithm 8:55
Lecture 160 Coding Our Solution With Dijkstra 17:32
Lecture 161 Time And Space Complexity Of Our Solution 13:8
Lecture 162 About Proctor Testing Pdf
Lecture 163 What is The Bellman-Ford Algorithm - Conceptualizing Dynamic Programming 16:22
Lecture 164 What is The Bellman-Ford Algorithm - The Algorithm Itself 16:17
Lecture 165 Coding Our Solution With Bellman-Ford 9:19

Section 31 : Dynamic Programming - Question #26 - Minimum Cost

Lecture 166 Question #26 - Minimum Cost Of Climbing Stairs & How To Approach DP 9:38
Lecture 167 Understanding & Identifying Recurrence Relation 15:48
Lecture 168 First Step - Recursive Solution From Recurrence Relation 5:34
Lecture 169 Note Correction to space complexity Text
Lecture 170 Second Step - Memoizing Our Redundant Recursive Calls 7:49
Lecture 171 Coding Our Memoization Optimization 7:51
Lecture 172 INTRODUCTION TO BRAINMEASURES PROCTOR SYSTEM Pdf
Lecture 173 Third Step - Bottom Up Tabulation 5:24
Lecture 174 Fourth Step - Bottom Up Optimization 6:52

Section 32 : Dynamic Programming - Question #27 - Knight Probability

Lecture 175 Question #27 - Knight Probability In Chessboard 10:9
Lecture 176 Thinking About Test Cases To Help Us 3:51
Lecture 177 Identifying The Recurrence Relation 15:30
Lecture 178 First Step - Recursive Solution From Recurrence Relation
Lecture 179 Second Step - Memoizing Our Redundant Recursive Calls 14:13
Lecture 180 Figuring Out The Logic For Our Bottom Up Solution 13:59
Lecture 181 Third Step - Bottom Up Tabulation 8:31
Lecture 182 Fourth Step - Bottom Up Optimization 6:56
Lecture 183 Dynamic Programming List Text

Section 33 : Backtracking - Question #28 - Sudoku Solver (Hard)

Lecture 184 Understanding The Basics Of Backtracking 7:6
Lecture 185 Question #28 - Sudoku Solver 4:19
Lecture 186 Learning The Backtracking Template 11:19
Lecture 187 Applying Our Backtracking Template To Sudoku Solver Logic 6:42
Lecture 188 Coding How To Get Box ID 7:49
Lecture 189 Setting Up Our Solution Code 7:5
Lecture 190 Coding The Recursive Backtracking Portion Of Our Solution 19:18
Lecture 191 Thinking About The Space And Time Complexity 6:58

Section 34 : Interface Design - Question #29 - Monarchy

Lecture 192 Understanding Interface Design & Question #29 - Monarchy 10:52
Lecture 193 Figuring Out Our Test Cases 5:58
Lecture 194 Thinking About The Logical Of The Monarchy 9:41
Lecture 195 Coding Our Monarchy Solution 14:57

Section 35 : Tries - Question #30 - Implement Prefix Trie (Medium)

Lecture 196 Introducing Tries 1:8
Lecture 197 Question #30 - Implement Prefix Trie 9:50
Lecture 198 Understanding The Logic For Our Methods 3:54
Lecture 199 Implementing Our Prefix Trie Data Structure Solution 15:15

Section 36 : Where To Go From Here

Lecture 200 Learning Guideline Text
Lecture 201 LinkedIn Endorsements Text
Lecture 202 Become An Alumni Text
Lecture 203 Coding Challenges Text

Section 37 : Appendix Big O

Lecture 204 Section Overview 2:8
Lecture 205 What Is Good Code 6:57
Lecture 206 Big O and Scalability 11:9
Lecture 207 O(n) 5:39
Lecture 208 O(1) 6:10
Lecture 209 Exercise Big O Calculation Text
Lecture 210 Solution Big O Calculation 5:55
Lecture 211 Exercise Big O Calculation 2 Text
Lecture 212 Solution Big O Calculation 2 2:30
Lecture 213 About Certification Pdf
Lecture 214 Big O Rule 1 4:29
Lecture 215 Big O Rule 2 6:37
Lecture 216 Big O Rule 3 3:14
Lecture 217 O(n^2) 7:14
Lecture 218 Big O Rule 4 6:47
Lecture 219 Big O Cheat Sheet 3:19
Lecture 220 What Does This All Mean 5:32
Lecture 221 O(n!) 1:18
Lecture 222 3 Pillars Of Programming
Lecture 223 Space Complexity 2:23
Lecture 224 Exercise Space Complexity 6:24
Lecture 225 Exercise Twitter 7:14
Lecture 226 Section Summary 4:44

Section 38 : Appendix Arrays

Lecture 227 Arrays Introduction 13:51
Lecture 228 Static vs Dynamic Arrays 6:41
Lecture 229 Optional Implementing An Array 17:19

Section 39 : Appendix Hash Tables

Lecture 230 Hash Tables Introduction 4:10
Lecture 231 Hash Function 5:56
Lecture 232 Hash Collisions 9:44
Lecture 233 Hash Tables VS Arrays 2:1

Section 40 : Appendix Linked Lists

Lecture 234 Linked Lists Introduction 2:27
Lecture 235 What Is A Linked List 4:37
Lecture 236 Exercise Why Linked Lists 2:27
Lecture 237 Solution Why Linked Lists 5:36
Lecture 238 What Is A Pointer 5:45
Lecture 239 Doubly Linked Lists 3:18
Lecture 240 Singly VS Doubly Linked Lists 2:40
Lecture 241 Linked Lists Review 5:8

Section 41 : Appendix Stacks + Queues

Lecture 242 Stacks + Queues Introduction 2:59
Lecture 243 Stacks 3:29
Lecture 244 Queues 3:31
Lecture 245 About Proctor Testing Pdf
Lecture 246 Solution Stacks VS Queues 3:39
Lecture 247 Stacks + Queues Review 2:19

Section 42 : Appendix Trees

Lecture 248 Trees Introduction 6:1
Lecture 249 Binary Trees 5:45
Lecture 250 O(log n) 7:0
Lecture 251 Binary Search Trees 6:12
Lecture 252 Balanced VS Unbalanced BST 3:42
Lecture 253 BST Pros and Cons 2:27
Lecture 254 Tries 3:17

Section 43 : Appendix Searching + BFS + DFS

Lecture 255 Graph + Tree Traversals 3:56
Lecture 256 BFS Introduction 2:45
Lecture 257 DFS Introduction 3:23
Lecture 258 BFS vs DFS 3:21
Lecture 259 Exercise BFS vs DFS 0:44
Lecture 260 Solution BFS vs DFS 3:16
Lecture 261 breadthFirstSearch() 9:15
Lecture 262 PreOrder, InOrder, PostOrder 5:21
Lecture 263 depthFirstSearch() 12:3

Section 44 : Appendix Recursion

Lecture 264 Recursion Introduction 5:37
Lecture 265 Stack Overflow 6:17
Lecture 266 Anatomy Of Recursion 10:27
Lecture 267 Recursive VS Iterative 4:16
Lecture 268 When To Use Recursion 4:0
Lecture 269 Recursion Review 2:47

Section 45 : Appendix Sorting

Lecture 270 Sorting Introduction 6:45
Lecture 271 The Issue With sort() 6:51
Lecture 272 Sorting Algorithms 3:38
Lecture 273 Bubble Sort 3:46
Lecture 274 Exercise Bubble Sort Text
Lecture 275 Solution Bubble Sort 5:7
Lecture 276 Selection Sort 2:39
Lecture 277 Exercise Selection Sort Text
Lecture 278 Solution Selection Sort 2:23
Lecture 279 Dancing Algorithms 1:36
Lecture 280 Insertion Sort 2:38
Lecture 281 Exercise Insertion Sort Text
Lecture 282 Solution Insertion Sort 2:7
Lecture 283 Merge Sort and O(n log n) 8:59
Lecture 284 Exercise Merge Sort Text
Lecture 285 Solution Merge Sort 4:44
Lecture 286 Quick Sort 7:40