Teach on Udemy

Turn what you know into an opportunity and reach millions around the world.

Learn More

Your cart is empty.

Keep shopping

Data Structures and Algorithms in JavaScript: DSA Course

Name: Data Structures and Algorithms in JavaScript: DSA Course
Rating: 4.7 (656 reviews)

Master JavaScript DSA for LEETCODE & Coding Interviews | 50-Day Learning Path with Hands-on Exercises

Role Play

Created byJackson Kailath

Last updated 12/2025

English

What you'll learn

Master DSA in JavaScript including Arrays, LinkedLists, Trees, Graphs
Solve DSA with JavaScript for coding interviews and LEETCODE
Build JavaScript data structures from scratch
Real coding interview problems using JS DSA
Real Coding Interview Questions from Google, Meta,Amazon,Netflix ,Microsoft etc.
Boost your Problem solving skills

Coding Exercises

This course includes our updated coding exercises so you can practice your skills as you learn.

Course content

63 sections • 678 lectures • 68h 0m total length

What you're going to get from this course7:48
Welcome! How to make best use of this course (Please Watch)4:02
Day 1 Goals0:35
Introduction to Data Structures4:34
Introduction to Big O, Time Complexity14:00
Asymptotic Analysis and Big O16:36
Big O Space Complexity3:49
Big O Logarithm5:12
Understand base-two logarithms in coding interviews with examples like log 16 = 4 and log 8 = 3. Connect to binary search by noting halving inputs yields log-time complexity.
Arrays: Data Structures Crash Course13:20
Quiz: Arrays
CODING EXERCISES0:31
How to log output to debug code in Udemy Editor0:17
CODING INTERVIEW Q1 (Easy): Sorted Squared Array4:45
CODING INTERVIEW Q1 (Easy): Sorted Squared Array
Method 1, Big O Analysis3:05
Explore the brute force method: square each array element into a new array, then sort for the final order. It runs in O(n log n) time and uses O(n) space.
JS Code - Method 13:15
Create a new array of the input length, fill with zeros, square each value, then sort ascending and return the result, using console logs for debugging.
Method 27:29
Leverage the sorted input and a two-pointer approach to square the extreme elements and fill a new array from the end, achieving O(n) time with O(n) space.
JavaScript Code - Method 24:07
CODING INTERVIEW Q2 (Easy): Monotonic Array5:14
Coding Exercise: Monotonic Array
Method and Big O analysis7:17
JavaScript Code - Monotonic Array6:14
Role Play( Beta) : Sorted Squarred Array
Celebrating Milestones0:43

For Quick Reference: Latest Additions to the Course0:54
Best Study Technique to prepare for Coding Interviews0:55
Day 2 Goals1:11
Recursion Basics9:21
Recursive Leap of Faith12:49
Visualising Recursion8:53
Recursion vs Iteration4:20
Ways to write Base condition3:31
Recurrence relation1:59
How to Solve Recursion Questions5:17
Recursion Approaches - 0 to N and N to 06:45
Recursion is everywhere2:24
Complexity Analysis of Recursive Solutions2:19
Quiz: Recursion
CODING INTERVIEW QUESTION (Medium): k-th symbol in Grammar7:00
Coding Exercise (k-th symbol in Grammar)
Approach(k-th symbol in Grammar)12:45
Explore a recursive approach to the k-th symbol in grammar, using base case n=1 and recurrence relations, with half-split logic and not operations.
Pseudocode (k-th symbol in Grammar)3:10
Present pseudocode for the k-th symbol in grammar using a recursive k gram; base case n=1 returns 0, with length 2^(n-1) and a midpoint split, and analyze complexity.
Complexity Analysis(k-th symbol in Grammar)4:22
JavaScript Solution (k-th symbol in Grammar)4:44
CODING INTERVIEW QUESTION (Medium): Josephus problem6:46
Coding Exercise: Josephus problem
Approach 17:52
Examine three approaches to the Josephus problem, from a recursive base with O(n^2) to an iterative O(n) solution using modulo and zero-based indexing.
Pseudocode3:24
Complexity Analysis1:42
JavaScript Solution 1: Josephus problem Method 14:39
Learn a JavaScript solution to josephus problem using a recursive helper and array, computing removal index with (start + k - 1) mod length and splicing until one winner remains.
Approach 210:04
Pseudocode6:20
Complexity Analysis1:38
JavaScript Solution 2 : Josephus problem Method 23:04
Approach 35:10
Complexity Analysis1:12
JavaScript Solution 3 : Josephus problem Method 31:55
Celebrating Milestones0:33

