#### 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