Section 1 : Introduction

 		Lecture 1 Curriculum Walkthrough 7:43
Lecture 2 INTRODUCTION TO BRAINMEASURES PROCTOR SYSTEM Pdf
Lecture 3 How I'm Running My Code 3:21

Section 2 : Big O Notation

 		Lecture 4 Intro to Big O 7:42
Lecture 5 Timing Our Code 10:19
Lecture 6 Counting Operations 4:36
Lecture 7 Visualizing Time Complexities 4:25
Lecture 8 Official Intro to Big O 9:58
Lecture 9 Simplifying Big O Expressions 9:32
Lecture 10 Space Complexity 6:27
Lecture 11 Logs and Section Recap 8:46

Section 3 : Analyzing Performance of Arrays and Objects

 		Lecture 12 PREREQUISITES Text
Lecture 13 Section Introduction 1:43
Lecture 14 The BIG O of Objects 5:32
Lecture 15 When are Arrays Slow 6:25
Lecture 16 Big O of Array Methods 5:56

Section 4 : Problem Solving Approach

 		Lecture 17 PREREQUISITES Text
Lecture 18 Introduction to Problem Solving 7:8
Lecture 19 Step 1 Understand The Problem 7:59
Lecture 20 Step 2 Concrete Examples 6:19
Lecture 21 Step 3 Break It Down 7:45
Lecture 22 Step 4 Solve Or Simplify 10:33
Lecture 23 Step 5 Look Back and Refactor 16:57
Lecture 24 Recap and Interview Strategies 4:12

Section 5 : Problem Solving Patterns

 		Lecture 25 PREREQUISITES Text
Lecture 26 Intro to Problem Solving Patterns 2:56
Lecture 27 Frequency Counter Pattern 15:11
Lecture 28 Frequency Counter Anagram Challenge 2:34
Lecture 29 Anagram Challenge Solution 6:18
Lecture 30 Multiple Pointers Pattern 9:43
Lecture 31 Multiple Pointers Count Unique Values Challenge 4:30
Lecture 32 Count Unique Values Solution 6:31
Lecture 33 Sliding Window Pattern 13:14
Lecture 34 Divide And Conquer Pattern 7:2

Section 6 : 100% OPTIONAL Challenges

 		Lecture 35 IMPORTANT NOTE! Text
Lecture 36 SOLUTIONS PART 1 Text
Lecture 37 SOLUTIONS PART 2 Text
Lecture 38 SOLUTIONS PART 3 Text

Section 7 : Recursion

 		Lecture 39 PREREQUISITES Text
Lecture 40 Story Time Martin & The Dragon 7:7
Lecture 41 Why Use Recursion 5:53
Lecture 42 The Call Stack 7:8
Lecture 43 Our First Recursive Function 5:12
Lecture 44 Our Second Recursive Function 7:54
Lecture 45 Writing Factorial Iteratively 2:19
Lecture 46 Writing Factorial Recursively 3:16
Lecture 47 Common Recursion Pitfalls 5:7
Lecture 48 Helper Method Recursion 6:23
Lecture 49 Pure Recursion 7:45

Section 8 : Recursion Problem Set

 		Lecture 50 START HERE! Text
Lecture 51 SOLUTIONS FOR THIS SECTION Text

Section 9 : Bonus CHALLENGING Recursion Problems

 		Lecture 52 NOTE ON THIS SECTION Text
Lecture 53 SOLUTIONS PART 1 Text
Lecture 54 SOLUTIONS PART 2 Text

Section 10 : Searching Algorithms

 		Lecture 55 PREREQUISITES Text
Lecture 56 Intro to Searching 4:4
Lecture 57 Intro to Linear Search 4:47
Lecture 58 Linear Search Solution 5:19
Lecture 59 Linear Search BIG O
Lecture 60 Intro to Binary Search 5:48
Lecture 61 Binary Search PseudoCode 2:40
Lecture 62 Binary Search Solution 16:41
Lecture 63 Binary Search BIG O 6:9
Lecture 64 Naive String Search 4:38
Lecture 65 Naive String Search Implementation 12:30
Lecture 66 KNP COMING SOON Text

Section 11 : Bubble Sort

 		Lecture 67 PREREQUISITES Text
Lecture 68 Introduction to Sorting Algorithms 8:36
Lecture 69 Built-In JavaScript Sorting 4:40
Lecture 70 Bubble Sort Overview 7:21
Lecture 71 Bubble Sort Implementation 9:58
Lecture 72 Bubble Sort Optimization 4:22
Lecture 73 Bubble Sort BIG O Complexity 1:28

Section 12 : Selection Sort

 		Lecture 74 PREREQUISITES Text
Lecture 75 Selection Sort Introduction 6:19
Lecture 76 Selection Sort Implementation 11:14
Lecture 77 Selection Sort Big O Complexity 1:40

Section 13 : Insertion Sort

 		Lecture 78 PREREQUISITES Text
Lecture 79 Insertion Sort Introduction 3:17
Lecture 80 Insertion Sort Implementation 10:43
Lecture 81 Insertion Sort BIG O Complexity 2:25