Day 3 Goals1:01
CODING INTERVIEW QUESTION (Medium): Tower of Hanoi4:11
Coding Exercise(Tower of Hanoi)
Identifying that wew can use Recursion2:59
Approach6:09
Recursion Tree8:40
Examine the recursion tree for Tower of Hanoi with three disks, detailing recursive calls, base cases, and print steps moving disks from rod one to rod three via auxiliary rod.
JavaScript Solution : Tower of Hanoi6:53
Complexity Analysis : Tower of Hanoi8:21
CODING INTERVIEW QUESTION(Medium): Power Sum6:34
Coding Exercise: Power Sum
Method and Big O Analysis11:01
Implement a recursive sum power function for nested arrays, then determine time complexity O(n) and space complexity O(d).
JavaScript Solution: Power Sum1:57
Celebrating Milestones0:31

Day 4 Goals0:16
What is Backtracking12:21
How is it different from Recursion ?1:04
How does Backtracking work ?3:37
Backtracking explores one option at a time using recursion, pruning paths when constraints fail to efficiently find valid solutions, as illustrated by Sudoku’s empty-cell choices.
Pass by reference / change inplace4:19
Blueprint to solve questions using Backtracking7:16
Identify when to use Backtracking2:04
Quiz: Backtracking
CODING INTERVIEW QUESTION (Medium): Permutations2:56
Coding Exercise ( Permutations)
Approach8:33
Pseudocode6:47
JavaScript Solution : Permutations4:28
Implement a recursive solution to generate permutations with a helper and a results array, using a base case and backtracking via swaps to restore state.
Complexity Analysis3:37
CODING INTERVIEW QUESTION(Medium): Permutations 20:46
Coding Exercise: Permutations 2
Approach5:54
Pseudocode2:14
JavaScript Code: Permutations 24:31
Implement a recursive solution for permutations two using a helper function and index-based recursion. Prune duplicates with a hash table, backtrack by undoing swaps, and check test cases.
Complexity Analysis : Permutations 20:50
Celebrating Milestones0:31

Day 5 Goals0:21
CODING INTERVIEW QUESTION(Medium): Subsets2:39
Coding Exercise: Subsets
Method16:16
Learn to generate the power set by including or excluding each array element, yielding two to the power of n subsets; implement recursively (and iteratively) with a helper function.
Subsets - Comparison with Backtracking Blueprint2:40
Compare the pseudocode with the backtracking blueprint to generate subsets, highlighting the base condition, two choices: exclude and include, in place updates, and the backtracking pop.
Subsets - Complexity Analysis3:39
JavaScript Code - Subsets4:29
Implement a power set function in JavaScript using a recursive helper to generate all subsets by including or excluding each element, copying subsets with slice.
code walkthrough (optional)11:38
CODING INTERVIEW QUESTION(Medium): Subsets 20:43
Coding Exercise: Subsets 2
Approach8:47
Learn a duplicate tolerant approach to generating unique subsets by sorting the array, using include exclude branches, and skipping all duplicates in the exclude path.
JavaScript Code: Subsets 26:43
Subsets 2: Complexity Analysis1:45
Celebrating Milestones0:32

