Leetcode For Beginners: Crack DSA Interviews With Blind 75+

Explore the two sum problem and its solutions. Use brute force, sorting, and a hash map to efficiently find indices that add to the target.

Explore how to detect duplicates in an integer array nums using brute force, sorting, or a hash set, returning true when a value repeats and false otherwise.

Define an anagram as two strings with identical character frequencies, and compare brute-force (sorting) with an efficient 26-letter bucket approach to determine if they are anagrams.

Group anagrams from an array of strings using hash maps and frequency patterns, compare brute-force and sorting methods, and explore time and space trade-offs.

Deliver a method to find the top k frequent elements by building a frequency map with a hash map, bucketing by frequency, then collecting from high to low.

Explore whether s is a subsequence of t using a two-pointer method, compare brute force and efficient solutions, and note O(n) time and O(1) space.

Explore the longest consecutive sequence in an unsorted array, comparing brute force, sorting, and hash map approaches to achieve O(n) time and return the maximum length.

Learn to compute the product of array elements except self in O(n) without division by building left and right product arrays, handling zeros, with illustrative examples on LeetCode 238.

Learn how to determine if a string is a palindrome by ignoring non alphanumeric characters and normalizing case, then compare characters from both ends using a two-pointer approach.

Master the two sum II problem on a sorted array using a two-pointer technique to find two numbers that add to a target and return one-indexed positions.

Master the 3sum problem by finding unique triplets that sum to zero using sorting and the two-pointer method, and learn the efficient O(n^2) approach over brute-force that avoids duplicates.

Visualize heights as bars to solve the container with most water problem, compute area as min(height[i], height[j]) times (j−i) with brute force, then optimize using a two-pointer left/right approach.

Learn to find the maximum average of a contiguous subarray of length k using a sliding window with a fixed-size two-pointer approach, achieving O(n) time and O(1) space.

Analyze a prices array to buy on a low day and sell on a later day in a single transaction to maximize profit, returning zero when no profit is possible.

Learn to solve the longest repeating character replacement problem using a sliding window with two pointers, tracking max frequency and up to k replacements to maximize a contiguous substring.

Explore the longest substring without repeating characters using a variable sliding window. Learn the difference between substring and subsequence, and apply two pointers with a set for unique characters.

Master the minimum window substring using a two-pointer sliding window with hash maps to find the shortest s-substring containing all characters of t, or return an empty string.

Use the fast and slow pointer technique to find the middle node of a singly linked list, returning the second middle for even elements, in O(n) time and O(1) space.

Detect a cycle in a linked list using Floyd's tortoise and hare approach, where slow and fast pointers meet to confirm a loop, with O(n) time and O(1) space.

Detect a cycle in a linked list and locate its start; compare a brute-force hash-table approach with O(n) time and space to a two-pointer method that finds the cycle entry.

Reverse a singly linked list efficiently by using three pointers (previous, current, next) to invert links, starting from the head and ending at null, after exploring a brute-force stack approach.

Reorder a singly linked list in place by using slow and fast pointers to find the middle, reverse the second half, and merge to form the alternating head-tail pattern.

Remove the nth node from the end of a linked list using a dummy node and a two-pointer approach, achieving O(m) time and O(1) space.

Master in-place merging of two sorted linked lists using two pointers and a dummy node; return the head of the merged, fully sorted list by iterating and attaching nodes.

Merge k sorted linked lists by divide and conquer, pairing lists to merge until one sorted list remains. It runs in o(n log k) time with space complexity o(log k).

Understand how to validate strings of brackets using a stack, mapping each closing bracket to its opening counterpart, ensuring proper order and an empty stack at the end.

Compute, for each day, how many days until a warmer temperature in the daily temperatures array; apply brute-force first, then a right-to-left stack solution with O(n) time and space.

Learn how to perform binary search on a sorted array to locate a target's index in O(log n) time, using left, right, and mid pointers.

Learn to find the minimum in a rotated sorted array of unique elements using binary search with left and right pointers, identifying the unsorted side pivot in O(log n) time.

discover how to locate a target in a rotated sorted array by finding the pivot and performing binary search on the correct side, delivering log n time and constant space.

Discover how to compute the maximum depth of a binary tree by traversing from root to leaf, using recursive depth-first search and iterative breadth-first search, and depth versus height clarified.

Determine if two binary trees are the same by checking identical structure and equal node values, using a depth-first recursive approach that compares left and right subtrees.

Determine if the secondary tree is a subtree of the main tree by recursively comparing values and structure with a same-tree check, using dfs and base cases for nulls.

Discover how to find the lowest common ancestor in a binary search tree by using BST properties, with an iterative, in-place solution that runs in O(log n) time.

learn how to perform a binary tree level order traversal using a queue to collect node values by level, left to right, from root to leaves.

Validate a binary search tree by ensuring left subtree values are less than the node and right subtree values are greater. Use inorder traversal to confirm the sequence is ascending.

Find the kth smallest value in a binary search tree using in-order traversal to produce a sequence, then return the k-th element (k is one-indexed) with O(n) time and space.

Construct a binary tree from preorder and inorder traversals by locating the root from preorder and partitioning inorder into left and right subtrees; use a map for O(1) lookups.

Learn to compute the binary tree maximum path sum for a non-empty path by combining left and right gains at each node, updating a global maximum during depth-first traversal.

Design and implement serialize and deserialize algorithms for binary trees using level order traversal and a queue, producing a unique string and reconstructing the exact same tree.

Solve the combination sum problem with backtracking on distinct candidates, using unlimited repetitions to reach target, producing all unique combinations and pruning duplicates.

Explore word search on an m by n grid using depth-first search and backtracking; move in four directions, no diagonals, marking visited cells, with time complexity 4^k and space O(k).

Learn how a prefix tree (trie) stores and searches strings efficiently through insertion, search, and prefix querying, using a root node and hash maps for children.

Design a data structure using tries to add words and search with wildcard dots, implementing depth-first search backtracking to match any letter and ensure end-of-word checks.

Explore word search ii on an m by n grid by building a trie from the word list and using depth-first search with backtracking to locate all board words efficiently.