Leetcode

A collection of 62 posts

Advice I’d Give to Anyone Starting Their LeetCode Journey (Including My Future Self)

I’ve learned that interview preparation isn’t about solving thousands of random problems. It’s about building the right habits, recognizing patterns, and learning how to think under pressure.

Understanding Big O Notation for LeetCode: The Complexity Cheat Sheet Every Beginner Needs

Big O notation measures the time complexity (or sometimes space complexity) of an algorithm. It doesn’t tell you exactly how many milliseconds your code takes—it tells you how the runtime grows as the input size (n) increases.

Think in Patterns, Not Solutions: A LeetCode Playbook

Goal: Don’t memorize solutions. Memorize patterns. Most LeetCode questions are variations of these.

703. Kth Largest Element in a Stream - Explanation

Since the smallest value among those k values is the answer, we can return the top of the min heap in constant time. This makes the min heap approach the preferred solution for this problem.

105. Construct Binary Tree From Preorder and Inorder Traversal

Preorder always tells you the next root. Inorder tells you where to split into left and right subtrees. Using left and right boundaries avoids creating new arrays and reduces the complexity from O(n²) to O(n).

230. Kth Smallest Element in a BST

A BST's inorder traversal visits nodes in ascending order. The kth node visited during inorder traversal is the kth smallest element. The recursive solution is concise and easy to understand. The iterative solution uses a stack to simulate recursion and is the standard interview approach.

LeetCode 98: Validate Binary Search Tree (Python)

Comparing a node with only its parent is not sufficient. Every node must satisfy constraints inherited from all its ancestors. Passing a valid (lower, upper) range during DFS elegantly enforces the BST rules. This is the standard interview solution and is both simple and optimal.

1448. Count Good Nodes in Binary Tree (LeetCode)

This is an excellent example of a DFS problem where the trick is not the traversal itself, but what information you carry along the path. By passing the maximum value seen so far, each node can determine independently whether it is "good," resulting in a simple and efficient O(n) solution.

199. Binary Tree Right Side View (LeetCode) – BFS Explained

Whenever a binary tree problem asks for something "per level", BFS should be one of your first thoughts. For the right side view: Traverse level by level. The last node of every level is visible from the right. Record it and continue.

102. Binary Tree Level Order Traversal (LeetCode) – BFS Explained

This problem naturally asks us to visit nodes level by level, making BFS the ideal traversal. This solution runs in O(n) time with O(n) auxiliary space and is the standard interview solution for this problem.

LeetCode 235: Lowest Common Ancestor of a Binary Search Tree

Binary Search Trees (BSTs) are special because they allow us to make decisions without exploring every node. This problem is a great example of taking advantage of that property to find the Lowest Common Ancestor (LCA) in O(h)time instead of searching the entire tree.

572. Subtree of Another Tree – Explanation

A brute-force approach would compare subRoot against every node, which is exactly what this recursive solution does. Since each comparison uses the optimal Same Tree algorithm, this is the standard interview solution and is accepted by virtually every interviewer.

LeetCode 100. Same Tree – Explanation

Given the roots of two binary trees p and q, determine whether they are exactly the same. Two binary trees are considered the same if: They have the same structure. Every corresponding node contains the same value

LeetCode 110: Balanced Binary Tree – Three DFS Solutions Explained

Whenever a tree problem asks you to determine something about a node based on information from its children, think post-order DFS. For this problem, every node needs: left subtree height, right subtree height, whether both subtrees are already balanced

Diameter of Binary Tree – Understanding the DFS Solution

Once you understand that the DFS is responsible only for returning subtree heights, the entire solution becomes a clean one-pass traversal of the tree. Recognise that the diameter at a node is left_height + right_height.

Leetcode 104 : Maximum Depth of Binary Tree — Recursive DFS, BFS, and Iterative DFS

With recursive DFS, the answer for each node is:1 + the greater depth of its two subtrees With BFS, the answer is the number of levels processed. With iterative DFS, each node is stored together with its current depth.

226. Invert Binary Tree – Three Ways to Solve It (Recursive, DFS, and BFS)

Binary Tree problems are a staple in coding interviews, and Invert Binary Tree is one of the most famous ones. Despite its simplicity, this problem is an excellent exercise for understanding tree traversal and the differences between recursive DFS, iterative DFS, and BFS.

LRU Cache Explained: Solving It in O(1) Using a Hash Map + Doubly Linked List

The LRU Cache is a classic example of combining two data structures to satisfy strict performance constraints. Once you understand this pattern, you’ll recognize similar techniques in problems involving caches, browser history, undo/redo systems, and operating system memory management.

LeetCode 287: Find the Duplicate Number — Floyd’s Cycle Detection Explained

The duplicate creates a cycle because two indices eventually lead to the same node. Floyd’s Tortoise and Hare algorithm detects that cycle without modifying the array. Resetting one pointer to the start lets you find the cycle entrance, which is the duplicate number.

LeetCode 2: Add Two Numbers — Python Explanation

The reverse-order representation makes the addition easier because the least significant digits appear first. This allows us to process the linked lists from left to right, just like digit-by-digit addition.

