JavaScript Algorithms - The Fundamentals

Learn all the core basics and fundamentals about JavaScript algorithms, dive into tons of examples and get a plan for building and measuring algorithms.

JavaScript Algorithms - The Fundamentals

Course Overview

About This Course

You can write code that works—and still feel stuck when a problem doesn’t come with a clear path. Interviews make that gap painfully obvious, but it also shows up in day-to-day development when you’re unsure whether your solution is actually a good one.

This course gives you a structured way to think: you’ll move step by step through the core ideas behind algorithms, using small, focused JavaScript examples and slide visualizations that make each building block click before you stack the next one on top.

By the end, you’ll be able to derive an algorithm for a new problem, explain why it works, and defend why it’s a better choice than alternatives. You’ll have a repeatable plan for tackling unfamiliar challenges, plus the foundation you need to build and optimize your own solutions with confidence.

What You'll Learn

You’ll build a practical algorithm toolkit in JavaScript: from analyzing performance to choosing the right problem-solving strategy for a given task.

  • Define algorithmic solutions

    Turn a problem statement into a clear algorithmic approach you can implement in JavaScript. You’ll know what an algorithm is and how to reason about different kinds you’ll encounter.

  • Compare algorithm quality

    Judge and compare multiple solutions to the same problem instead of stopping at the first working answer. You’ll be able to explain tradeoffs and pick a fitting approach for the constraints.

  • Analyze Big O

    Determine time complexity and space complexity using Big O notation. You’ll derive different time complexities and use them to predict how solutions scale.

  • Use recursion effectively

    Apply recursion as a tool for algorithm design, not a mystery. You’ll know when recursion is a good fit and how it changes the structure of your solution.

  • Apply dynamic programming

    Optimize solutions with Dynamic Programming when repeated subproblems make naive approaches slow. You’ll recognize dynamic approaches and use them to improve performance.

  • Solve core problem types

    Work confidently with the fundamental building blocks behind math, search, sorting, and sets/array algorithms. You’ll also distinguish between greedy and dynamic ways of solving problems.

Ready to get started?

See enrollment options

Prerequisites

  • Solid programming fundamentals are required; prior algorithm knowledge is not assumed.

  • Preferably, you’re comfortable reading and writing JavaScript, since it’s the language used throughout the course.

Who Is This Course For?

  • Interview candidates

    You can code, but algorithm questions feel like guesswork under pressure. This course gives you a dependable way to reason through problems and justify your choices.

  • Growing developers

    You want to take the next step beyond “it works” and start thinking in scalable solutions. This is for you if you’re ready to evaluate and improve your own approaches.

  • JavaScript learners

    You’ve built a foundation in JavaScript and now want to strengthen your problem-solving mindset in the same language. You’ll get a clear path into algorithms without needing prior exposure.

Curriculum Overview

Start Now