Day 6 Goals0:29
CODING INTERVIEW QUESTION(Medium): Combinations1:52
Coding Exercise: Combinations
Approach4:51
Explore a recursive backtracking approach to generate all k-element combinations from 1 to n using two pointers. See how i and j progress, backtrack, and build results.
Combinations : Complexity Analysis5:34
Analyze the time complexity of generating all k-length combinations by a recursive approach, showing it equals k times n choose k, with space complexity O(k) due to recursion depth.
JavaScript Code : Combinations5:26
Combinations: Optimisation3:55
JavaScript Code: Combinations with Optimisation0:43
CODING INTERVIEW QUESTION ( Medium) : Combinations Sum 11:31
Coding Exercise: Combinations Sum 1
Approach7:21
Complexity Analysis part 12:45
Sidenote: Max number of nodes5:23
Complexity Analysis part 23:10
JavaScript Code: Combinations Sum 14:40
Celebrating Milestones0:31

Day 8 Goals0:41
CODING INTERVIEW QUESTION(Hard) : Sudoku Solver4:27
Coding Exercise: Sudoku Solver
Approach9:08
Pseudocode5:52
The lecture presents pseudocode for a sudoku solver using backtracking, detailing how to identify the next empty cell, try numbers 1–9, validate choices, and prune invalid paths.
isValid check for Sudoku Solver6:50
JavaScript Code : Sudoku Solver13:16
Complexity Analysis2:30
Another approach - Sudoku Solver ( JavaScript Code)0:58
CODING INTERVIEW QUESTION(Hard): N Queen3:41
Coding Exercise: N Queen
Approach6:55
Pseudocode3:50
JavaScript Code: N Queen12:48
Complexity Analysis3:52

Day 9 Goals0:35
Introduction to Dynamic Programming (DP)12:56
Explore dynamic programming as recursion plus storage, using memoization and tabulation to solve problems like the Fibonacci sequence with fewer recomputations, highlighting overlapping subproblems and optimal substructure.
Dynamic Programming - Patterns2:39
Approach to solve DP(Dynamic Programming) Questions7:51
Why writing the Recursive solution helps to write the Bottom up approach3:35
Identifying Dynamic Programming Questions1:37
Quiz: Dynamic Programming
CODING INTERVIEW QUESTION(Easy): Fibonacci4:59
Implement a function that computes f(n) in the Fibonacci sequence for n >= 0 using f(0)=0, f(1)=1, and f(n)=f(n-1)+f(n-2). Explore multiple approaches and their time and space implications.
Coding Exercise: Fibonacci
Approaches0:58
Explore dynamic programming with the Fibonacci coding interview question, identifying overlapping subproblems and optimal substructure, and implement four approaches: recursive, memoized, bottom-up tabulation, and space-optimized tabulation.
Approach 1: Recursion2:35
Complexity Analysis: Approach 1 - Recursion9:16
JavaScript Code - Recursion1:16
Approach 2: Memoization6:15
Complexity Analysis : Approach 2 - Memoization1:47
JavaScript Code: Approach 2 - Memoization2:51
Approach 3: Tabulation3:29
Complexity Analysis: Approach 3 - Tabulation0:40
JavaScript Code: Approach 3 - Tabulation3:08
Approach 4: Space Optimised Tabulation + Complexity Analysis5:58
JavaScript Code: Approach 4 -Space Optimised Tabulation + Complexity Analysis2:56
Use a space-optimized tabulation to compute fib(n) in JavaScript, with prev, cur, and next updated in a while loop. Include a concise complexity analysis.
CODING INTERVIEW QUESTION(Easy): Climbing Stairs4:13
Coding Exercise: Climbing Stairs
Approach3:56

Day 10 Goals0:28
CODING INTERVIEW QUESTION(Easy): Min Cost Climbing Stairs2:59
Coding Exercise: Minimum Cost Climbing Stairs
Recursive Approach7:58
Complexity Analysis1:34
JavaScript Code: Recursive Approach2:40
Implement a recursive JavaScript solution for the minimum cost climbing stairs, using a helper, base case at n, and one- or two-step moves from index zero or one.
Memoization Approach5:24
Complexity Analysis1:39
JavaScript Code: Memoization Approach1:58
Tabulation Approach8:47
Complexity Analysis1:23
JavaScript Code: Tabulation Approach5:24
CODING INTERVIEW QUESTION(Easy): Tribonacci0:08
Coding Exercise: Tribonacci