Section 14 : Comparing Bubble, Selection, and Insertion Sort

 		Lecture 82 Comparing Bubble, Selection, and Insertion Sort 5:34

Section 15 : Merge Sort

 		Lecture 83 PREREQUISITES Text
Lecture 84 Intro to the Crazier Sorts 6:6
Lecture 85 Merge Sort Introduction 5:26
Lecture 86 Merging Arrays Intro 5:11
Lecture 87 Merging Arrays Implementation 6:55
Lecture 88 Writing Merge Sort Part 1 2:21
Lecture 89 Writing Merge Sort Part 2 12:37
Lecture 90 Merge Sort BIG O Complexity 6:22

Section 16 : Quick Sort

 		Lecture 91 PREREQUISITES Text
Lecture 92 Introduction to Quick Sort 9:1
Lecture 93 Pivot Helper Introduction 8:6
Lecture 94 Pivot Helper Implementation 8:8
Lecture 95 Quick Sort Implementation 8:46
Lecture 96 Quick Sort Call Stack Walkthrough 4:16
Lecture 97 Quick Sort Big O Complexity 4:6

Section 17 : Radix Sort

 		Lecture 98 PREREQUISITES Text
Lecture 99 Radix Sort Introduction 9:23
Lecture 100 Radix Sort Helper Methods
Lecture 101 Radix Sort Pseudocode 4:18
Lecture 102 Radix Sort Implementation 10:25
Lecture 103 Radix Sort BIG O Complexity 3:51

Section 18 : Data Structures Introduction

 		Lecture 104 Which Data Structure Is The Best 12:39
Lecture 105 ES2015 Class Syntax Overview 5:15
Lecture 106 Data Structures The Class Keyword 6:37
Lecture 107 Data Structures Adding Instance Methods 9:50
Lecture 108 Data Structures Adding Class Methods 7:12

Section 19 : Singly Linked Lists

 		Lecture 109 PREREQUISITES Text
Lecture 110 Intro to Singly Linked Lists 7:47
Lecture 111 Starter Code and Push Intro 7:22
Lecture 112 Singly Linked List Push Solution 4:25
Lecture 113 Singly Linked List Pop Intro 6:14
Lecture 114 Singly Linked List Pop Solution 7:35
Lecture 115 Singly Linked List Shift Intro 1:31
Lecture 116 Singly Linked List Shift Solution 3:22
Lecture 117 Singly Linked List Unshift Intro 1:35
Lecture 118 Singly Linked List Unshift Solution 5:58
Lecture 119 Singly Linked List Get Intro 2:32
Lecture 120 Singly Linked List Get Solution 3:32
Lecture 121 Singly Linked List Set Intro 1:26
Lecture 122 Singly Linked List Set Solution 2:11
Lecture 123 Singly Linked List Insert Intro 4:27
Lecture 124 Singly Linked List Insert Solution
Lecture 125 Singly Linked List Remove Intro 1:56
Lecture 126 Singly Linked List Remove Solution 3:15
Lecture 127 Singly Linked List Reverse Intro 4:46
Lecture 128 Singly Linked List Reverse Solution 8:59
Lecture 129 Singly Linked List BIG O Complexity 5:41

Section 20 : Doubly Linked Lists

 		Lecture 130 PREREQUISITES Text
Lecture 131 Doubly Linked Lists Introduction 4:44
Lecture 132 Setting Up Our Node Class 3:0
Lecture 133 Push 2:11
Lecture 134 Push Solution 4:5
Lecture 135 Pop 3:20
Lecture 136 Pop Solution 6:24
Lecture 137 Shift 2:45
Lecture 138 Shift Solution 4:12
Lecture 139 Unshift 1:36
Lecture 140 Unshift Solution 2:19
Lecture 141 Get 4:2
Lecture 142 Get Solution 7:5
Lecture 143 Set 1:18
Lecture 144 Set Solution 2:8
Lecture 145 Insert 2:50
Lecture 146 Insert Solution 6:48
Lecture 147 Remove 2:19
Lecture 148 Remove Solution 6:28
Lecture 149 Comparing Singly and Doubly Linked Lists 4:32

Section 21 : Stacks + Queues

 		Lecture 150 PREREQUISITES Text
Lecture 151 Intro to Stacks 6:19
Lecture 152 Creating a Stack with an Array 7:5
Lecture 153 Writing Our Own Stack From Scratch 11:33
Lecture 154 BIG O of Stacks 2:15
Lecture 155 Intro to Queues 4:15
Lecture 156 Creating Queues Using Arrays 3:25
Lecture 157 Writing Our Own Queue From Scratch 10:24
Lecture 158 BIG O of Queues

Section 22 : Binary Search Trees

 		Lecture 159 PREREQUISITES Text
