Section 1 : Introduction
|
|
Lecture 1 | Course Breakdown | 00:10:49 Duration |
|
|
Lecture 2 | Join Our Online Classroom! | |
|
|
Lecture 3 | Exercise Meet The Community | |
|
|
Lecture 4 | Download All Code + Solutions | |
|
|
Lecture 5 | INTRODUCTION TO BRAINMEASURES PROCTOR SYSTEM |
Section 2 : Arrays - Question #1 Google Interview Question
|
|
Lecture 1 | Interview Question #1 Two Sum | 00:07:14 Duration |
|
|
Lecture 2 | How To Approach Our Problem | 00:11:45 Duration |
|
|
Lecture 3 | Writing Our Brute Force Solution | 00:06:41 Duration |
|
|
Lecture 4 | Testing Our Optimal Solution With Our Test Cases | 00:09:23 Duration |
|
|
Lecture 5 | Submitting To Leetcode | 00:01:49 Duration |
|
|
Lecture 6 | Analyzing Space and Time Complexity | 00:10:37 Duration |
|
|
Lecture 7 | Optimizing Our Solution | |
|
|
Lecture 8 | Coding Our Optimal Solution | 00:05:22 Duration |
|
|
Lecture 9 | Testing Our Optimal Solution With Our Test Cases & Space and Time Complexity | 00:08:03 Duration |
|
|
Lecture 10 | Checking Performance on Leetcode | 00:03:24 Duration |
|
|
Lecture 11 | Solutions In Other Languages |
Section 3 : Arrays - Questions #2 - Container With Most
|
|
Lecture 1 | Interview Question #2 - Container With Most Water | 00:04:47 Duration |
|
|
Lecture 2 | Coming Up With Test Cases | 00:04:20 Duration |
|
|
Lecture 3 | Thinking Through A Logical Brute Force Solution | 00:12:49 Duration |
|
|
Lecture 4 | Coding Out Our Brute Force Solution | 00:07:21 Duration |
|
|
Lecture 5 | Stepping Through Our Code | 00:04:45 Duration |
|
|
Lecture 6 | Thinking About Our Optimal Solution | 00:13:53 Duration |
|
|
Lecture 7 | Coding Our Optimal Solution And Testing On LeetCode | 00:09:51 Duration |
Section 4 : Arrays - Questions #3 - Trapping Rainwater (Hard)
|
|
Lecture 1 | Interview Question #3 - Trapping Rainwater | 00:07:19 Duration |
|
|
Lecture 2 | Thinking About A Logical Solution | 00:12:45 Duration |
|
|
Lecture 3 | Coding Our Brute Force | 00:08:52 Duration |
|
|
Lecture 4 | Figuring Out Our Optimization Strategy | 00:24:26 Duration |
|
|
Lecture 5 | Coding Our Optimal Solution | 00:13:26 Duration |
|
|
Lecture 6 | Optimal Code And LeetCode | 00:02:10 Duration |
Section 5 : Strings - Question #4 - Typed Out Strings (Easy)
|
|
Lecture 1 | Interview Question #4 -Typed Out Strings | 00:07:08 Duration |
|
|
Lecture 2 | Logic Of Our Brute Force | 00:08:02 Duration |
|
|
Lecture 3 | Coding Our Brute Force | 00:09:38 Duration |
|
|
Lecture 4 | Space And Time Complexity | 00:07:23 Duration |
|
|
Lecture 5 | Coming Up With Optimal Solution | 00:11:52 Duration |
|
|
Lecture 6 | Coding Our Optimal Solution | 00:12:36 Duration |
|
|
Lecture 7 | Submitting To LeetCode | 00:05:52 Duration |
Section 6 : Strings - Question #5 - Longest Substring Without
|
|
Lecture 1 | Interview Question #5 - Longest Substring Without Repeating Characters | 00:06:39 Duration |
|
|
Lecture 2 | Coming Up With A Brute Force Approach | 00:06:34 Duration |
|
|
Lecture 3 | Coding Our Brute Force | 00:09:57 Duration |
|
|
Lecture 4 | Space And Time Complexity | 00:03:16 Duration |
|
|
Lecture 5 | Sliding Window Technique | 00:05:18 Duration |
|
|
Lecture 6 | Hints For Optimizing Our Solution | 00:02:16 Duration |
|
|
Lecture 7 | Thinking About Optimal Solution | 00:09:10 Duration |
|
|
Lecture 8 | Coding Our Optimal Solution | 00:08:30 Duration |
|
|
Lecture 9 | Note Correction for explanation of +1 | |
|
|
Lecture 10 | Optimal Code And LeetCode | 00:03:18 Duration |
Section 7 : Strings - Question #6 - Valid Palindrome & Almost
|
|
Lecture 1 | Intro To Palindromes | 00:09:44 Duration |
|
|
Lecture 2 | Interview Question #6 - Valid Palindrome | 00:08:43 Duration |
|
|
Lecture 3 | Almost A Palindrome | 00:10:15 Duration |
|
|
Lecture 4 | Figuring Out Our Solution | 00:06:50 Duration |
|
|
Lecture 5 | Coding Our Solution | 00:09:47 Duration |
Section 8 : Introducing Linked Lists - Basics and Reverse
|
|
Lecture 1 | Linked List Introduction | 00:03:58 Duration |
|
|
Lecture 2 | Basic Algorithm Reverse a Linked List | 00:08:22 Duration |
|
|
Lecture 3 | Thinking About Our Solution | 00:10:55 Duration |
|
|
Lecture 4 | Coding Reverse A Linked List Solution | 00:07:08 Duration |
Section 9 : Linked List - Question #7 - M, N Reversals (Medium)
|
|
Lecture 1 | Interview Question #7 - M, N Reversals | 00:06:51 Duration |
|
|
Lecture 2 | About Certification | |
|
|
Lecture 3 | Coding Our Solution | 00:15:38 Duration |
Section 10 : Linked List - Question #8 - Merge Multi-Level Doubly
|
|
Lecture 1 | Interview Question #8 - Merge Multi-Level Doubly Linked List | 00:08:52 Duration |
|
|
Lecture 2 | Figuring Out Our Test Cases | 00:08:34 Duration |
|
|
Lecture 3 | Note A great visualization helper written in Python by Karen Fish | |
|
|
Lecture 4 | Thinking About Our Approach | 00:16:47 Duration |
|
|
Lecture 5 | Coding Out Our Solution | 00:14:38 Duration |
Section 11 : Linked List - Question #9 - Cycle Detection (Medium)
|
|
Lecture 1 | Interview Question #9 - Cycle Detection | 00:11:40 Duration |
|
|
Lecture 2 | What Is Floyd's Tortoise And Hare Algorithm | |
|
|
Lecture 3 | Coding Floyd's Algorithm | 00:08:55 Duration |
|
|
Lecture 4 | Optional Proof Of How And Why Floyd's Algorithm Works | 00:25:51 Duration |
Section 12 : Stacks - Question #10 - Valid Parentheses (Easy)
|
|
Lecture 1 | Intro to Stacks and Queues | 00:03:12 Duration |
|
|
Lecture 2 | Interview Question #10 - Valid Parentheses | 00:09:23 Duration |
|
|
Lecture 3 | Walking Through Our Problem - Identifying The Need For A Stack | 00:08:15 Duration |
|
|
Lecture 4 | Coding Our Solution With A Stack | 00:09:18 Duration |
Section 13 : Stacks - Question #11 - Minimum Brackets To Remove
|
|
Lecture 1 | Interview Question #11 - Minimum Brackets To Remove | 00:07:39 Duration |
|
|
Lecture 2 | Thinking About Our Solution | 00:12:46 Duration |
|
|
Lecture 3 | Coding Our Solution | 00:10:53 Duration |
Section 14 : Queues - Question #12 - Implement Queue With Stacks (Easy)
|
|
Lecture 1 | Question #12 - Implement Queue With Stacks | 00:04:10 Duration |
|
|
Lecture 2 | Figuring Out Our Solution | 00:10:19 Duration |
|
|
Lecture 3 | Coding Our Solution | 00:08:28 Duration |
Section 15 : Recursion (Sorting and Hoare's QuickSelect) - Question #13
|
|
Lecture 1 | Introducing Recursion | 00:03:07 Duration |
|
|
Lecture 2 | Optional Tail Recursion | 00:19:55 Duration |
|
|
Lecture 3 | Sorting | 00:02:23 Duration |
|
|
Lecture 4 | Interview Question #13 - Kth Largest Element | 00:06:50 Duration |
|
|
Lecture 5 | Insights From Quick Sort | 00:12:36 Duration |
|
|
Lecture 6 | Understanding Divide And Conquer | 00:08:17 Duration |
|
|
Lecture 7 | Coding Quicksort Into Our Solution | 00:14:54 Duration |
|
|
Lecture 8 | What Is Hoare's Quickselect Algorithm | 00:06:55 Duration |
|
|
Lecture 9 | Coding Our Solution With Quickselect | 00:11:48 Duration |
|
|
Lecture 10 | Correction About Time Complexity |
Section 16 : Recursion (Binary Search) - Question #14 - Start And End
|
|
Lecture 1 | Understanding Binary Search | 00:09:32 Duration |
|
|
Lecture 2 | How To Code Binary Search | 00:06:23 Duration |
|
|
Lecture 3 | Question #14 - Start And End Of Target In A Sorted Array | 00:05:05 Duration |
|
|
Lecture 4 | Walking Through Our Solution | 00:10:48 Duration |
|
|
Lecture 5 | Coding Our Solution | 00:12:55 Duration |
Section 17 : Binary Trees - Question #15 - Maximum Depth Of Binary Tree
|
|
Lecture 1 | Intro to Binary Trees | 00:01:53 Duration |
|
|
Lecture 2 | Question #15 - Maximum Depth of Binary Tree | 00:06:55 Duration |
|
|
Lecture 3 | Learning The Process For Solving Binary Tree Problems | 00:19:12 Duration |
|
|
Lecture 4 | Coding Our Solution | 00:06:11 Duration |
Section 18 : Binary Trees - Question #16 - Level Order Of Binary Tree (Medium)
|
|
Lecture 1 | Question #16 - Level Order Of Binary Tree | 00:05:29 Duration |
|
|
Lecture 2 | Walking Through Our Solution | 00:17:28 Duration |
|
|
Lecture 3 | Coding Out Level Order Traversal | 00:11:38 Duration |
Section 19 : Binary Trees - Question #17 - Right Side View of Tree (Medium)
|
|
Lecture 1 | Question #17 - Right Side View of Tree | 00:06:43 Duration |
|
|
Lecture 2 | Understanding The Breadth First Search Approach | 00:08:27 Duration |
|
|
Lecture 3 | Understanding The Depth First Search Approach | 00:09:22 Duration |
|
|
Lecture 4 | Thinking About Pre-Order, In-Order, and Post-Order Traversals For Our Solution | 00:12:23 Duration |
|
|
Lecture 5 | Completing Our DFS Solution | 00:07:41 Duration |
|
|
Lecture 6 | Coding Our Final DFS Solution | 00:11:55 Duration |
Section 20 : Full & Complete Binary Trees - Question #18 - Number Of Nodes
|
|
Lecture 1 | Question #18 - Number Of Nodes In Complete Tree | 00:08:32 Duration |
|
|
Lecture 2 | Thinking Deeply About A Full Binary Tree | 00:10:26 Duration |
|
|
Lecture 3 | Figuring Out Number Of Nodes At Last Level | 00:15:29 Duration |
|
|
Lecture 4 | Coding Out Our Full Solution | 00:20:39 Duration |
Section 21 : Binary Search Tree - Question #19 - Validate Binary Search Tree
|
|
Lecture 1 | Question #19 - Validate Binary Search Tree | 00:08:50 Duration |
|
|
Lecture 2 | Thinking About Our Logical Solution | 00:15:04 Duration |
|
|
Lecture 3 | Figuring Out Our Boundaries | 00:06:53 Duration |
|
|
Lecture 4 | Coding Our Our Full Solution | 00:07:58 Duration |
Section 22 : Heaps & Priority Queues
|
|
Lecture 1 | Introducing Heaps | 00:08:45 Duration |
|
|
Lecture 2 | Insertion In Heaps - Understanding Sift Up | 00:07:35 Duration |
|
|
Lecture 3 | Deletion In Heaps - Understanding Sift Down | 00:10:48 Duration |
|
|
Lecture 4 | Starting To Code Our Priority Queue Class | 00:10:49 Duration |
|
|
Lecture 5 | Coding Our Insertion And Sift Up Methods | 00:05:50 Duration |
|
|
Lecture 6 | Coding Our Deletion And Sift Down Methods |
Section 23 : Intro To 2D-Arrays - Basics & Traversal Algorithms
|
|
Lecture 1 | Introducing 2D Arrays - What Are They | 00:07:24 Duration |
|
|
Lecture 2 | Depth First Search In 2D-Arrays | 00:13:00 Duration |
|
|
Lecture 3 | Coding DFS - Setting Up For DFS | 00:09:44 Duration |
|
|
Lecture 4 | Coding DFS - Implementing Recursive DFS | 00:08:40 Duration |
|
|
Lecture 5 | Breadth First Search In 2D-Arrays | 00:07:49 Duration |
|
|
Lecture 6 | Coding BFS | 00:10:06 Duration |
Section 24 : 2D-Arrays - Question #20 Number Of Islands (Medium)
|
|
Lecture 1 | A General Approach To Thinking About Most Graph Questions | 00:09:09 Duration |
|
|
Lecture 2 | Question #20 Number Of Islands | 00:07:50 Duration |
|
|
Lecture 3 | Approaching Our Problem - Thinking Deeply About The Values | 00:16:12 Duration |
|
|
Lecture 4 | Approaching Our Problem - Thinking About Traversals | 00:08:55 Duration |
|
|
Lecture 5 | Coding Our Solution | 00:19:08 Duration |
|
|
Lecture 6 | Thinking About Space And Time Complexity | 00:14:39 Duration |
Section 25 : 2D-Arrays - Question #21 Rotting Oranges (Medium)
|
|
Lecture 1 | Question #21 Rotting Oranges | 00:06:57 Duration |
|
|
Lecture 2 | Figuring Out Our Initial Logic | 00:11:04 Duration |
|
|
Lecture 3 | Figuring Out The Rest Of Our Solution | 00:14:28 Duration |
|
|
Lecture 4 | Coding Out Our Solution | 00:14:47 Duration |
Section 26 : 2D-Arrays - Question #22 - Walls And Gates (Medium)
|
|
Lecture 1 | Question #22 - Walls And Gates | 00:06:20 Duration |
|
|
Lecture 2 | Figuring Out Our Logical Solution | 00:12:16 Duration |
|
|
Lecture 3 | Coding Out Our Solution | 00:11:45 Duration |
Section 27 : Intro to Graphs - Representation & Traversal Algorithms
|
|
Lecture 1 | Introduction To The Types Of Graphs | 00:11:07 Duration |
|
|
Lecture 2 | Representing Our Graphs - Adjacency List & Adjacency Matrix | 00:07:20 Duration |
|
|
Lecture 3 | Breadth First Search In Graphs | 00:04:39 Duration |
|
|
Lecture 4 | Coding BFS | 00:07:53 Duration |
|
|
Lecture 5 | Depth First Search In Graphs | 00:03:03 Duration |
|
|
Lecture 6 | Coding DFS | 00:07:04 Duration |
Section 28 : Graphs - Question #23 - Time Needed to Inform All Employees
|
|
Lecture 1 | Question #23 - Time Needed to Inform All Employees | 00:12:52 Duration |
|
|
Lecture 2 | Verifying Our Constraints And Thinking About Test Cases | 00:08:12 Duration |
|
|
Lecture 3 | How To Represent Our Graph As An Adjacency List | 00:09:37 Duration |
|
|
Lecture 4 | Solving Our Problem Logically Using DFS Traversal | 00:07:49 Duration |
|
|
Lecture 5 | Coding Our DFS Solution | 00:10:02 Duration |
Section 29 : Graphs - Question #24 - Course Scheduler (Medium)
|
|
Lecture 1 | Question #24 - Course Scheduler | 00:10:25 Duration |
|
|
Lecture 2 | Thinking About Our Initial Solution - BFS | 00:07:57 Duration |
|
|
Lecture 3 | Coding Out Our Initial BFS Solution | 00:15:28 Duration |
|
|
Lecture 4 | What is Topological Sort | 00:07:57 Duration |
|
|
Lecture 5 | Thinking About A Solution With Topological Sort | 00:04:50 Duration |
|
|
Lecture 6 | Coding Our Final Solution | 00:15:47 Duration |
Section 30 : Graphs - Question #25 - Network Time Delay (Medium)
|
|
Lecture 1 | Question #25 - Network Time Delay | 00:12:39 Duration |
|
|
Lecture 2 | Thinking About How To Approach The Problem | 00:08:37 Duration |
|
|
Lecture 3 | Greedy Method & What Is Dijkstra's Algorithm | 00:15:30 Duration |
|
|
Lecture 4 | Thinking About A Solution With Dijkstra's Algorithm | 00:08:55 Duration |
|
|
Lecture 5 | Coding Our Solution With Dijkstra | 00:17:32 Duration |
|
|
Lecture 6 | Time And Space Complexity Of Our Solution | 00:13:08 Duration |
|
|
Lecture 7 | About Proctor Testing | |
|
|
Lecture 8 | What is The Bellman-Ford Algorithm - Conceptualizing Dynamic Programming | 00:16:22 Duration |
|
|
Lecture 9 | What is The Bellman-Ford Algorithm - The Algorithm Itself | 00:16:17 Duration |
|
|
Lecture 10 | Coding Our Solution With Bellman-Ford | 00:09:19 Duration |
Section 31 : Dynamic Programming - Question #26 - Minimum Cost
|
|
Lecture 1 | Question #26 - Minimum Cost Of Climbing Stairs & How To Approach DP | 00:09:38 Duration |
|
|
Lecture 2 | Understanding & Identifying Recurrence Relation | 00:15:48 Duration |
|
|
Lecture 3 | First Step - Recursive Solution From Recurrence Relation | 00:05:34 Duration |
|
|
Lecture 4 | Note Correction to space complexity | |
|
|
Lecture 5 | Second Step - Memoizing Our Redundant Recursive Calls | 00:07:49 Duration |
|
|
Lecture 6 | Coding Our Memoization Optimization | 00:07:51 Duration |
|
|
Lecture 7 | INTRODUCTION TO BRAINMEASURES PROCTOR SYSTEM | |
|
|
Lecture 8 | Third Step - Bottom Up Tabulation | 00:05:24 Duration |
|
|
Lecture 9 | Fourth Step - Bottom Up Optimization | 00:06:52 Duration |
Section 32 : Dynamic Programming - Question #27 - Knight Probability
|
|
Lecture 1 | Question #27 - Knight Probability In Chessboard | 00:10:09 Duration |
|
|
Lecture 2 | Thinking About Test Cases To Help Us | 00:03:51 Duration |
|
|
Lecture 3 | Identifying The Recurrence Relation | 00:15:30 Duration |
|
|
Lecture 4 | First Step - Recursive Solution From Recurrence Relation | |
|
|
Lecture 5 | Second Step - Memoizing Our Redundant Recursive Calls | 00:14:13 Duration |
|
|
Lecture 6 | Figuring Out The Logic For Our Bottom Up Solution | 00:13:59 Duration |
|
|
Lecture 7 | Third Step - Bottom Up Tabulation | 00:08:31 Duration |
|
|
Lecture 8 | Fourth Step - Bottom Up Optimization | 00:06:56 Duration |
|
|
Lecture 9 | Dynamic Programming List |
Section 33 : Backtracking - Question #28 - Sudoku Solver (Hard)
|
|
Lecture 1 | Understanding The Basics Of Backtracking | 00:07:06 Duration |
|
|
Lecture 2 | Question #28 - Sudoku Solver | 00:04:19 Duration |
|
|
Lecture 3 | Learning The Backtracking Template | 00:11:19 Duration |
|
|
Lecture 4 | Applying Our Backtracking Template To Sudoku Solver Logic | 00:06:42 Duration |
|
|
Lecture 5 | Coding How To Get Box ID | 00:07:49 Duration |
|
|
Lecture 6 | Setting Up Our Solution Code | 00:07:05 Duration |
|
|
Lecture 7 | Coding The Recursive Backtracking Portion Of Our Solution | 00:19:18 Duration |
|
|
Lecture 8 | Thinking About The Space And Time Complexity | 00:06:58 Duration |
Section 34 : Interface Design - Question #29 - Monarchy
|
|
Lecture 1 | Understanding Interface Design & Question #29 - Monarchy | 00:10:52 Duration |
|
|
Lecture 2 | Figuring Out Our Test Cases | 00:05:58 Duration |
|
|
Lecture 3 | Thinking About The Logical Of The Monarchy | 00:09:41 Duration |
|
|
Lecture 4 | Coding Our Monarchy Solution | 00:14:57 Duration |
Section 35 : Tries - Question #30 - Implement Prefix Trie (Medium)
|
|
Lecture 1 | Introducing Tries | 00:01:08 Duration |
|
|
Lecture 2 | Question #30 - Implement Prefix Trie | 00:09:50 Duration |
|
|
Lecture 3 | Understanding The Logic For Our Methods | 00:03:54 Duration |
|
|
Lecture 4 | Implementing Our Prefix Trie Data Structure Solution | 00:15:15 Duration |
Section 36 : Where To Go From Here
|
|
Lecture 1 | Learning Guideline | |
|
|
Lecture 2 | LinkedIn Endorsements | |
|
|
Lecture 3 | Become An Alumni | |
|
|
Lecture 4 | Coding Challenges |
Section 37 : Appendix Big O
|
|
Lecture 1 | Section Overview | 00:02:08 Duration |
|
|
Lecture 2 | What Is Good Code | 00:06:57 Duration |
|
|
Lecture 3 | Big O and Scalability | 00:11:09 Duration |
|
|
Lecture 4 | O(n) | 00:05:39 Duration |
|
|
Lecture 5 | O(1) | 00:06:10 Duration |
|
|
Lecture 6 | Exercise Big O Calculation | |
|
|
Lecture 7 | Solution Big O Calculation | 00:05:55 Duration |
|
|
Lecture 8 | Exercise Big O Calculation 2 | |
|
|
Lecture 9 | Solution Big O Calculation 2 | 00:02:30 Duration |
|
|
Lecture 10 | About Certification | |
|
|
Lecture 11 | Big O Rule 1 | 00:04:29 Duration |
|
|
Lecture 12 | Big O Rule 2 | 00:06:37 Duration |
|
|
Lecture 13 | Big O Rule 3 | 00:03:14 Duration |
|
|
Lecture 14 | O(n^2) | 00:07:14 Duration |
|
|
Lecture 15 | Big O Rule 4 | 00:06:47 Duration |
|
|
Lecture 16 | Big O Cheat Sheet | 00:03:19 Duration |
|
|
Lecture 17 | What Does This All Mean | 00:05:32 Duration |
|
|
Lecture 18 | O(n!) | 00:01:18 Duration |
|
|
Lecture 19 | 3 Pillars Of Programming | |
|
|
Lecture 20 | Space Complexity | 00:02:23 Duration |
|
|
Lecture 21 | Exercise Space Complexity | 00:06:24 Duration |
|
|
Lecture 22 | Exercise Twitter | 00:07:14 Duration |
|
|
Lecture 23 | Section Summary | 00:04:44 Duration |
Section 38 : Appendix Arrays
|
|
Lecture 1 | Arrays Introduction | 00:13:51 Duration |
|
|
Lecture 2 | Static vs Dynamic Arrays | 00:06:41 Duration |
|
|
Lecture 3 | Optional Implementing An Array | 00:17:19 Duration |
Section 39 : Appendix Hash Tables
|
|
Lecture 1 | Hash Tables Introduction | 00:04:10 Duration |
|
|
Lecture 2 | Hash Function | 00:05:56 Duration |
|
|
Lecture 3 | Hash Collisions | 00:09:44 Duration |
|
|
Lecture 4 | Hash Tables VS Arrays | 00:02:01 Duration |
Section 40 : Appendix Linked Lists
|
|
Lecture 1 | Linked Lists Introduction | 00:02:27 Duration |
|
|
Lecture 2 | What Is A Linked List | 00:04:37 Duration |
|
|
Lecture 3 | Exercise Why Linked Lists | 00:02:27 Duration |
|
|
Lecture 4 | Solution Why Linked Lists | 00:05:36 Duration |
|
|
Lecture 5 | What Is A Pointer | 00:05:45 Duration |
|
|
Lecture 6 | Doubly Linked Lists | 00:03:18 Duration |
|
|
Lecture 7 | Singly VS Doubly Linked Lists | 00:02:40 Duration |
|
|
Lecture 8 | Linked Lists Review | 00:05:08 Duration |
Section 41 : Appendix Stacks + Queues
|
|
Lecture 1 | Stacks + Queues Introduction | 00:02:59 Duration |
|
|
Lecture 2 | Stacks | 00:03:29 Duration |
|
|
Lecture 3 | Queues | 00:03:31 Duration |
|
|
Lecture 4 | About Proctor Testing | |
|
|
Lecture 5 | Solution Stacks VS Queues | 00:03:39 Duration |
|
|
Lecture 6 | Stacks + Queues Review | 00:02:19 Duration |
Section 42 : Appendix Trees
|
|
Lecture 1 | Trees Introduction | 00:06:01 Duration |
|
|
Lecture 2 | Binary Trees | 00:05:45 Duration |
|
|
Lecture 3 | O(log n) | 00:07:00 Duration |
|
|
Lecture 4 | Binary Search Trees | 00:06:12 Duration |
|
|
Lecture 5 | Balanced VS Unbalanced BST | 00:03:42 Duration |
|
|
Lecture 6 | BST Pros and Cons | 00:02:27 Duration |
|
|
Lecture 7 | Tries | 00:03:17 Duration |
Section 43 : Appendix Searching + BFS + DFS
|
|
Lecture 1 | Graph + Tree Traversals | 00:03:56 Duration |
|
|
Lecture 2 | BFS Introduction | 00:02:45 Duration |
|
|
Lecture 3 | DFS Introduction | 00:03:23 Duration |
|
|
Lecture 4 | BFS vs DFS | 00:03:21 Duration |
|
|
Lecture 5 | Exercise BFS vs DFS | 00:00:44 Duration |
|
|
Lecture 6 | Solution BFS vs DFS | 00:03:16 Duration |
|
|
Lecture 7 | breadthFirstSearch() | 00:09:15 Duration |
|
|
Lecture 8 | PreOrder, InOrder, PostOrder | 00:05:21 Duration |
|
|
Lecture 9 | depthFirstSearch() | 00:12:03 Duration |
Section 44 : Appendix Recursion
|
|
Lecture 1 | Recursion Introduction | 00:05:37 Duration |
|
|
Lecture 2 | Stack Overflow | 00:06:17 Duration |
|
|
Lecture 3 | Anatomy Of Recursion | 00:10:27 Duration |
|
|
Lecture 4 | Recursive VS Iterative | 00:04:16 Duration |
|
|
Lecture 5 | When To Use Recursion | 00:04:00 Duration |
|
|
Lecture 6 | Recursion Review | 00:02:47 Duration |
Section 45 : Appendix Sorting
|
|
Lecture 1 | Sorting Introduction | 00:06:45 Duration |
|
|
Lecture 2 | The Issue With sort() | 00:06:51 Duration |
|
|
Lecture 3 | Sorting Algorithms | 00:03:38 Duration |
|
|
Lecture 4 | Bubble Sort | 00:03:46 Duration |
|
|
Lecture 5 | Exercise Bubble Sort | |
|
|
Lecture 6 | Solution Bubble Sort | 00:05:07 Duration |
|
|
Lecture 7 | Selection Sort | 00:02:39 Duration |
|
|
Lecture 8 | Exercise Selection Sort | |
|
|
Lecture 9 | Solution Selection Sort | 00:02:23 Duration |
|
|
Lecture 10 | Dancing Algorithms | 00:01:36 Duration |
|
|
Lecture 11 | Insertion Sort | 00:02:38 Duration |
|
|
Lecture 12 | Exercise Insertion Sort | |
|
|
Lecture 13 | Solution Insertion Sort | 00:02:07 Duration |
|
|
Lecture 14 | Merge Sort and O(n log n) | 00:08:59 Duration |
|
|
Lecture 15 | Exercise Merge Sort | |
|
|
Lecture 16 | Solution Merge Sort | 00:04:44 Duration |
|
|
Lecture 17 | Quick Sort | 00:07:40 Duration |