LeetCode 138: Copy List With Random Pointer – Hash Map Approach Explained

This problem is an extension of the classic linked list cloning problem. Along with the usual next pointer, every node also contains a random pointer that can point to any node in the list or be null.

19. Remove Nth Node From End of List — Explanation and Python Solution

The two-pointer technique is useful when a problem asks us to find a node relative to the end of a linked list. The dummy node simplifies edge cases, especially when the node being removed is the head.

LeetCode 143: Reorder List – Three-Step Linked List Solution Explained

Find the midpoint once. Reverse the second half once. Merge both halves once. Each node is visited only a constant number of times, making the solution both efficient and easy to reason about.

LeetCode 21: Merge Two Sorted Lists — Python Explanation

This problem demonstrates several important linked-list techniques: Using a dummy node to simplify list construction. Updating pointers without creating unnecessary nodes.

LeetCode 141: Linked List Cycle – Floyd’s Tortoise and Hare Algorithm Explained

This is one of the most frequently asked linked list interview problems, and understanding the intuition behind the two-pointer approach will help you tackle many other linked list questions as well.

LeetCode 206: Reverse Linked List – A Simple Iterative Approach

Linked lists are one of the most fundamental data structures, and reversing a linked list is a classic interview question. Although the problem is straightforward, it tests your understanding of pointers and how nodes are connected.

LeetCode 3: Longest Substring Without Repeating Characters | Brute Force to Sliding Window

A set is perfect for checking duplicates in constant time. The sliding window technique maintains a valid substring by expanding to the right and shrinking from the left only when necessary.

Greedy Algorithm -

LeetCode 121: Best Time to Buy and Sell Stock

The important rule is that we must buy before we sell. So while scanning the array, we keep track of the cheapest price seen so far and calculate the best possible profit at each step.

LeetCode 4: Median of Two Sorted Arrays – From Brute Force to Binary Search

One of the most famous hard problems on LeetCode is Median of Two Sorted Arrays. At first glance, it looks straightforward—you just need the median of two sorted arrays. But the catch is that the required time complexity is O(log(m + n)), which rules out the obvious approach.

LeetCode 981: Time Based Key-Value Store Explained (Binary Search Solution)

The elegant part of this problem is recognizing that the timestamps are already sorted because of the problem constraint. The combination of: a hash map for fast key lookup, and binary search on the timestamp list gives an optimal solution

Leetcode 33: Search in Rotated Sorted Array Explained

The main trick in this problem is realizing that even though the entire array is rotated, one side of the midpoint will always be sorted. Once we identify the sorted side, we can decide whether the target belongs there or not.

LeetCode 153: Find Minimum in Rotated Sorted Array – Binary Search Explained

Binary search isn’t just for finding an element in a sorted array. One of its most powerful applications is searching for a boundary or turning point. LeetCode 153: Find Minimum in Rotated Sorted Array is a perfect example of this pattern.

Leetcode 875: Koko Eating Bananas – Binary Search on the Answer

Whenever you encounter a problem asking for the minimum or maximum value that satisfies a condition, consider whether the answer space is monotonic. If it is, binary search on the answer is often the optimal approach.

LeetCode 74: Search a 2D Matrix — Explanation

The two-step binary search solves by first finding the row and then searching inside it. The cleanest and most optimal solution is to treat the matrix as a virtual 1D sorted array and run one binary search over it.

Leetcode 704. Binary Search – Explained with Python

Binary Search is one of the most fundamental algorithms every programmer should know. It’s fast, elegant, and appears frequently in coding interviews. Binary Search only works on sorted data.

Leetcode 84. Largest Rectangle in Histogram — Explanation

The brute force solution is easier to understand because it directly checks how far each bar can expand. The optimized monotonic stack solution is more efficient because it avoids repeated scanning.

Leetcode 853: Car Fleet: Intuition and Python Solution

The main trick in this problem is realizing that we do not need to simulate the cars moving. We only need to calculate each car’s arrival time and process the cars from closest to farthest from the destination.

739. Daily Temperatures — Explanation

We need to return an array result, where result[i] tells us how many days we have to wait after day i to get a warmer temperature. The monotonic stack solution is more efficient because it keeps track of unresolved days and updates them as soon as a warmer temperature appears.

Leetcode 150. Evaluate Reverse Polish Notation — Explanation

This problem is a great example of how useful stacks are when evaluating expressions. Since Reverse Polish Notation places operators after operands, a stack helps us easily keep track of the values needed for each operation.

Leetcode 42: Trapping Rain Water: From Brute Force to Optimal Two Pointers

The Trapping Rain Water problem is an excellent example of how understanding the properties of a problem can lead to significant optimizations. The biggest takeaway is recognizing that the smaller of the two maximum boundaries determines the water level.

Leetcode 11: Container With Most Water – From Brute Force to Two Pointers

Instead of checking every possible pair, we use the properties of the problem to make a greedy decision at each step, resulting in an elegant O(n) solution.

Leetcode 15: 3Sum – From Brute Force to Two Pointers