Requirements

Basic knowledge of Javascript ( things like write a loop, function etc)
No experience with Data Structures or Algorithms required

Description

Looking for the best DSA JavaScript course? Master data structures and algorithms in JavaScript with this comprehensive JavaScript DSA course designed for LEETCODE and technical interviews. Learn DSA with JavaScript through 117 coding challenges across 50 structured days. Perfect for mastering DSA in JS and acing your next coding interview.

Student Testimonials:

"Basically I'm a beginner to javascript but after listening the way of his teaching , i have no word for him he's fabulous person . and I recommend all to watch his course." - Mohd. Amir
"Excellent explanations and application of theory directly to practice!" - GUILLERMO GABRIEL KELLY SCHMIDT
"Explanations and demonstrations are on point and it makes grasping easier.." - Emmanuel Apea
"Excellent Teaching" - Sarhan Sayyed Rasool Shaikh
"Excellent course. The teacher has mastery of what he explains and the content is of great value."-Vyctor Vieira Guimarães
"It's an amazing course the instructor is super amazing and the way of teaching it is super awesome clarify everything very well and the roadmap for learning DSA is superb. Go with this guy without a second thought you will love it for sure..." - Shashank Jaiswal
"Excellent, way of teaching" - Gauri Shankar Jangid

About the Course:

Welcome to the Data Structures and Algorithms Coding Interview Bootcamp with Javascript!

The primary goal of this course is to prepare you for coding interviews at top tech companies. By tackling one problem at a time and understanding its solution, you'll accumulate a variety of tools and techniques for conquering any coding interview.

Daily Data Structures and Algorithms Coding Challenges:

The course is structured around daily coding challenges. Consistent practice will equip you with the skills required to ace coding interviews. For the next 50 days commit to yourself to practice atleast 2 coding interview questions everyday. You don't need any setup for this as the daily coding problem challenges can be solved in the coding environment provided by Udemy. The course will automatically track your progress and you just need to spend your time making actual progress everyday.

Topics Covered:

We start from the basics with Big O analysis, then move on to very important algorithmic techniques such as Recursion, Backtracking and Dynamic Programming Patters. After this we move to cover common data structures, and discuss real problems asked in interviews at tech giants such as Google, Meta, Amazon, Netflix, Apple, and Microsoft.

For each question, we will:

Discuss the optimal approach
Explain time and space complexity
Code the solution in Javascript (you can follow along in your preferred language)

Additional Resources :

The course includes downloadable resources, motivational trackers, and cheat sheets.

Course Outline:

