Your cart is empty.
Keep shopping
Teach on Udemy
Turn what you know into an opportunity and reach millions around the world.
Learn MoreMaster LeetCode: Conquer the Top 150 Problems
Rating: 4.5 out of 54.5(1 rating)
232 students
Master LeetCode: Conquer the Top 150 Problems
Master data structures & algorithms with step-by-step solutions to ace technical interviews & land your dream job.
Created byHarshit Shah
Last updated 11/2025
English
What you'll learn
- Master data structures and algorithms essential for solving LeetCode’s top 150 problems
- Develop advanced problem-solving skills to tackle complex coding challenges efficiently
- Learn to recognize patterns across different problem types and apply optimal solutions
- Improve coding speed and efficiency to solve multiple problems within time constraints, preparing for technical interviews
- Analyze time and space complexity to optimize solutions and impress interviewers with efficient code
- Master dynamic programming techniques to solve the most challenging algorithmic problems
- Learn effective whiteboarding techniques to clearly communicate you systematic debugging skills to identify and fix errors quickly during interviews.
- Build a strategic approach to interview preparation, including spaced repetition and targeted practice.
- Implement clean, readable code that follows best practices valued by top tech companies.
- Gain confidence in explaining complex algorithms through practice with clear verbal explanations.
- Apply problem decomposition strategies to break down intimidating problems into manageable components.
Explore related topics
Course content
20 sections • 96 lectures • 10h 51m total length
- Merge Sorted Array8:15
Mastering Merge Sorted Arrays: LeetCode #88 Solution
Problem Overview
In this lesson, we tackle LeetCode Problem 88: "Merge Sorted Array," where you need to combine two sorted integer arrays into a single sorted array in-place. The first array has enough space at the end to accommodate the second array.
Complexity Analysis
Time Complexity: O(m+n) where m and n are the lengths of the arrays
Space Complexity: O(1) as we modify the first array in-place
Key Concepts Covered
Two-pointer technique
In-place array manipulation
Merge operation from merge sort
Handling sorted data efficiently
Learning Points
How to efficiently merge two sorted arrays without extra space
Working backwards to avoid overwriting elements
Edge case handling when one array is empty
Practical application of the two-pointer technique in sorting problems
Join me as we solve this fundamental array manipulation problem step-by-step, building a solid foundation for more complex algorithm challenges! This solution technique appears frequently in technical interviews and is essential for your algorithmic toolkit.
- Remove Element6:19
Remove Element - LeetCode 27
Problem Overview
In this lesson, we'll tackle LeetCode's Problem 27: Remove Element. This is a fundamental array manipulation problem that tests your ability to modify an array in-place while maintaining certain conditions.
Key Concepts Covered
In-place array modification
Two-pointer technique
Element removal without auxiliary storage
Array traversal and manipulation
Solution Approach
We'll implement the efficient two-pointer technique to solve this problem, where one pointer tracks the position for the next valid element, while another scans through the array.
Time & Space Complexity
Time Complexity: O(n) - we traverse the array only once
Space Complexity: O(1) - we modify the array in-place without using extra space
Learning Points
Understanding how to modify arrays in-place
Implementing the two-pointer technique effectively
Handling edge cases with arrays
Optimizing solutions by avoiding unnecessary operations
Join me in this lesson to master this fundamental array manipulation technique that appears frequently in coding interviews!
- Remove Duplicates from Sorted Array7:26
Remove Duplicates from Sorted Array: A Step-by-Step Guide
Problem Overview
In LeetCode's Problem 26, you are given a sorted array of integers, and your task is to remove duplicates "in-place" so that each element appears only once while maintaining the relative order of the elements.
Complexity Analysis
Time Complexity: O(n) - We make a single pass through the array
Space Complexity: O(1) - We modify the array in-place with only a few pointer variables
Key Concepts Covered
Two-pointer technique
In-place array manipulation
Handling sorted arrays efficiently
Learning Points
How to solve problems without using extra space
Importance of taking advantage of the array's sorted property
Understanding "in-place" operations in arrays
Implementing the two-pointer approach for array manipulation
What You'll Learn
In this lesson, we'll walk through a clean, efficient solution that uses the two-pointer technique to solve this common interview problem. You'll master a fundamental array manipulation pattern that appears frequently in coding interviews at top tech companies.
- Remove Duplicates from Sorted Array II7:08
Solving LeetCode 80: Remove Duplicates from Sorted Array II
Brief problem overview
This problem asks you to modify a sorted array in-place so that each unique element appears at most twice, and return the length of the modified array.
Time and space complexity: The optimal solution has O(n) time complexity, where n is the length of the input array, and O(1) space complexity as we modify the array in-place.
Key concepts covered:
Two-pointer technique
In-place array manipulation
Array traversal
Counting duplicates
Learning points: You'll learn how to efficiently handle duplicates in a sorted array using the two-pointer technique. This problem helps practice in-place array modifications and understand how to maintain specific constraints (in this case, allowing at most two occurrences of each element) while processing an array.
Check the introduction section to download the source code for the solution.
- Majority Element6:12
Brief problem overview: LeetCode problem 169 (Majority Element) asks you to find the element that appears more than n/2 times in an array of n elements. Your task is to return this majority element which is guaranteed to exist in the array.
Time and space complexity: The optimal solution achieves O(n) time complexity and O(1) space complexity using the Boyer-Moore Voting Algorithm.
Key concepts covered:
Boyer-Moore Voting Algorithm
Array traversal
Counting techniques
Divide and conquer (alternative approach)
Hash maps (alternative approach)
Learning points: By solving this problem, you'll learn how to identify elements with specific frequency characteristics in an array. You'll practice implementing the elegant Boyer-Moore Voting Algorithm which efficiently finds a majority element without using extra space. This problem also demonstrates how a clever algorithm can outperform more obvious solutions like sorting or using a hash map.
Check the introduction section to download the source code for the solution.
- Rotate Array5:44
Brief problem overview: In this lecture, we'll solve LeetCode's Rotate Array problem, which asks you to rotate an array to the right by k steps, where each element moves k positions.
Time and space complexity: The optimal solution has O(n) time complexity and O(1) space complexity.
Key concepts covered: Array manipulation, in-place algorithms, reverse array technique, modular arithmetic.
Learning points: You'll learn how to efficiently rotate arrays without using extra space, practice implementing the reverse array technique, understand how to handle edge cases like when k is larger than the array length, and see how clever mathematical insights can lead to elegant solutions for array manipulation problems.
Check the introduction section to download the source code for the solution.
- Best Time to Buy and Sell Stock7:59
Brief problem overview: In LeetCode problem 121 Best Time to Buy and Sell Stock, you need to maximize profit by determining the best single day to buy a stock and the best later day to sell it, given an array of stock prices.
Time and space complexity: The optimal solution has O(n) time complexity and O(1) space complexity, where n is the number of days/prices in the array.
Key concepts covered:
One-pass algorithm
Dynamic programming simplified
Greedy approach
Array traversal
Min/max tracking
Learning points:
How to implement a single-pass solution to optimize profit calculation
Techniques for tracking minimum values while iterating through arrays
Understanding when to use greedy algorithms for optimization problems
Efficiently solving problems without using extra space
Recognizing and avoiding unnecessary computations in array processing
Check the introduction section to download the source code for the solution.
- Best Time to Buy and Sell Stock II4:07
Brief problem overview: This problem asks you to maximize profit by buying and selling stocks multiple times over a given period. You are given an array where each element represents the stock price on a particular day, and you need to determine the maximum profit you can make.
Time and space complexity: The optimal solution has O(n) time complexity, where n is the number of days. The space complexity is O(1) as we only need a few variables to track the profit.
Key concepts covered:
Greedy algorithms
Array traversal
Profit maximization
Multiple transaction optimization
Learning points: By solving this problem, you'll learn how to implement a greedy approach to optimize profits in a stock trading scenario. You'll practice identifying profitable transactions by comparing adjacent days and understand how to accumulate profits incrementally rather than trying to find optimal buy-sell pairs.
Check the introduction section to download the source code for the solution.
- Jump Game7:11
Brief problem overview: In LeetCode problem 55, Jump Game, you are given an array of non-negative integers representing the maximum jump length at each position. You need to determine if you can reach the last index starting from the first position.
Time and space complexity: The optimal solution has O(n) time complexity where n is the length of the array, and O(1) space complexity as we only need to track the furthest reachable position.
Key concepts covered:
Greedy algorithms,
Array traversal,
Optimization
Learning points: In this lecture, you'll learn how to approach problems that can be solved using greedy strategies. You'll practice identifying when to use a greedy approach instead of more complex solutions like dynamic programming. You'll also learn how to track and update reachable positions efficiently while traversing through an array.
Check the introduction section to download the source code for the solution.
- Jump Game II8:14
Brief problem overview:
In this problem, you're given an array of integers representing the maximum number of steps you can jump forward from each position. The goal is to find the minimum number of jumps needed to reach the last index of the array.
Time and space complexity:
The optimal solution has O(n) time complexity and O(1) space complexity, where n is the length of the input array.
Key concepts covered:
Greedy algorithms
Array traversal
Dynamic programming concepts
Jump optimization
Learning points:
In this lecture, you'll learn how to approach this classic jumping problem using a greedy approach. You'll understand how to track the current reach and maximum reach to minimize jumps, avoiding the common pitfalls of recursive solutions that lead to time limit exceeded errors. This problem helps strengthen your ability to identify when greedy solutions are applicable and how to implement them efficiently.
Check the introduction section to download the source code for the solution.
- H-Index9:02
Brief problem overview: In this lecture, we'll solve LeetCode Problem 274 (H-Index), which asks us to calculate the h-index of a researcher based on their citation counts. The h-index measures both the productivity and impact of a researcher's publications.
Time and space complexity: The optimal solution has a time complexity of O(n log n) if we use sorting, or O(n) if we use counting sort. The space complexity is O(1) for the sorting approach or O(n) for the counting sort approach.
Key concepts covered:
Sorting
Counting Sort
Array Manipulation
Binary Search (alternative approach)
Understanding the H-Index concept
Learning points: You'll learn how to analyze a problem with a non-intuitive definition, transform it into an algorithmic solution, and optimize it. This problem helps practice array manipulation and understand when to use different sorting techniques based on the constraints of the input data.
Check the introduction section to download the source code for the solution.
- Insert Delete GetRandom O(1)5:05
Brief problem overview: In this lecture, we will implement a data structure RandomizedSet which supports inserting elements, removing elements, and getting a random element from the set, all in O(1) time complexity.
Time and space complexity: The optimal solution has O(1) time complexity for all operations (insert, remove, getRandom) and O(n) space complexity where n is the number of elements in the set.
Key concepts covered:
Hash Maps
Arrays
Constant-time operations
Random access
Learning points: You'll learn how to combine a hash map and an array to achieve O(1) operations for all required functionalities. This problem demonstrates a clever technique of swapping elements to maintain constant time deletion without disrupting the ability to get random elements efficiently. You'll also understand the trade-offs between different data structures and how to leverage their strengths in combination.
Check the introduction section to download the source code for the solution.
- Product of Array Except Self8:25
Brief problem overview:
In this problem, you need to calculate a new array where each element is the product of all numbers in the original array except the number at that index. The challenge is to do this without using division and in O(n) time.
Time and space complexity:
The optimal solution achieves O(n) time complexity and O(1) space complexity (excluding the output array).
Key concepts covered:
Prefix and suffix products
Array manipulation
In-place calculation techniques
Optimizing space complexity
Learning points:
In this lecture, you'll learn how to solve a seemingly complex problem with an elegant solution that avoids division. You'll practice using prefix/suffix product calculations, understand how to optimize both time and space complexity, and see how to approach problems that initially seem to require nested loops but can be solved linearly.
Check the introduction section to download the source code for the solution.
- Gas Station8:39
Brief problem overview:
In this problem, you need to find the starting gas station index that allows you to complete a circular route. You have arrays representing gas available at each station and the cost to travel to the next station, and must determine if a valid starting point exists.
Time and space complexity:
The optimal solution has O(n) time complexity as we traverse the array once, and O(1) space complexity as we use only a few variables regardless of input size.
Key concepts covered:
Greedy algorithms
Circular array traversal
Running sum calculations
Problem constraints analysis
Learning points:
In this lecture, you'll learn how to approach problems requiring circular traversal with limited resources. You'll practice implementing a greedy approach to find an efficient solution without brute force, and understand how to use mathematical properties of the problem to eliminate unnecessary calculations.
Check the introduction section to download the source code for the solution.
- Roman to Integer4:41
Roman to Integer: Convert Roman Numerals to Numbers
Brief problem overview:
In this lecture, we tackle LeetCode problem 13 which asks us to convert a Roman numeral string into an integer value. This requires understanding the rules of Roman numerals and handling special cases where smaller values precede larger ones.
Time and space complexity:
Time complexity: O(n) where n is the length of the input string
Space complexity: O(1) as we use a fixed-size hash map regardless of input size
Key concepts covered:
Hash maps / Dictionaries
String traversal
Roman numeral system rules
Special case handling
Learning points:
How to use a hash map to store symbol-value pairs
Implementing logic for Roman numeral subtraction rules (IV = 4, IX = 9, etc.)
Efficiently traversing a string while making decisions based on current and next characters
Converting a complex representation system into integers
Writing clean, readable code for a common interview problem
Check the introduction section to download the source code for the solution.
- Length of Last Word2:57
Length of Last Word - LeetCode Problem 58
Brief problem overview: This lecture covers how to find the length of the last word in a string. A word is a maximal substring consisting of non-space characters.
Time and space complexity:
The optimal solution has O(n) time complexity, where n is the length of the input string, and O(1) space complexity as we only use a few variables.
Key concepts covered:
String manipulation
String traversal
Handling edge cases with whitespace
Basic string parsing
Learning points:
By solving this problem, you'll practice working with strings, learn how to efficiently handle trailing spaces, and understand a simple but practical string parsing technique. This problem helps build fundamental string manipulation skills that are useful in many real-world applications.
Check the introduction section to download the source code for the solution.
- Longest Common Prefix7:17
Brief problem overview: In this lecture, we'll solve the Longest Common Prefix problem, which asks us to find the longest common prefix string amongst an array of strings.
Time and space complexity: The optimal solution runs in O(S) time where S is the sum of all characters in all strings. The space complexity is O(1) as we only need a constant amount of extra space.
Key concepts covered:
String manipulation, character comparison, horizontal scanning approach, divide and conquer optional approach
Learning points:
You'll learn how to efficiently compare multiple strings character by character, handle edge cases like empty arrays or strings, and implement a clean solution for prefix matching. This problem helps practice string iteration techniques and builds foundational skills for more complex string algorithms.
Check the introduction section to download the source code for the solution.
- Reverse Words in a String3:23
Brief problem overview:
This problem requires you to reverse the order of words in a given string while preserving the words themselves. Extra spaces between words should be reduced to a single space, and leading/trailing spaces should be removed.
Time and space complexity:
The optimal solution has O(n) time complexity where n is the length of the input string, and O(n) space complexity to store the reversed words.
Key concepts covered:
String manipulation
Two-pointer technique
In-place operations (for certain approaches)
Split and join operations
Learning points:
In this lecture, you'll learn how to efficiently process strings by splitting them into words, removing extra spaces, and reconstructing them in reverse order. You'll practice string traversal techniques and understand how to optimize memory usage when handling string operations. This problem highlights the importance of carefully managing string transformations while preserving specific formatting requirements.
Check the introduction section to download the source code for the solution.
- Zigzag Conversion10:33
Brief problem overview: In this lecture, we tackle LeetCode Problem 6, Zigzag Conversion, which asks us to convert a string into a zigzag pattern across multiple rows and then read it line by line to create a new string output.
Time and space complexity: The optimal solution has a time complexity of O(n) where n is the length of the input string, and a space complexity of O(n) to store the converted string.
Key concepts covered:
String manipulation
pattern recognition
array manipulation
mathematical relationships
simulation.
Learning points: By solving this problem, you'll strengthen your understanding of string processing techniques, improve your ability to identify and implement mathematical patterns, and learn how to efficiently simulate a visual process in code. You'll also practice optimizing your solution by identifying the direct mapping between input and output positions.
Check the introduction section to download the source code for the solution.
- Find the Index of the First Occurrence in a String5:50
LeetCode Problem 28: Find the Index of the First Occurrence in a String ?
Problem Overview ?
This problem asks you to find the first occurrence of a needle string within a haystack string, returning the index of the first character if found, or -1 if not present.
Complexity Analysis ⏱️
Time Complexity: O(n×m) where n is the length of the haystack and m is the length of the needle
Space Complexity: O(1) as we only use a constant amount of extra space
Key Concepts ?
String manipulation
Substring search algorithms
Two-pointer technique
Pattern matching
Learning Points ?
How to efficiently compare strings and substrings
Implementing simple string search algorithms
Edge case handling (empty strings, needle longer than haystack)
Understanding when to use built-in functions vs custom implementations
What You'll Learn ?
In this lecture, you'll learn how to implement a solution to the string matching problem using both the brute force approach and optimize it with proper string comparison techniques. This pattern appears frequently in technical interviews and real-world applications!
- Valid Palindrome6:49
Brief problem overview: This lecture covers Leetcode Problem 125, "Valid Palindrome", which asks you to determine if a string is a palindrome after removing all non-alphanumeric characters and converting all uppercase letters to lowercase.
Time and space complexity: The optimal solution has O(n) time complexity, where n is the length of the input string, and O(1) space complexity as we use a two-pointer approach without additional data structures.
Key concepts covered: Two-pointer technique, String manipulation, Character validation, In-place algorithms
Learning points: In this lecture, you'll learn how to efficiently check if a string is a palindrome without creating additional strings. You'll practice implementing the two-pointer technique, handling character validation, and performing case-insensitive comparisons. This is a fundamental string manipulation problem that demonstrates how to solve problems without using extra space.
Check the introduction section to download the source code for the solution.
- Is Subsequence5:04
Brief problem overview: In this lecture, we tackle LeetCode problem 392, Is Subsequence, which asks us to determine if one string is a subsequence of another string - meaning if the characters of the first string appear in order within the second string.
Time and space complexity: The optimal solution has a time complexity of O(n), where n is the length of the target string, and a space complexity of O(1) as we only use a few pointers.
Key concepts covered: Two-pointer technique, String manipulation, Subsequence verification, Iteration
Learning points: Through this problem, you'll learn how to efficiently check if one string is a subsequence of another without using extra space. You'll practice implementing the two-pointer technique to traverse strings at different rates, and understand how to optimize string comparison operations - a commonly tested pattern in interviews.
Check the introduction section to download the source code for the solution.
- Two Sum II - Input Array Is Sorted7:10
Brief problem overview:
In this lecture, we'll tackle the Two Sum II problem, which asks you to find two numbers in a sorted array that add up to a specific target, returning their indices (1-indexed).
Time and space complexity:
The optimal solution has O(n) time complexity and O(1) space complexity.
Key concepts covered:
Two-pointer technique
Sorted array properties
Binary search (alternative approach)
Input array traversal
Learning points:
How to leverage the sorted nature of an array to optimize solutions
Applying the two-pointer technique to avoid using extra space
Understanding when to use binary search vs. two pointers
Practicing efficient array manipulation in a common interview problem
Converting between 0-indexed and 1-indexed representations
Check the introduction section to download the source code for the solution.
- Container With Most Water8:48
Brief problem overview:
In this lecture, we explore LeetCode problem 11: Container With Most Water, which asks us to find the container that can hold the maximum amount of water given an array of heights representing vertical lines.
Time and space complexity:
The optimal solution has O(n) time complexity and O(1) space complexity, where n is the number of elements in the height array.
Key concepts covered:
Two-pointer technique
Greedy algorithms
Array manipulation
Area calculation
Learning points:
By solving this problem, you'll learn how to apply the two-pointer technique to efficiently find an optimal solution without brute force. You'll practice reasoning about maximizing area based on width and height constraints, and understand why we can safely eliminate certain combinations. This problem demonstrates how to reduce time complexity from O(n²) to O(n) through clever pointer movement.
Check the introduction section to download the source code for the solution.
- 3Sum8:19
Brief problem overview: 3Sum is a classic array problem where you need to find all unique triplets within an array that add up to zero. It builds on two-sum concepts but requires handling duplicates.
Time and space complexity: The optimal solution has O(n²) time complexity, where n is the length of the input array. The space complexity is O(1) excluding the output array.
Key concepts covered:
Two-pointer technique
sorting, duplicate handling
array manipulation
search optimization.
Learning points: In this lecture, you'll learn how to efficiently search for triplets in an array, manage duplicate elements, use sorting to simplify complex search problems, and apply the two-pointer technique to avoid nested loops. These skills are frequently tested in technical interviews and apply to many similar array problems.
Check the introduction section to download the source code for the solution.
- Minimum Size Subarray Sum9:32
Brief problem overview: LeetCode problem 209, Minimum Size Subarray Sum, asks you to find the minimum length of a contiguous subarray whose sum is greater than or equal to a target value. If no such subarray exists, return 0.
Time and space complexity: The optimal solution has O(n) time complexity where n is the length of the array, and O(1) space complexity as we only need a few variables to track our sliding window.
Key concepts covered:
Sliding Window Technique
Two Pointer Approach
Array Traversal
Prefix Sums Concept
Learning points: In this lecture, you'll learn how to efficiently implement the sliding window technique to solve subarray problems. You'll practice optimizing brute force approaches, maintaining and updating window boundaries, and handling edge cases. This problem builds critical skills for technical interviews and provides a foundation for tackling more complex sliding window problems.
Check the introduction section to download the source code for the solution.
- Longest Substring Without Repeating Characters8:22
Brief problem overview: LeetCode problem 3 Longest Substring Without Repeating Characters asks you to find the length of the longest substring in a given string that contains no repeating characters.
Time and space complexity: The optimal solution has O(n) time complexity where n is the length of the string, and O(min(m,n)) space complexity where m is the size of the character set.
Key concepts covered:
Sliding window technique
hash map or set for character tracking
string manipulation
two-pointer approach.
Learning points: Through this problem, you'll learn how to efficiently track character occurrences, implement the sliding window pattern for substring problems, optimize space usage by reusing data structures, and handle edge cases like empty strings or single-character inputs.
Check the introduction section to download the source code for the solution.
- Valid Sudoku6:46
Brief problem overview:
In this lecture, we'll tackle the Valid Sudoku problem, which asks us to determine if a partially filled 9x9 Sudoku board is valid according to the game's rules. We need to check if any row, column, or 3x3 sub-box contains duplicate numbers from 1-9.
Time and space complexity:
The optimal solution has O(1) time complexity since the board size is fixed at 9x9. The space complexity is also O(1) as we use a fixed amount of extra space regardless of input size.
Key concepts covered:
Hash sets for efficient duplicate detection
Matrix traversal techniques
Array indexing and manipulation
Validation algorithms
Learning points:
In this problem, you'll learn how to efficiently check for duplicates in multiple dimensions, practice working with 2D arrays, and understand how to convert real-world constraints into programming logic. You'll also develop skills in breaking down complex validation tasks into manageable steps, which is valuable for many interview scenarios.
Check the introduction section to download the source code for the solution.
- Spiral Matrix9:07
Brief problem overview: In this lecture, we tackle LeetCode's Spiral Matrix problem, which asks us to return all elements of an m x n matrix in spiral order, moving from outside to inside in a clockwise direction.
Time and space complexity: The optimal solution has O(m*n) time complexity where m and n are the dimensions of the matrix, as we need to visit each element once. The space complexity is O(1) excluding the output array.
Key concepts covered:
Matrix traversal
Simulation
Boundary tracking
Direction changes
Array manipulation
Learning points: By solving this problem, you'll practice how to navigate a 2D array in specific patterns, handle boundary conditions effectively, implement directional changes, and maintain state while traversing a data structure. This problem builds strong fundamentals for more complex matrix operations and simulation problems.
Check the introduction section to download the source code for the solution.
- Rotate Image7:10
Brief problem overview: LeetCode problem 48 asks you to rotate a given n×n matrix by 90 degrees clockwise. You must modify the matrix in-place without using an additional matrix for the rotation.
Time and space complexity: The optimal solution achieves O(n²) time complexity, where n is the dimension of the matrix. The space complexity is O(1) since we perform the rotation in-place without extra memory allocation.
Key concepts covered:
Matrix manipulation
in-place operations
layer-by-layer rotation
transposing and reversing operations.
Learning points: By solving this problem, you'll learn techniques for manipulating 2D arrays in-place, strengthen your understanding of matrix operations, and practice visualizing geometric transformations. You'll also develop skills in optimizing space usage by avoiding additional data structures.
Check the introduction section to download the source code for the solution.
- Set Matrix Zeroes10:18
Brief problem overview: In this lecture, we'll tackle LeetCode Problem 73, where we need to modify a matrix in-place such that if an element is zero, its entire row and column are set to zero. The challenge is implementing this efficiently without using extra space.
Time and space complexity: The optimal solution has a time complexity of O(m×n) where m is the number of rows and n is the number of columns, and a space complexity of O(1) as we'll use the first row and first column as markers instead of additional data structures.
Key concepts covered:
In-place matrix manipulation
constant space optimization
using the input matrix itself for tracking state
two-pass algorithms.
Learning points: By solving this problem, you'll strengthen your ability to manipulate 2D arrays efficiently, develop insight into optimizing space complexity through clever use of existing resources, and practice implementing a multi-stage algorithm that preserves original information while transforming a data structure.
Check the introduction section to download the source code for the solution.
- Game of Life7:05
Brief problem overview: In LeetCode problem 289 (Game of Life), you're given a board representing cells in Conway's Game of Life and need to update the board to its next state. The challenge is to implement this transformation in-place without using extra space.
Time and space complexity: The optimal solution has O(m*n) time complexity where m and n are the dimensions of the board. The space complexity is O(1) since we modify the board in-place.
Key concepts covered: In-place matrix manipulation, bit manipulation, cellular automata, state encoding, neighbor counting algorithms.
Learning points: By solving this problem, you'll practice implementing complex state transitions without using additional space, learn techniques for encoding multiple states in a single value, and improve your ability to work with 2D arrays and handle edge cases. This problem sharpens your ability to think about state transitions and conditional logic in matrix problems.
Check the introduction section to download the source code for the solution.
- Ransom Note5:20
Brief problem overview: In this lecture, we explore LeetCode problem 383 Ransom Note, which involves determining whether you can construct a ransom note using letters from a magazine.
Time and space complexity: The optimal solution has O(n) time complexity and O(1) space complexity, where n is the total number of characters in both strings.
Key concepts covered: Hash maps/dictionaries, character frequency counting, string manipulation.
Learning points: You'll learn how to efficiently count and compare character frequencies between strings, implement a practical application of hash maps, and understand when a constant space solution is possible. This problem is excellent practice for interview questions involving string manipulation and character counting.
Check the introduction section to download the source code for the solution.
- Isomorphic Strings7:16
Isomorphic Strings Problem Explanation
Brief problem overview: This lecture explains how to determine if two strings are isomorphic, meaning each character in one string can be mapped to another character while preserving the order of characters.
Time and space complexity: The optimal solution has O(n) time complexity where n is the length of the strings, and O(k) space complexity where k is the size of the character set (constant in practice).
Key concepts covered: Hash maps, character mapping, bidirectional mapping, string comparison
Learning points: You'll learn how to track character mappings between strings using hash maps, understand the importance of one-to-one mapping in string problems, and practice implementing efficient character comparison algorithms. This problem teaches a fundamental concept that appears in many string-related interview questions.
Check the introduction section to download the source code for the solution.
- Word Pattern6:34
Brief problem overview:
In this lecture, we'll solve LeetCode problem 290 (Word Pattern), which requires determining if a pattern and a string follow the same structure, where each character in the pattern corresponds to a specific word in the string.
Time and space complexity:
The optimal solution has O(n) time complexity, where n is the length of the input string, and O(k) space complexity, where k is the number of unique words and pattern characters.
Key concepts covered:
Hash maps
Bijective mapping
String parsing and comparison
Pattern matching algorithms
Learning points:
How to identify and maintain a one-to-one mapping between elements
Techniques for splitting strings efficiently
Building and checking relationships between different data sets
Edge case handling for patterns and strings of different lengths
Practical application of hash maps to track relationships between elements
Check the introduction section to download the source code for the solution.
- Valid Anagram4:49
Valid Anagram: Understanding String Manipulation Using Hash Tables
Brief problem overview: In this lecture, we'll solve LeetCode problem 242 - Valid Anagram, which asks us to determine if one string is an anagram of another (i.e., if they contain the same characters with the same frequencies).
Time and space complexity: The optimal solution has O(n) time complexity where n is the length of the strings, and O(1) space complexity since we only need to store counts for a limited character set (26 lowercase English letters).
Key concepts covered: Hash tables, character frequency counting, string manipulation, and comparison algorithms.
Learning points: By solving this problem, you'll practice implementing a character frequency counter using arrays or hash maps, learn how to efficiently compare character distributions between strings, and understand when and how to optimize for specific character sets versus generic solutions. This problem demonstrates a common technique used in many string comparison and analysis problems.
Check the introduction section to download the source code for the solution.
- Group Anagrams7:12
Brief problem overview: In this lecture, we'll tackle LeetCode's Group Anagrams problem, where you need to group strings that are anagrams of each other into separate clusters from an array of strings.
Time and space complexity: The optimal solution has a time complexity of O(n*k), where n is the number of strings and k is the maximum length of any string. The space complexity is O(n*k) to store the grouped anagrams.
Key concepts covered:
Hash tables
string manipulation
sorting
character counting
anagram detection
Learning points: You'll learn how to efficiently identify anagrams using character frequency maps as hash keys, implement a solution that avoids sorting for better performance, and practice working with hash tables to group related elements. This problem demonstrates how choosing appropriate data structures can lead to elegant and efficient algorithms.
Check the introduction section to download the source code for the solution.
- Two Sum5:51
Two Sum: Solving Your First LeetCode Problem
Brief problem overview: The Two Sum problem asks you to find two numbers in an array that add up to a specific target value and return their indices. It's the perfect introduction to algorithmic problem solving.
Time and space complexity: The optimal solution has O(n) time complexity and O(n) space complexity, where n is the length of the input array.
Key concepts covered:
Hash tables (dictionaries)
Array iteration
Complement pattern
Problem-solving approach
Learning points:
How to convert a brute force approach into an efficient solution
Practical application of hash tables for lookups
Techniques for reducing time complexity
Understanding trade-offs between time and space complexity
Learning to think about edge cases
Check the introduction section to download the source code for the solution.
- Happy Number5:25
Brief problem overview: In this problem, we need to determine if a number is "happy" by repeatedly replacing it with the sum of the squares of its digits until it equals 1 or enters a cycle.
Time and space complexity: The optimal solution has O(log n) time complexity and O(log n) space complexity, where n is the input number.
Key concepts covered:
Hash sets for cycle detection
Number manipulation
Floyd's Cycle-Finding Algorithm (Tortoise and Hare)
Learning points:
How to detect cycles in a sequence of operations
Techniques for breaking down numbers into their digits
Implementation of Floyd's Cycle-Finding Algorithm
Trade-offs between hash set and two-pointer approaches
Practical application of mathematical properties
Check the introduction section to download the source code for the solution.
- Contains Duplicate II6:34
Solving LeetCode 219: Contains Duplicate II
Brief problem overview: This problem asks you to determine if an array contains duplicates that are at most k positions apart. You need to check if there are any two distinct indices i and j such that nums[i] == nums[j] and abs(i - j) <= k.
Time and space complexity: The optimal solution has O(n) time complexity and O(min(n,k)) space complexity, where n is the length of the array.
Key concepts covered:
Hash Tables
Sliding Window
Array Manipulation
Learning points: In this lecture, you'll learn how to efficiently track elements using a hash map to store the most recent index of each value. You'll practice implementing a sliding window approach to maintain only the relevant elements within the k-distance constraint. This problem helps strengthen your understanding of hash tables and how they can be used to solve duplicates problems with additional constraints.
Check the introduction section to download the source code for the solution.
- Longest Consecutive Sequence6:18
Brief problem overview: In this problem, we need to find the length of the longest consecutive elements sequence in an unsorted array. The algorithm needs to run in O(n) time complexity.
Time and space complexity: The optimal solution has O(n) time complexity and O(n) space complexity.
Key concepts covered:
Hash Sets
Array manipulation
Sequence detection
Linear time algorithms
Optimizing lookups
Learning points: You'll learn how to transform an apparently sequential problem into a set-based solution. This lecture demonstrates how to use a HashSet for O(1) lookups, identify sequence starting points, and calculate sequence lengths efficiently. The technique showcased here will help you approach similar array-based problems requiring optimal time complexity.
Check the introduction section to download the source code for the solution.
- Summary Ranges5:05
Solving LeetCode Problem 228: Summary Ranges
Brief problem overview: This problem asks you to convert a sorted list of unique integers into a compact representation of ranges. For example, [0,1,2,4,5,7] becomes ["0->2","4->5","7"].
Time and space complexity: The optimal solution has O(n) time complexity where n is the length of the input array. Space complexity is O(1) excluding the output space.
Key concepts covered:
Array traversal
Two-pointer technique
String manipulation
Range detection in sorted arrays
Learning points:
How to identify consecutive elements in sorted arrays
Efficiently handling edge cases for single-element ranges
Formatting output according to specific requirements
Implementing a linear-time solution without additional data structures
Practicing clean code that handles all edge cases
Check the introduction section to download the source code for the solution.
- Merge Intervals3:58
Brief problem overview: In this lecture, we tackle LeetCode's Merge Intervals problem, which asks you to merge overlapping intervals in a collection, resulting in a set of non-overlapping intervals that cover all the original intervals.
Time and space complexity: The optimal solution has a time complexity of O(n log n) due to sorting, and a space complexity of O(n) to store the merged intervals.
Key concepts covered:
Array manipulation
sorting
interval merging
greedy algorithms
Learning points: By solving this problem, you'll strengthen your understanding of sorting techniques, learn how to efficiently identify and merge overlapping ranges, practice implementing greedy approaches for optimization problems, and develop your ability to handle edge cases in interval-based problems.
Check the introduction section to download the source code for the solution.
- Insert Interval5:12
Brief problem overview:
This problem asks you to insert a new interval into a sorted non-overlapping intervals list, merging overlapping intervals as needed. It tests your ability to handle interval operations efficiently.
Time and space complexity:
Time Complexity: O(n) where n is the number of intervals
Space Complexity: O(n) for storing the result
Key concepts covered:
Array manipulation
Interval merging
Greedy algorithms
Linear traversal
Edge case handling
Learning points:
How to efficiently insert intervals without sorting the entire array
Techniques for merging overlapping intervals
Handling special cases like completely non-overlapping intervals
Implementing a single-pass solution for better efficiency
Applying logical conditions to determine when to insert vs. merge intervals
Check the introduction section to download the source code for the solution.
- Minimum Number Of Arrows To Burst Balloons6:20
Brief problem overview:
In this problem, we need to find the minimum number of arrows required to burst all balloons. Each balloon is represented as a segment on the x-axis, and an arrow can burst all balloons it passes through.
Time and space complexity:
Time Complexity: O(n log n) due to sorting
Space Complexity: O(1) or O(n) depending on the sorting implementation
Key concepts covered:
Greedy algorithm
Interval scheduling
Sorting
Overlapping intervals
Learning points:
How to identify and apply greedy strategies to interval problems
Efficient handling of overlapping ranges
Importance of sorting data before processing
Solving problems by tracking interval endpoints rather than full intervals
Optimizing arrow placement to maximize balloon bursts
Check the introduction section to download the source code for the solution.
- Valid Parentheses7:44
Introduction to Valid Parentheses
Brief problem overview: This problem asks you to determine whether a string containing only parentheses characters is valid, meaning that all opening brackets must be closed by the same type of closing bracket in the correct order.
Time and space complexity: The optimal solution has O(n) time complexity and O(n) space complexity, where n is the length of the input string.
Key concepts covered:
Stack data structure
String manipulation
Bracket matching algorithms
Hash maps for character mapping
Learning points:
How to use a stack to solve parentheses validation problems
Implementing a solution for matching different types of brackets
Pattern recognition for bracket pairing problems
Efficiently handling edge cases for string validation
Practicing a common interview question pattern
Check the introduction section to download the source code for the solution.
- Linked List Cycle5:39
Brief problem overview:
In this lecture, we tackle the Linked List Cycle problem which asks us to determine if a linked list contains a cycle a node that points back to a previous node in the list.
Time and space complexity:
The optimal solution has O(n) time complexity and O(1) space complexity.
Key concepts covered:
Floyds Tortoise and Hare slow and fast pointers
Linked list traversal
Cycle detection algorithms
Learning points:
How to detect cycles in linked lists without using additional data structures
Implementation of the two pointer technique slow/fast pointers
Understanding why the fast and slow pointers will eventually meet if a cycle exists
Efficient memory usage for cycle detection problems
Check the introduction section to download the source code for the solution.
- Add Two Numbers4:31
Brief problem overview:
In this problem, you'll learn how to add two numbers represented as linked lists, where each node stores a single digit and the digits are stored in reverse order.
Time and space complexity:
Time Complexity: O(max(m, n)) where m and n are the lengths of the two linked lists
Space Complexity: O(max(m, n)) for the output linked list
Key concepts covered:
Linked List traversal
Elementary math operations
Carry handling in addition
Dummy head technique for linked lists
Learning points:
How to manipulate linked list nodes efficiently
Managing carrying digits in arithmetic operations
Edge case handling with different length lists
Creating a new linked list while traversing existing ones
Practicing pointer manipulation in a concrete, real-world scenario
Check the introduction section to download the source code for the solution.
- Merge Two Sorted Lists5:57
Brief problem overview: In this lecture, we'll learn how to merge two sorted linked lists into a single sorted linked list. This is a fundamental linked list manipulation problem that tests your understanding of pointers and list traversal.
Time and space complexity: The optimal solution has a time complexity of O(n+m), where n and m are the lengths of the two input lists, and a space complexity of O(1) as we only use a few pointers.
Key concepts covered:
Linked lists
two-pointer technique
in-place list manipulation
dummy head pattern
Learning points: By solving this problem, you'll learn how to traverse two linked lists simultaneously, manipulate list pointers efficiently, handle edge cases like empty lists, and implement the dummy head technique to simplify linked list operations. This problem reinforces understanding of iterative algorithms and serves as a building block for more complex linked list problems.
Check the introduction section to download the source code for the solution.
- Maximum Depth of Binary Tree5:01
Mastering Binary Tree Maximum Depth: LeetCode #104
Brief problem overview: This problem requires you to find the maximum depth of a binary tree, which is the number of nodes along the longest path from the root node down to the farthest leaf node.
Time and space complexity: The optimal solution has O(n) time complexity, where n is the number of nodes in the tree. The space complexity is O(h) where h is the height of the tree, due to the recursive call stack.
Key concepts covered:
Binary Trees
Depth-First Search (DFS)
Recursion
Tree Traversal
Learning points: By solving this problem, you'll learn how to traverse a binary tree recursively, understand the concept of tree depth calculation, practice implementing a clean recursive solution, and recognize a classic tree problem pattern that appears in many interview questions.
Check the introduction section to download the source code for the solution.
- Same Tree5:18
Same Tree: Binary Tree Traversal
Brief problem overview:
In this lecture, we'll tackle LeetCode problem 100, which asks you to determine if two binary trees are identical. Two trees are considered the same if they have identical structure and the same node values.
Time and space complexity:
Time Complexity: O(n), where n is the number of nodes in the tree, as we need to visit each node once.
Space Complexity: O(h), where h is the height of the tree due to the recursion stack. In the worst case, this becomes O(n) for a skewed tree.
Key concepts covered:
Binary Tree Traversal
Depth-First Search
Recursive Tree Comparison
Tree Structure Validation
Learning points:
How to traverse two trees simultaneously
Implementing recursive tree comparison algorithms
Writing elegant and concise tree validation code
Understanding base cases for tree recursion problems
Recognizing when two tree structures match or differ
Check the introduction section to download the source code for the solution.
- Invert Binary Tree3:13
Brief problem overview: In this lecture, we'll solve LeetCode problem 226, which requires us to invert a binary tree by swapping left and right children of all nodes.
Time and space complexity: The optimal solution has O(n) time complexity, where n is the number of nodes in the tree. The space complexity is O(h), where h is the height of the tree, due to the recursion stack.
Key concepts covered:
Binary Trees
Tree Traversal
Recursion
Depth-First Search
Learning points: By solving this problem, you'll learn how to traverse and manipulate binary tree structures, implement a clean recursive solution, understand the concept of inverting/mirroring a tree, and practice a fundamental tree operation that appears frequently in interviews. You'll also see how a seemingly complex transformation can be achieved with surprisingly minimal code.
Check the introduction section to download the source code for the solution.
- Symmetric Tree4:03
Brief problem overview: In this lecture, we'll tackle LeetCode problem 101 which asks us to determine if a binary tree is symmetric (mirror image of itself).
Time and space complexity: The optimal solution has O(n) time complexity where n is the number of nodes in the tree. The space complexity is O(h) where h is the height of the tree due to the recursive call stack.
Key concepts covered: Binary Trees, Depth-First Search, Recursion, Tree Traversal, Symmetry Property
Learning points: You'll learn how to traverse a binary tree recursively while comparing corresponding nodes for symmetry. This problem reinforces the concept of tree traversal and helps you develop intuition for recognizing symmetrical structures in trees. You'll also practice implementing a clean recursive solution that checks mirror conditions.
Check the introduction section to download the source code for the solution.
- Path Sum5:51
Path Sum: Finding a Valid Root-to-leaf Path
Brief problem overview: In Problem 112 "Path Sum", you're given a binary tree and a target sum, and need to determine if there's a path from root to leaf where node values sum to the target.
Time and space complexity: The optimal solution has O(N) time complexity where N is the number of nodes in the tree. Space complexity is O(H) where H is the height of the tree, due to the recursive call stack.
Key concepts covered:
Binary tree traversal
Depth-first search (DFS)
Recursive problem solving
Path tracking in trees
Learning points:
How to efficiently traverse a binary tree
Techniques for tracking values along a path
Implementing a recursive solution for tree problems
Distinguishing between leaf nodes and internal nodes
Applying the concept of "subproblem" in recursive solutions
Check the introduction section to download the source code for the solution.
- Sum Root To Leaf Numbers4:00
Brief problem overview: This problem asks you to calculate the total sum of all root-to-leaf numbers in a binary tree. Each path from root to leaf represents a number, and we need to find the sum of all such numbers.
Time and space complexity: The optimal solution has a time complexity of O(n), where n is the number of nodes in the tree, as we need to visit each node once. The space complexity is O(h), where h is the height of the tree, due to the recursive call stack.
Key concepts covered:
Binary Tree Traversal
Depth-First Search (DFS)
Tree Path Calculation
Recursive Problem Solving.
Learning points: In this lecture, you'll learn how to build numbers while traversing a binary tree, how to identify leaf nodes, and when to accumulate values into the final sum. You'll also practice a common tree traversal technique that's applicable to many other problems involving path calculations in trees.
Check the introduction section to download the source code for the solution.
- Count Complete Tree Nodes2:21
Count Complete Tree Nodes - A Deep Dive
Brief problem overview: This lecture explores LeetCode problem 222, which asks you to count the total number of nodes in a complete binary tree. This problem challenges you to leverage the special properties of complete binary trees for an efficient solution.
Time and space complexity: The optimal solution achieves O(log²n) time complexity, which is better than the O(n) naive approach. The space complexity is O(logn) due to the recursive call stack.
Key concepts covered: Complete binary trees, binary search, tree height calculation, bit manipulation, recursive tree traversal.
Learning points: By solving this problem, you'll learn how to exploit the special structure of complete binary trees to avoid visiting every node. You'll practice implementing an efficient algorithm that uses binary search principles to determine the number of nodes in the last level. This problem helps strengthen your understanding of tree properties and recursive algorithms with early termination conditions.
Check the introduction section to download the source code for the solution.
- Binary Tree Right Side View4:28
Brief problem overview:
This lecture tackles LeetCodes Binary Tree Right Side View problem, where we need to identify which nodes would be visible when viewing a binary tree from the right side, essentially finding the rightmost node at each level of the tree.
Time and space complexity:
Time Complexity: O(n) where n is the number of nodes in the binary tree
Space Complexity: O(h) where h is the height of the tree (in the worst case, this could be O(n))
Key concepts covered:
Binary Tree Traversal
Breadth-First Search (BFS)
Level Order Traversal
Queue Data Structure
Learning points:
How to implement level order traversal in a binary tree
Techniques for identifying and extracting information about tree levels
Efficient use of queues for tree traversal
How to solve problems related to tree visibility and perspectives
Understanding the relationship between tree height and node visibility
Check the introduction section to download the source code for the solution.
- Average of Levels in Binary Tree5:11
Brief problem overview: Average of Levels in Binary Tree (LeetCode 637) asks you to calculate the average value of all nodes on each level of a binary tree and return them as an array.
Time and space complexity: The optimal solution has O(n) time complexity where n is the number of nodes in the tree, and O(m) space complexity where m is the maximum number of nodes at any level in the binary tree.
Key concepts covered: Binary Tree Traversal, Breadth-First Search (BFS), Queue Data Structure, Level Order Traversal
Learning points: In this lecture, you'll learn how to implement level order traversal using BFS to process a binary tree level by level. You'll practice working with queues to track nodes at each level, calculate averages of node values, and handle potential integer overflow by using appropriate data types. This problem reinforces fundamental tree traversal patterns that appear frequently in interviews.
Check the introduction section to download the source code for the solution.
- Binary Tree Zigzag Level Order Traversal5:46
Binary Tree Zigzag Level Order Traversal
Brief problem overview: This lecture covers LeetCode problem 103, where you need to return the zigzag level order traversal of a binary tree's nodes (alternating between left-to-right and right-to-left for each level).
Time and space complexity: The optimal solution has O(n) time complexity where n is the number of nodes in the tree. The space complexity is also O(n) to store the nodes in the result and in the queue for traversal.
Key concepts covered:
Binary Tree traversal
Breadth-First Search (BFS)
Queue data structure
Level order processing
Direction reversal logic
Learning points:
How to implement level order traversal using BFS
Techniques to track and alternate traversal direction
Working with queues for tree traversal
Handling level-by-level node collection
Efficient node processing in binary trees
Check the introduction section to download the source code for the solution.
Requirements
- Basic programming knowledge in any language (e.g., Python, Java, C++)
- Familiarity with fundamental data structures (arrays, strings, linked lists)
- Understanding of basic algorithms and time complexity (Big O notation)
- Comfort with problem-solving and logical thinking
- Basic understanding of object-oriented programming concepts
- Familiarity with at least one integrated development environment (IDE) or code editor
- Access to a computer with internet connection to practice on LeetCode’s platform
- Willingness to dedicate time for consistent practice and problem-solving
- Basic math skills, including algebra and discrete mathematics
- Familiarity with version control systems like Git (helpful but not required)
- Understanding of basic database concepts and SQL (for certain types of problems)
- Patience and perseverance when facing challenging problems
- Ability to read and understand technical documentation and problem statements
- Basic knowledge of computer architecture and memory management (helpful for optimizing solutions)
Description
Master LeetCode: Conquer the Top 150 Problems
Struggling with coding interviews? This comprehensive course will transform you from a coding novice to a LeetCode master by methodically tackling all 150 of LeetCode’s most important problems.
What You’ll Learn
In this course, you’ll develop a systematic approach to solving any coding challenge. Rather than memorizing solutions, you’ll learn a step-by-step formula that works for every problem:
• Simplify complex problems into manageable components
• Recognize common patterns across different problem types
• Create effective implementation plans before coding
• Write clean, efficient code that interviewers love
• Debug systematically when things don’t work as expected
Course Structure
Each section follows a consistent format designed for maximum learning retention:
• Problem Breakdown: Clear explanation of what the problem is asking
• Pattern Recognition: Identifying which data structures and algorithms apply
• Solution Development: Building the approach step-by-step
• Implementation: Writing clean, optimized code
• Time & Space Analysis: Understanding the efficiency of our solution
• Common Pitfalls: Avoiding mistakes that trip up most candidates
Who This Course Is For
This course is perfect for:
• Software engineers preparing for technical interviews
• Computer science students looking to strengthen their problem-solving skills
• Self-taught programmers wanting to fill knowledge gaps
• Anyone who has struggled with LeetCode’s challenging problems
Prerequisites
To get the most from this course, you should have:
• Basic programming knowledge in any language
• Familiarity with fundamental data structures (arrays, strings, linked lists)
• Understanding of Big O notation (helpful but not required)
Your Instructor
As an experienced software engineer who has conducted hundreds of technical interviews, I’ve distilled the exact methods used by top performers. I focus on teaching you not just how to solve these specific 150 problems, but how to approach any coding challenge with confidence.
Don’t waste time randomly solving problems without a strategy. Join this course to develop a structured approach that will serve you throughout your entire programming career.
Who this course is for:
- Software engineers preparing for technical interviews
- CS students strengthening algorithm skills
- Self-taught programmers filling knowledge gaps
- Bootcamp graduates deepening technical expertise
- Job seekers targeting tech companies
- Developers wanting to master data structures and algorithms
- Professionals advancing careers through better technical skills
- Anyone struggling with LeetCode problems who has basic programming knowledge