The key insight is realizing that after sorting the array, we don’t need three nested loops anymore. Instead: Fix one number., use two pointers to search for the other two, skip duplicates carefully and stop early once the fixed number becomes positive.

Leetcode 167: Two Sum II – Input Array Is Sorted

A sorted array often hints at using the two-pointer technique. Instead of checking every possible pair, eliminate impossible candidates by moving pointers intelligently.

Solution: Leetcode 20 Valid Parentheses Problem and its Solution in Python

Given a string s containing only the characters '(', ')', '{', '}', '[', and ']', we need to determine if the input string is valid. An input string is considered valid if the following conditions are met:

Leetcode 125 Valid Palindrome – Two Pointers Explained (Python)

This is a classic interview problem because it combines string manipulation with the Two Pointer pattern while keeping both the time complexity O(n) and the space complexity O(1).

LeetCode 128: Longest Consecutive Sequence — Explanation

Given an integer array nums, return the length of the longest consecutive sequence that can be formed. The key trick is to only begin counting when we find the start of a sequence. This avoids repeated work and allows us to solve the problem in linear time.

Leetcode 36 : Valid Sudoku - Explanation

Sudoku is a classic 9×9 puzzle where each row, column, and 3×3 box must contain the digits 1 through 9 without repetition. In this problem, we are not asked to solve the Sudoku board. Instead, we only need to check whether the current board is valid.

Leetcode 238. Product of Array Except Self — Explanation

The main trick is realizing that for each index, we need: left product * right product. By doing one pass from the left and one pass from the right, we can calculate the answer without using division and without needing nested loops.

LeetCode 271: Encode and Decode Strings — Python Explanation

The encode function takes a list of strings and converts it into a single string. The decode function takes that encoded string and converts it back into the original list.

LeetCode 347: Top K Frequent Elements — Explanation

We are given an integer array nums and an integer k. We need to return the k most frequent elements in the array. Implementation using sorting, min-heap and bucket sorting are explained in this article.

Leetcode 49: Group Anagrams Explanation

An anagram is a word that has the same characters as another word, but possibly in a different order. For example, "act"and "cat" are anagrams because both contain the letters a, c, and t.

Leetcode 1: Two Sum Explained: From Brute Force to an Optimal Hash Map Solution

The Two Sum problem is one of the most popular coding interview questions. Although it looks simple, it introduces several important concepts that appear repeatedly in algorithm design, such as brute force search, sorting with two pointers, and hash maps.

LeetCode 217: Contains Duplicate – 4 Python Solutions Explained

One of the first array problems you’ll encounter on LeetCode is 217. Contains Duplicate. Although the problem is straightforward, it introduces an important concept: trading time for space.

LeetCode 242: Valid Anagram – 3 Python Solutions Explained

Valid Anagram is a classic string problem that teaches different ways to compare the frequency of characters in two strings. While the problem is simple, it introduces an important concept you’ll use repeatedly in coding interviews: counting occurrences efficiently.

Solution: Leetcode 21 Solving the Merge Two Sorted Lists Problem in Python

You are given the heads of two sorted linked lists, list1 and list2. Merge the two lists into one sorted list. The list should be made by splicing together the nodes of the first two lists. Return the head of the merged linked list.

Solution: Leetcode 206 Reversing a Singly Linked List

Given the head of a singly linked list, our task is to reverse the list and return the reversed version. For example, if the input linked list is [1, 2, 3, 4, 5], the reversed list should be [5, 4, 3, 2, 1].

LeetCode 155: Min Stack – Constant Time Minimum Lookup

The key insight isn’t about finding the minimum quickly—it’s about remembering the minimum as the stack evolves. By maintaining a second stack that mirrors the main stack and stores the minimum value at every level, we eliminate the need to recompute the minimum after every pop().

Solution: Leetcode 682 Solving a Baseball Scoring Puzzle with Python

You are keeping the scores for a baseball game with a unique set of rules. At the beginning of the game, you start with an empty record. You're given a list of strings operations, where each element represents an operation to apply to the record.

Solution: Leetcode 1929 Solving the Array Concatenation Problem in Python

You are given an integer array nums of length n. The task is to create a new array ans of length 2n such that ans[i] == nums[i] and ans[i + n] == nums[i] for 0 <= i < n (0-indexed). In simpler terms, the array ans is formed by concatenating two copies of the array nums.

Solution: Leetcode 27 Removing Elements from an Integer Array in Python

Given an integer array nums and an integer val, the task is to remove all occurrences of val in nums in-place. Additionally, we need to return the number of elements in nums that are not equal to val.

Solution: Leetcode 26 Removing Duplicates from Sorted Array in Python

The problem at hand is to remove duplicates from a sorted integer array nums in-place, such that each unique element appears only once. Additionally, we need to return the number of unique elements present in the modified array.

88. Merge Sorted Array – LeetCode Solution Explained Problem Link

You are given two integer arrays nums1 and nums2, sorted in non-decreasing order, and two integers m and n, representing the number of elements in nums1 and nums2 respectively. Merge nums1 and nums2 into a single array sorted in non-decreasing order.