Introduction
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
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
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
Welcome!
Welcome to the Data Structures and Algorithms program!
At its core, this program is about how to write code to solve problems and to do so efficiently.
You’re probably well aware that computers can be used to solve all sorts of problems—from calculating the fastest route on a map, to sequencing the human genome. But there is almost always more than one way to solve a problem, and some ways can be dramatically more efficient than others. Two approaches may solve the same problem, but one may take milliseconds, while the other takes hours.
How do you look at a problem and identify different ways that you could solve it? And how do you know which approaches are more or less efficient? Will your solution run quickly or slowly? Will it take up a lot of space in the computer’s memory, or only a little? Being able to answer these kinds of questions will make you a more effective developer—and also help you perform much better during technical interviews.
The key to mastering these skills is practice. Simply hearing about algorithms and data structures will not make you proficient at analyzing or implementing them in a real-world situation. For that reason, our goal in this program is not only to explain key concepts, but also to give you lots of chances to practice the key skills through hands-on exercises.
Overview
Here’s a brief overview of what we’ll cover in the program.
1. Welcome
In this section, we’ll go over some important foundational topics. We’ll review some basic Python concepts that you’ll need, talk about how to solve problems, and then consider some of the fundamental ideas related to efficiency.
2. Data Structures
When you write code to solve a problem, there will always be data involved—and how you store or structure that data in the computer’s memory can have a huge impact on what kinds of things you can do with it and how efficiently you can do those things. In this section, we’ll explore different data structures, and consider the pros and cons of using different structures when solving different types of problems.
3. Basic Algorithms
To solve such problems, we need to come up with a very specific sequence of steps that will get us from whatever input we start with to the desired output. This kind of clear, highly specific procedure is called an algorithm. In this section, we’ll get started with some elementary algorithms, such as binary search and mergesort.
4. Advanced Algorithms
In this final part of the program, we’ll dive into some more advanced topics—including greedy algorithms, graph algorithms, dynamic programming, and linear programming.
Let’s get started!
