LEETCODE In C++ - Top 100 Coding Interview Problems

Explore time and space complexity, understanding runtime and memory growth with input size. Measure operations and express results in big O notation, focusing on ram usage and storage.

Explore big O notation as a language of time and space complexity and learn how runtime grows with input size across linear, constant, logarithmic, and quadratic cases.

Analyze time complexity of for loops by counting operations, derive O(n) for n iterations, and O(1) for a single-run loop, using Big-O rules to ignore constants and lower-order terms.

Estimate operation counts from time complexity and constraints to decide acceptability, targeting at most 1e7–1e8 operations. Let constraints hint whether to use binary search, backtracking, or dynamic programming.

Analyze a doubling while loop to show O(log n) time by tracking i across iterations. Examine nested loops yielding O(mn) time and learn to count operations toward big-O.

Explore myths about time complexity with two loops, showing both have O(n) time while one runs longer in practice. Learn that complexity measures growth rate, not absolute runtime.

Explore how to calculate time complexity for recursive functions using a recursion tree, illustrated with a factorial example and function calls, highlighting O(n) growth.

Explore the Fibonacci function, analyzing its time and space complexity with a recursion tree of two branches, showing exponential growth and a two raised to the n minus one count.

Understand how space complexity grows with input and compute it by summing contributions from variables, external data structures, and recursion for coding interviews.

Examine a simple space complexity case where an input array is not counted, a for loop uses fixed variables, and the overall space remains constant at O(1).

Compute the space complexity of a recursive fibonacci function by tracing recursion depth and the call stack, revealing an O(n) space cost with n−1 stored integers.

Discover how arrays store data as a continuous, homogeneous structure in RAM, enabling constant-time access through index-based address calculation. Recognize the speed benefits of contiguity and understand the trade-offs.

Explore drawbacks of traditional arrays: static size and inefficient inserts or deletions in the beginning or middle, with alternatives like vectors, array lists, and linked lists for resizable arrays.

learn how resizable arrays work by using ArrayList or vector, which start with a small capacity, track size and capacity, double on overflow, copy elements, and achieve amortized O(1) insertion.

Solve max consecutive ones in a binary array by iterating, using a count and answer to track the longest run, resetting count when encountering zeros, with O(n) time.

Analyze the best time to buy and sell a stock with one transaction across daily prices, tracking the minimum price before each day to maximize profit.

Explore the product of array except self, using left and right product arrays to compute each position's product without division, delivering an O(n) time solution in C++.

Rotate an array to the right by k steps using k mod n and a three-step reverse: reverse whole, reverse first k, reverse last n-k, achieving O(n) time.

Explore Kadane's algorithm for the maximum sum subarray, tracking the current sum, resetting on negative values, and updating the best sum in O(n) with a simple C++ implementation.

Explore the maximum product subarray problem with a dynamic approach that tracks both the maximum and minimum products at each index, handling negatives and zeros.

Validate a 9x9 sudoku by checking each row, column, and 3x3 grid for digits 1–9 without repetition, ignoring empty cells, using row, column, and grid sets.

Move zeros to the end while preserving the relative order of non-zero elements by shifting non-zeros to the left using a swap-based two-pointer approach.

Sort zeros, ones, and twos in place using a Dutch national flag approach with two pointers. Move zeros left and twos right without extra space.

Discover the majority element problem, where the element occurs at least n/2 times, and solve it in linear time and constant space using the most voting algorithm, assuming majority exists.

Compute the intersection node of two linked lists with a two-pointer approach that handles unequal lengths by skipping nodes, achieving O(m+n) time and O(1) space, returning the intersection or null.

Practice problem 2 shows merging two sorted linked lists into one sorted list by splicing nodes, using two pointers to append the smaller value and finish with remaining nodes.

Detect cycles in a linked list using the hare and tortoise algorithm with slow and fast pointers. Handle empty or single-element lists and note the O(n) time complexity.

Explore reversing a singly linked list using a recursive approach. See how the function reverses from head, handles the base case, and yields O(n) time and O(n) space complexity.

Learn to determine if a linked list is a palindrome in linear time with constant space by reversing the second half and using two pointers to compare halves.

Detects a linked list cycle with the slow and fast pointer method and, if present, finds the cycle start via a second phase; otherwise returns null.

Master the two-pointer solution to find the middle of a singly linked list, returning the second middle node for even lengths in one pass with O(n) time.

Master the one-pass removal of the nth node from the end of a linked list using fast and slow pointers with a gap of n+1, including deleting the first node.

Add two numbers represented by linked lists stored in reverse order. Implement a C++ solution that traverses both lists, handles carry, and returns the sum as a linked list.

Learn to check for balanced parentheses using a stack, validating opening and closing brackets of round, curly, and square types in correct last-in, first-out order.

Design a min stack that supports push, pop, top, and get min in o(1) time by maintaining a main stack for all elements and an auxiliary stack for current minima.

Explore solving the next greater element II problem on a circular array using a stack to perform delayed processing, update answers, and achieve O(n) time.

Evaluate reverse Polish notation, or postfix notation, by using a stack to process tokens as operands or operators and compute value, as shown with 2 1 + 3 *.

Solve the easy contains duplicate problem from LeetCode by using a hash table or set to detect repeated values in an array, returning true when a duplicate is found.

Solve the two sum problem in an array using a hash table to find the complement and return indices, illustrating the O(n) time and O(n) space trade-off versus brute-force O(n^2).

Explore how to check if two strings are anagrams using sorting (or hashing), with a C++ implementation that sorts s and t via std::sort and compares the results.

Group strings into anagrams using a hash table; sort each string to form a key and store all same-key strings as a list to form groups.

Explore solving the longest consecutive sequence problem in an unsorted array by building a hash set, avoiding sorting, and achieving O(n) time with efficient preprocessing.

Master the three sum problem by finding all unique triplets that sum to zero, from brute force to a sorted two-pointer solution with O(n^2) time.

Master the sliding window and two-pointer approach to find the longest substring without repeating characters, using a hash table to count chars and achieve linear time.

Master the sliding window maximum problem by using a double-ended queue to maintain candidate indices, removing out-of-window and smaller values to achieve O(n) time for all k-length windows.

Check whether a string is a valid palindrome using the two-pointer method, ignoring non-alphanumeric characters and converting uppercase letters to lowercase, with left and right pointers comparing characters in C++.

Apply the two-pointer method on a sorted, non-decreasing array to find two numbers that sum to a target, returning one-indexed positions with linear time and constant space.

Practice solving the container with most water using a two-pointer method on a height array. Min of the two heights times the width; move the smaller height pointer.

Solve the trapping rainwater problem on an elevation map by computing water trapped at each bar using left and right maximums via a two pointer method, yielding O(n) time.

Solve the set matrix zeros problem in place by marking rows and columns with the first row and first column as markers, achieving constant space in C++.

Learn to print a rectangular m by n matrix in spiral order by tracking four directions and the top, bottom, left, and right boundaries with C++ and output vector.