Preview the structure and pacing of this course before you begin.

  • Getting Started13 lectures1h 1m
    • 01Welcome to the Course!0:58 min
    • 02What & Why6:42 min
    • 03Join the Learning Community0:00 min
    • 04Measuring Algorithm Performance & Time Complexity9:31 min
    • 05Big O Notation6:57 min
    • 06Deriving the Time Complexity / Big O of an Algorithm11:27 min
    • 07Constant Time4:50 min
    • 08Using Big O For Algorithm Comparison3:42 min
    • 09A First Task!2:13 min
    • 10Solution & A Gotcha10:01 min
    • 11About this Course & Outline5:30 min
    • 12Module Resources0:00 min
    • 13The Academind Pro Referral Program0:00 min
  • Math Algorithms & Practicing The Basics17 lectures1h 33m
    • 01Module Introduction1:38 min
    • 02The Fibonacci Problem3:30 min
    • 03The Fibonacci Solution5:42 min
    • 04Fibonacci Big O (Time Complexity)4:17 min
    • 05The "Is Prime" Problem2:33 min
    • 06The "Is Prime" Solution3:56 min
    • 07"Is Prime", Big O & Multiple Cases12:48 min
    • 08"Is Prime" - Improved Version6:44 min
    • 09Time to Practice (Problem)1:27 min
    • 10Time to Practice (Solution)12:50 min
    • 11Identifying Big O Quickly5:53 min
    • 12Is Power Of Two Algorithm8:06 min
    • 13Logarithmic Time Complexity7:29 min
    • 14Bitwise Operators & Power Of Two8:19 min
    • 15Again: Identifying Big O Quickly2:50 min
    • 16The Factorial Algorithm5:12 min
    • 17Module Resources0:00 min
  • Recursion & Dynamic Programming8 lectures43m
    • 01Module Introduction1:06 min
    • 02Recursion in Algorithms8:30 min
    • 03Exponential Time Complexity11:30 min
    • 04Quadratic Time Complexity vs Exponential Time Complexity5:08 min
    • 05What is "Dynamic Programming"?3:25 min
    • 06"Dynamic Programming" in Action9:22 min
    • 07The "Bottom Up" Approach4:37 min
    • 08Module Resources0:00 min
  • Search Algorithms11 lectures1h 1m
    • 01Module Introduction2:04 min
    • 02What Search Algorithms Are About1:19 min
    • 03Introducing Linear Search1:41 min
    • 04Linear Search in Action10:39 min
    • 05Linear Search Time Complexity4:21 min
    • 06Binary Search in Theory2:50 min
    • 07Binary Search in Action11:46 min
    • 08Binary Search Time Complexity3:20 min
    • 09Recursive Binary Search13:05 min
    • 10The Master Theorem10:39 min
    • 11Module Resources0:00 min
  • Sorting Algorithms13 lectures1h 19m
    • 01Module Introduction0:52 min
    • 02What are Sorting Algorithms About?1:11 min
    • 03Bubble Sort - Theory5:07 min
    • 04Bubble Sort in Action17:31 min
    • 05Bubble Sort Time Complexity3:41 min
    • 06Quicksort - Theory2:55 min
    • 07Quicksort in Action13:14 min
    • 08Quicksort Time Complexity8:04 min
    • 09Merge Sort - Theory4:09 min
    • 10Merge Sort in Action16:38 min
    • 11Merge Sort Time Complexity4:01 min
    • 12Summary2:04 min
    • 13Module Resources0:00 min
  • Space Complexity11 lectures32m
    • 01Module Introduction1:13 min
    • 02Introducing Space Complexity3:02 min
    • 03Deriving Space Complexity2:39 min
    • 04Factorial Algorithm (Loop) - Space Complexity5:06 min
    • 05Factorial Algorithm (Recursive) - Space Complexity3:58 min
    • 06Linear Search - Space Complexity3:23 min
    • 07Binary Search - Space Complexity2:24 min
    • 08Bubble Sort - Space Complexity2:04 min
    • 09Quicksort - Space Complexity6:00 min
    • 10Merge Sort - Space Complexity2:13 min
    • 11Module Resources0:00 min
  • Sets (Array) Algorithms11 lectures1h 18m
    • 01Module Introduction1:50 min
    • 02An Introduction to Sets3:17 min
    • 03The Cartesian Product Algorithm5:11 min
    • 04Cartesian Product - Time Complexity5:10 min
    • 05The Cartesian Product Algorithm - Without Limits16:37 min
    • 06The Permutations Algorithms3:27 min
    • 07Permutations without Repetitions19:00 min
    • 08Understanding Permutations4:44 min
    • 09Permutations without Repetitions - Big O3:53 min
    • 10Permutations WITH Repetitions15:15 min
    • 11Module Resources0:00 min
  • More Complex Algorithms & How To Solve Code Problems16 lectures1h 45m
    • 01Module Introduction1:07 min
    • 02Solving Problems In A Structured Way7:06 min
    • 03Simplifying Problems4:00 min
    • 04Practice Makes Perfect!1:35 min
    • 05The Knapsack Problem (0/1)1:47 min
    • 06A Wrong Approach5:21 min
    • 07Approaching the Problem Differently5:26 min
    • 08A Working Knapsack Solution18:21 min
    • 09An Improved Knapsack Algorithm14:47 min
    • 10Greedy vs Dynamic Algorithms3:48 min
    • 11A Greedy Knapsack Algorithm9:46 min
    • 12A New Problem Solving Plan2:50 min
    • 13The Change Making Problem3:31 min
    • 14A Greedy Change Making Algorithm12:40 min
    • 15A Variation to the Change Making Problem13:17 min
    • 16Module Resources0:00 min

And 1 more sections in the full course.

Ready to Get Started?

Choose the option that works best for you.

Single Course

JavaScript Algorithms - The Fundamentals

One Payment. Lifetime Access.

$89one-time

  • One-time payment
  • All future updates for this course
  • Downloadable resources & code
  • Certificate of completion
  • Hands-on exercises & projects
  • Self-paced learning
  • English captions on all videos
  • Lifetime access