Introduction
Get an overview of your program. Meet your instructors, and refresh your python skills. Learn the framework to deconstruct any open-ended problem and then understand the concepts of time and space complexity, essential tools for evaluating different data structure & algorithms.
Python Refresher
02. Control Structures
03. Functions & Generators
04. Classes
04. Classes
How to Solve Problems
02. How to Solve Problems0:47
03. Days Between Dates00:00
04. Attempting the Problem [workspace]00:00
05. First Step00:00
05.2 First Step00:00
06. Understanding a Problem0:45
07. The First Rule0:22
08. What Are the Inputs1:54
09. How Are Inputs Represented00:00
10. What Are the Outputs0:35
10.2 What Are the Outputs0:43
11. Obey the Rules00:00
12. Next Step00:00
12.2 Next Step00:00
13. The Expected Output00:00
13.2 The Expected Output00:00
14. Take the Next Step00:00
15. Try an Example00:00
16. Harder Example00:00
17. Algorithm Pseudocode00:00
18. Should We Implement It00:00
18.2 Should We Implement It00:00
19. Different Approach00:00
20. Simple Mechanical Algorithm00:00
20.2 Simple Mechanical Algorithm00:00
21. Don’t Optimize Prematurely00:00
22. What Should We Write First00:00
22.2 What Should We Write First00:00
23. Define Simple nextDay1:25
23.2 Define Simple nextDay1:25
24. Making Progress Is Good0:29
25. What Should We Do Next00:00
25.2 What Should We Do Next0:39
26. Define daysBetweenDates0:37
27. Step One Pseudocode00:00
28. Step Two Helper Function00:00
29. Step Three daysBetweenDates00:00
30. Test for Valid Inputs00:00
30.2 Test for Valid Inputs00:00
31. Real World Problem00:00
32. Best Strategy00:00
32.2 Best Strategy3:01
33. Completing the Problem00:00
34. Finish daysBetweenDates0:27
35. Solution Step I2:01
36. Solution Step II1:39
37. Solution Step III2:52
38. Solution Step IV0:54
39. Conclusion00:00
Efficiency
01. Efficiency2:28
01. Efficiency Practice00:00
01. Efficiency
02. Quantifying Efficiency
02. Quantifying Efficiency
02. Quantifying Efficiency Practice00:00
03. Input Size and Efficiency
03. Input Size and Efficiency
03. Input_Size_Efficiency Practice00:00
04. Big O Notation (1/2)2:46
04. Big O Notation (1/2)
04. Big O Notation (1/2) Practice00:00
05. Big O Notation (2/2)00:00
06. Worst Case and Approximation1:45
06. Worst Case and Approximation
06.2 Worst Case and Approximation00:00
06. Worst Case and Approximation Practice00:00
07. Efficiency Practice
07. Efficiency Practice
08. Space Complexity00:26
Unscramble Computer Science Problems
01. Project Introduction
Environment00:00
Project Rubric - Unscramble Computer Science Problems
Project Description - Unscramble Computer Science Problems
Arrays and Linked Lists
01. Collections1:11
02. Lists1:10
03. Arrays2:41
04. Strings
05. Linked Lists Introduction1:24
06. Linked Lists Continued2:40
07. Implement a Linked List
08. Types of Linked Lists
09. Linked List Practice
10. Reverse a Linked List
11. Loop Detection
12. Flatten a Nested Linked List
13. Add One
14. Duplicate Number
15. Max Sum Subarray
16. Pascal’s Triangle
17. Even After Odd
18. Skip i, delete j
19. Swap Nodes
20. Interlude00:00
Stacks and Queues
01. Stacks Introduction00:46
02. Stacks Details00:00
03. Implement a Stack Using an Array
04. Implement a Stack Using a Linked List
05. Build a Stack
06. Practice: Balanced Parentheses
07. Reverse Polish Notation
08. Reverse a Stack
09. Minimum Bracket Reversals
10. Queues00:00
10. Queues
11. Build a Queue Using an Array
12. Build a Queue Using a Linked List
13. Build a Queue Using a Stack
14. Build a Queue Using High-Level Python
15. Reverse a Queue
16. Interlude1:01
Recursion
01. Recursion Introduction6:52
02. Recursion
03. Factorial Function
04. Reverse a String
05. Palindrome Checking
06. List Permutations
07. String Permutations
08. Keypad Combinations
09. Deep Reverse
10. The Call Stack and Recursion
11. Recurrence Relations00:00
12. Tower of Hanoi00:00
13. Return Codes00:00
14. Return Subsets00:00
15. Staircase00:00
16. Last Index00:00
17. Interlude1:26
Trees
01. Trees0:39
02. Tree Basics1:27
03. Tree Terminology00:00
03. Tree Terminology
04. Tree Traversal1:49
05. Depth-First Traversals00:00
06. Search and Delete00:00
07. Insert00:00
08. Binary Search Trees00:00
09. BSTs00:00
10. BST Complications00:00
11. Practice overview00:00
12. Code: Create a Binary Tree00:00
12.2 Code: Create a Binary Tree00:00
12.3 Code: Create a Binary Tree00:00
12.4 Code: Create a Binary Tree00:00
12.5 Code: Create a Binary Tree00:00
12.6 Code: Create a Binary Tree00:00
12.7 Code: Create a Binary Tree00:00
12.8 Code: Create a Binary Tree00:00
12.9 Code: Create a Binary Tree00:00
12.10 Code: Create a Binary Tree00:00
12.11 Code: Create a Binary Tree00:00
12.12 Code: Create a Binary Tree00:00
12.13 Code: Create a Binary Tree00:00
12.14 Code: Create a Binary Tree00:00
13. Code: DFS00:00
13.2 Code: DFS00:00
13.3 Code: DFS00:00
13.4 Code: DFS00:00
13.5 Code: DFS00:00
13.6 Code: DFS00:00
13.7 Code: DFS00:00
13.8 Code: DFS00:00
13.9 Code: DFS00:00
13.10 Code: DFS00:00
13.11 Code: DFS00:00
14. Code: BFS00:00
14.2 Code: BFS00:00
14.3 Code: BFS
14.4 Code: BFS00:00
14.5 Code: BFS00:00
14.6 Code: BFS00:00
14.7 Code: BFS00:00
14.8 Code: BFS00:00
15. Code: BST00:00
15.2 Code: BST00:00
15.3 Code: BST00:00
15.4 Code: BST00:00
15.5 Code: BST00:00
15.6 Code: BST00:00
15.7 Code: BST
15.8 Code: BST00:00
15.9 Code: BST00:00
16. Diameter of a Binary Tree
17. Path From Root to Node
18. Interlude3:40
Maps and Hashing
01. Introduction to Maps00:00
02. Sets and Maps00:00
03. Exploring the Map Concept
04. Introduction to Hashing00:00
05. Hashing00:00
06. Collisions00:00
07. Hash Maps00:00
08. Hash Maps Notebook
09. String Keys00:00
10. Caching
11. String Key Hash Table
12. Practice: Pair Sum to Target
13. Practice: Longest Consecutive Subsequence
14. Interlude1:05
Show Me the Data Structures
01. Introduction to the Project
02. Problem 1: LRU Cache00:00
03. Problem 2: File Recursion00:00
04. Problem 3: Huffman Coding00:00
05. Problem 4: Active Directory00:00
06. Problem 5: Blockchain00:00
07. Problem 6: Union and Intersection00:00
Project Description - Show Me the Data Structures
Project Rubric - Show Me the Data Structures
Basic Algorithms
Learn and implement basic algorithms such as searching and sorting on different data structures and examine the efficiency of these algorithms. Use recursion to implement these algorithms and then learn how some of these algorithms can be implemented without recursion. Practice selecting and modifying these algorithms for a variety of interview problems.
01. Binary Search1:28
01. Binary Search
02. Efficiency of Binary Search8:44
03. Binary Search Practice
04. Binary Search Variation
05. Binary search: First and last indexes
06. Tries
07. Heaps00:00
08. Heapify00:00
09. Heap Implementation00:00
10. Heaps Exercise
11. Self-Balancing Tree00:00
12. Red-Black Tree Insertion00:00
13. Tree Rotations00:00
14. Build a Red-Black Tree
15. Interlude00:00
Sorting Algorithms
01. Intro to Sorting00:00
02. Bubble Sort00:00
03. Efficiency of Bubble Sort00:00
04. Practice: Bubble Sort
05. Merge Sort4:17
06. Efficiency of Merge Sort00:00
07. Merge Sort Walkthrough
08. Merge Sort: Counting Inversions
09. Case Specific Sorting of Strings
10. Quicksort00:00
11. Quicksort Efficiency00:00
12. Quick Sort Walkthrough
13. Heapsort
14. Pair Sum
15. Sort 0, 1, 2
Faster Divide & Conquer Algorithms
01. Divide & Conquer0:25
02. Median Problem2:10
03. Basic Approach00:00
04. Search Example00:00
05. D & C : High Level00:00
06. D&C Recursive Pivot00:00
07. Median: Pseudocode00:00
08. Median Running Time00:00
Problems vs. Algorithms
01. Introduction to the Project
02. Problem 1: Square Root of an Integer
03. Problem 2: Search in a Rotated Sorted Array
04. Problem 3: Rearrange Array Digits
05. Problem 4: Dutch National Flag Problem
06. Problem 5: Autocomplete with Tries
07. Problem 6: Unsorted Integer Array
08. Problem 7: Request Routing in a Web Server with a Trie
Project Description - Problems vs. Algorithms
Project Rubric - Problems vs. Algorithms
Greedy Algorithms
Build on your algorithm skills by learning more advanced algorithms such as brute-force greedy algorithms, graph algorithms, and dynamic programming, which optimizes recursion by storing results to sub problems.
01. Introduction
02. Min Platforms Exercise
03. Min Operations
Graph Algorithms
01. Graph Introduction00:00
02. What is a Graph?00:00
03. Directions and Cycles00:00
04. Connectivity00:00
05. Graph Representation00:00
06. Adjacency Matricies00:00
07. Graph Traversal00:00
08. DFS00:00
09. Implement DFS - Iterative Solution
10. Implement DFS - Recursive Solution
11. BFS00:00
12. Implement BFS
13. Shortest Path & Diijkstra’s Algorithm00:00
13.2 Shortest Path & Diijkstra’s Algorithm00:00
14. Diijkstra’s Algorithm Exercise
15. Connecting Islands
Dynamic Programming
01. Knapsack Problem00:00
02. Smarter Approach00:00
03. Dynamic Programming00:00
04. Knapsack Exercise
05. Longest Common Subsequence Exercise
06. Longest Palindromic Subsequence
07. The Coin Change Problem
08. Stock Prices
A
01. Introduction00:00
01. Introduction
02. What Is A Problem?00:00
03. Example: Route Finding00:00
04. Uniform Cost Search00:00
04. Uniform Cost Search
05. Uniform Cost Search00:00
05. Uniform Cost Search
06. Uniform Cost Search 200:00
06. Uniform Cost Search 2
07. Uniform Cost Search 300:00
07. Uniform Cost Search 3
08. Uniform Cost Search 400:00
08. Uniform Cost Search 4
09. Uniform Cost Search 500:00
10. On Uniform Cost00:00
11. A* Search00:00
11. A* Search
11.2 A* Search00:00
12. A* Search 100:00
12. A* Search 1
12.2 A* Search 100:00
13. A* Search 200:00
13. A* Search 2
13.2 A* Search 200:00
14. A* Search 300:00
14. A* Search 3
14.2 A* Search 300:00
15. A* Search 400:00
15. A* Search 4
15. A* Search 4
16. A* Search 500:00
Route Planner
01. About this Project00:00
02. Project Specifics
03. Notebook - Implement Route Planner
04. Congratulations!00:00
Project Description - Route Planner
Project Rubric - Route Planner
01. Prepared for Programming
The data structures and algorithms you learn in this program can be implemented in any number of different languages. For that reason, when we discuss these concepts in videos, we’ll explain them in general terms and demonstrate them using pseudocode.
However, it’s also essential to get lots of practice applying the algorithms for yourself, so we’ll provide exercises and projects where you can implement the algorithms using concrete code.
The language we’ll be using for these exercises is Python 3. It will help you a lot if you take the time now to make sure your understanding of fundamental Python is strong. In this section, we’ll briefly review some of the main concepts you should know. This will help you see if you have areas where you need to do some additional review or practice.
At the bottom of the main menu for this Nanodegree, you’ll find an Extracurricular section. This contains our full Introduction to Python course. If you feel uncomfortable with any of the concepts we review in this brief refresher, feel free to use the full Python course to go deeper.