Lecture 160 Introduction to Trees 6:46
Lecture 161 Uses For Trees 6:32
Lecture 162 Intro to Binary Trees 5:54
Lecture 163 POP QUIZ! 1:14
Lecture 164 Searching A Binary Search Tree 2:55
Lecture 165 Our Tree Classes 2:45
Lecture 166 BST Insert 3:51
Lecture 167 BST Insert Solution 11:53
Lecture 168 BST Find 4:42
Lecture 169 BST Find Solution 5:36
Lecture 170 Big O of Binary Search Trees 5:59

Section 23 : Tree Traversal

 		Lecture 171 PREREQUISITES Text
Lecture 172 Intro To Tree Traversal 4:50
Lecture 173 Breadth First Search Intro 5:52
Lecture 174 Breadth First Search Solution 6:21
Lecture 175 Depth First PreOrder Intro 5:38
Lecture 176 Depth First PreOrder Solution 6:50
Lecture 177 Depth First PostOrder Intro 4:2
Lecture 178 Depth First PostOrder Solution 2:39
Lecture 179 Depth First InOrder Intro 2:8
Lecture 180 Depth First InOrder Solution 2:33
Lecture 181 When to Use BFS and DFS 7:37

Section 24 : Binary Heaps

 		Lecture 182 PREREQUISITES Text
Lecture 183 Intro to Heaps 7:31
Lecture 184 Storing Heaps 7:6
Lecture 185 Heap Insert Intro 9:15
Lecture 186 Heap Insert Solution 10:52
Lecture 187 Heap ExtractMax Intro 8:28
Lecture 188 Heap ExtractMax Solution 17:56
Lecture 189 Priority Queue Intro
Lecture 190 Priority Queue Pseudocode 3:43
Lecture 191 Priority Queue Solution 9:21
Lecture 192 BIG O of Binary Heaps 8:54

Section 25 : Hash Tables

 		Lecture 193 PREREQUISITES Text
Lecture 194 Intro to Hash Tables 5:50
Lecture 195 More About Hash Tables 4:32
Lecture 196 Intro to Hash Functions 6:11
Lecture 197 Writing Our First Hash Function 8:27
Lecture 198 Improving Our Hash Function 7:10
Lecture 199 Handling Collisions 4:0
Lecture 200 Hash Table Set and Get 4:3
Lecture 201 Hash Table Set Solution 5:15
Lecture 202 Hash Table Get Solution 6:43
Lecture 203 Hash Table Keys and Values 1:42
Lecture 204 Hash Table Keys and Values Solution 8:44
Lecture 205 Hash Table Big O Complexity 5:41

Section 26 : Graphs

 		Lecture 206 PREREQUISITES Text
Lecture 207 Intro to Graphs 3:50
Lecture 208 Uses for Graphs 7:58
Lecture 209 Types of Graphs 8:49
Lecture 210 Storing Graphs Adjacency Matrix 3:57
Lecture 211 Storing Graphs Adjacency List 2:29
Lecture 212 Adjacency Matrix Vs 5:51
Lecture 213 Add Vertex Intro 2:10
Lecture 214 Add Vertex Solution 2:54
Lecture 215 Add Edge Intro 2:33
Lecture 216 Add Edge Solution 2:11
Lecture 217 Remove Edge Intro 1:36
Lecture 218 Remove Edge Solution 2:42
Lecture 219 Remove Vertex Intro 2:36
Lecture 220 Remove Vertex Solution 4:34

Section 27 : Graph Traversal

 		Lecture 221 PREREQUISITES Text
Lecture 222 Intro to Graph Traversal 8:38
Lecture 223 Depth First Graph Traversal 8:31
Lecture 224 DFS Recursive Intro 7:28
Lecture 225 DFS Recursive Solution 12:45
Lecture 226 DFS Iterative Intro 3:38
Lecture 227 DFS Iterative Solution 8:44
Lecture 228 Breadth First Graph Traversal 3:0
Lecture 229 BFS Intro 2:27
Lecture 230 BFS Solution 8:9

Section 28 : Dijkstra's Algorithm!

 		Lecture 231 PREREQUISITES Text
Lecture 232 Intro to Dijkstra's and Prerequisites 2:42
Lecture 233 Who was Dijkstra and what is his Algorithm 9:0
Lecture 234 Writing a Weighted Graph 5:20
Lecture 235 Walking through the Algorithm 16:27
Lecture 236 Introducing Our Simple Priority Queue 3:48
Lecture 237 Dijkstra's Pseudo-Code 4:29
Lecture 238 Implementing Dijkstra's Algorithm 21:19
Lecture 239 Upgrading the Priority Queue 1:53

Section 29 : Dynamic Programming

 		Lecture 240 Intro to Dynamic Programming 5:3
Lecture 241 Overlapping Subproblems 6:0
Lecture 242 Optimal Substructure 6:28
Lecture 243 Writing A Recursive Solution 6:43
Lecture 244 Time Complexity of Our Solution 4:12
Lecture 245 The Problem With Our Solution 3:39
Lecture 246 Enter Memoization! 9:1
Lecture 247 Time Complexity of Memoized Solution 3:27
Lecture 248 Tabulation A Bottom Up Approach 6:59