Table of Contents
Introducing Practical Guide to AlgorithmsBianca Gandolfo introduces herself and talks about why algorithms are essential to all engineers.
Space & Time Complexity
Introducing Space & Time ComplexityBianca introduces the concept of time complexity, space complexity, and understanding algorithmic speed. Bianca answers questions from students.
Big O NotationBianca reviews the different big O notations: constant, linear, quadratic, logarithmic, and exponential.
Space Complexity & ReviewAfter discussing space complexity, Bianca reviews Big O notations and time complexity.
Big O: LoopBianca dissects function with a loop to reason about the time complexity.
Big O: Property LookupBianca walks through a property lookup in an array.length and measures time complexity.
Big O: Push, Shift, & UnshiftBianca contrasts different array methods and their respective time complexity.
Optimization with Caching
Faster AlgorithmsBianca reviews two common ways to speed up algorithms through caching previous values significantly.
Unique Sort ExerciseIn this exercise, students Implement unique sort, which removes duplicates from an array.
Unique Sort SolutionBianca reviews the breadcrumbs caching technique while walking through the unique sort solution.
Caching with MemoizationBianca discusses the difference between memoizing and the breadcrumbs caching technique.
Basic Memoization ExerciseIn this exercise, students use a global cache to memoize.
Basic Memoization SolutionBianca walks through the Basic Memoization Exercise and answers questions from students.
Memoization with Closure ExerciseIn this exercise, students improve the memoize function by moving the cache into a closure.
Memoization with Closure SolutionBianca walks through the Memoization with Closure Exercise to show how to use a closure to make the cache local. Bianca answers questions from students.
Generic Memoize Function ExerciseIn this exercise, students make a memoize function generic by passing in the function rather than hardcoding a function.
Generic Memoize Function SolutionBianca reviews the previous two exercises and walks through how to transform the hardcoded memoize function into a generic memoize function.
Reviewing OptimizationBianca wraps up discussing the different caching techniques by reviewing the trade-off between time complexity and space complexity.
Introducing RecursionBianca introduces recursion, which is when a function calls itself, and its importance in programming.
Looping with RecursionBianca walks through an example of loop implementing through the use of recursion.
Factorial with a LoopBianca looks at how the factorial algorithm would be implemented with a for() loop. The loop starts at the number 2 and continues to multiply the numbers together until the desired factorial is reached.
Looping ReviewBianca reviews the differences and benefit of recursion and a loop.
Wrapper FunctionsBianca introduces wrapper functions as a pattern for recursion.
AccumulatorsBianca walks through the accumulator technique, which gathers all callbacks returned values.
Iterative Loop ExerciseIn this exercise, students translate a recursive pattern into an iterative loop.
Iterative Loop SolutionBianca walks through the solution to Iterative Loop Exercise.
Recursive Factorial & Memoize ExerciseIn this exercise, students write their own recursive factorial method.
Recursive Factorial & Memoize SolutionBianca walks through the solution to Recursive Factorial & Memoize Exercise.
Divide & Conquer
Introducing Divide & ConquerBianca introduces what divide and conquer method to sorting. After data is separated into smaller lists, the merge step combines two sorted lists into one sorted list.
Linear Search ExerciseIn this exercise, students implement linear search.
Linear Search SolutionBianca walks through the solution to Linear Search Exercise. Bianca answers questions from students.
Binary SearchBianca illustrates binary search, which allows a search of a sorted array by repeatedly splitting the array in half. Binary search is fast Since with each iteration half of the array is determined to be undesired, instead of just one wrong value.
Divide & Conquer ReviewBianca reviews divide and conquer.
Sorting TypesBianca discusses the two main types of sorting: naive and divide & conquer. Bianca answers questions from students.
Merge SortBianca reviews merge sort, which is an algorithm that takes a "divide and conquer" approach to sorting. With merge sort, data is separated into smaller lists, the merge step combines two sorted lists into one sorted list.
Merge Sort WalkthroughBianca walks through a code example of merge sort.
Bubble Sort & Merge Sort ExerciseIn this exercise, students implement bubble sort and merge sort.
Bubble Sort SolutionBianca walks through the first part of the Bubble Sort & Merge Sort Exercise by coding the solution to bubble sort.
Merge Sort SolutionBianca walks through the last part of the Bubble Sort & Merge Sort Exercise by coding the solution to mergesort. Bianca answers questions from students.
Introducing GreedyBianca introduces the greedy algorithm, which is an algorithmic paradigm that follows the problem-solving course of making the locally optimal choice.
Greedy Algorithms WalkthroughBianca walks through a "make change" problem to demonstrate the greedy algorithm.
Brute ForceBianca reviews the brute force approach, which calculates every single combination possible and keeps track of the minimum. Bianca answers questions from students.
Introducing Dynamic ProgrammingBianca discusses dynamic programming, which is a data optimization technique. The dynamic approach caches values to avoid repeated calculations. Bianca answers questions from students.
Memoization with RecursionBinca reviews memoization and recursive approach to the "make change" problem.
The Landscape of Data Structures & AlgorithmsBianca wraps up "A Practical Guide to Algorithms" course by reviewing the landscape of data structures and algorithms. Bianca answers questions from students.