Day 1: Arrays, Big O, Sorted Squared Array, Monotonic Array
Day 2:Recursion,k-th symbol in Grammar,Josephus problem
Day 3:Recursion, Tower of Hanoi, Power Sum
Day 4:Backtracking, Permutations, Permutations 2
Day 5:Backtracking, Subsets, Subsets 2
Day 6:Backtracking, Combinations, Combinations Sum 1
Day 7:Backtracking,Combinations Sum 2,Combinations Sum 3
Day 8:Backtracking,Sudoku Solver, N Queens
Day 9:Dynamic Programming, Fibonacci, Climbing Stairs
Day 10:Dynamic Programming, Min Cost Climbing Stairs, Tribonacci
Day 11:Dynamic Programming, 01 Knapsack, Unbounded Knapsack
Day 12:Dynamic Programming, Target Sum, Partition Equal Subset Sum
Day 13:Dynamic Programming, LCS, Edit Distance
Day 14:Dynamic Programming, LIS, Max Length of Pair Chain, Russian Doll Envelopes
Day 15:Dynamic Programming, Palindromic Substrings, Longest Palindromic Substring, Longest Palindromic Subsequence
Day 16:Dynamic Programming, Palindrome Partitioning, Palindrome Partitioning 2
Day 17:Dynamic Programming, Word Break, Matrix Chain Multiplication
Day 18:Dynamic Programming, Kadane's algorithm - Max Subarray, Maximum Product Subarray
Day 19:Greedy Algorithms - Fractional Knpasack, Non overlapping Intervals
Day 20:Greedy Algorithms - Jump Game 1, Minimum # of arrows to burst baloons
Day 21:Greedy Algorithms - Two City Scheduling, Boats to Save people
Day 22:Greedy Algorithms - Task Scheduler, Largest Number
Day 23:Greedy Algorithms - Gas Stations, Jump Game 2
Day 24: Arrays, Rotate Array, Container with Most Water
Day 25: Hash Tables, Two Sum, Isomorphic Strings
Day 26: Strings, Non-Repeating Character, Palindrome
Day 27: Strings, Longest Unique Substring, Group Anagrams
Day 28: Searching, Binary Search, Search in Rotated Sorted Array
Day 29: Searching, Find First and Last Position, Search in 2D Array
Day 30: Sorting, Bubble Sort, Insertion Sort
Day 31: Sorting, Selection Sort, Merge Sort
Day 32: Sorting, Quick Sort, Radix Sort
Day 33: Singly Linked Lists, Construct SLL, Delete Duplicates
Day 34: Singly Linked Lists, Reverse SLL, Cycle Detection
Day 35: Singly Linked Lists, Find Duplicate, Add 2 Numbers
Day 36: Doubly Linked Lists, DLL Remove Insert, DLL Remove All
Day 37: Stacks, Construct Stack, Reverse Polish Notation
Day 38: Queues, Construct Queue, Implement Queue with Stack
Day 39: Binary Trees, Construct BST, Traversal Techniques
Day 40: Pre order and In order Traversal of Binary Tree - Iterative
Day 41: Post Order Traversal Iterative, Path Sum 2
Day 42: Construct Binary Tree from Pre and In order Traversal ^ In and Post order Traversal
Day 43: Binary Trees, Level Order Traversal, Left/Right View
Day 44: Level order Trav 2, ZigZag Traversal
Day 45: Vertical order Traversal, Sum root to leaf numbers
Day 46: Binary Trees, Invert Tree, Diameter of Tree
Day 47: Binary Trees, Convert Sorted Array to BST, Validate BST
Day 48: Lowest common Ancestor of BST, Unique BST 2
Day 49: Lowest common Ancestor of Binary Tree, Unique BST 1
Day 50: Serialize and Deserialize Binary Tree, N-ary Tree Level Order Traversal
Day 51: Heaps, Max Heap, Min Priority Queue
Day 52: Graphs, BFS, DFS
Day 53: Graphs, Number of Connected Components, Topological Sort
Day 54: Number of Provinces, Find if path exists in Graph
Day 55: Number of Islands, Numbers with same consecutive differences

My confidence in your satisfaction with this course is so high that we offer a complete money-back guarantee for 30 days! Thus, it's a totally risk-free opportunity. Register today, facing ZERO risk and standing to gain EVERYTHING.

So what are you waiting for? Join the best Javascript Data Structures & Algorithms Bootcamp on Udemy.

I'm eager to see you in the course.

Let's kick things off! :-)

Jackson

Who this course is for:

People looking to get into top Tech companies in Software Engineering roles
Folks looking to ace the DSA part in Data Science Interview
Self taught programmers looking for their first job
Experienced developers wanting to get into MAANG companies ( top tech firms)

Data Structures and Algorithms in JavaScript: DSA Course

What you'll learn

Explore related topics

Coding Exercises

Course content

Day 1: Arrays Data Structures and Algorithms21 lectures • 1hr 53min

Day 2: Recursion31 lectures • 2hr 27min

Day 3: Recursion Continued11 lectures • 58min

Day 4: Backtracking18 lectures • 1hr 12min

Day 5: Backtracking12 lectures • 1hr

Day 6: Backtracking14 lectures • 48min

Day 7: Backtracking8 lectures • 20min

Day 8: Backtracking13 lectures • 1hr 15min

Day 9: Dynamic Programming21 lectures • 1hr 24min

Day 10: Dynamic Programming Type - Fibonacci12 lectures • 40min

Requirements

Description

Who this course is for: