Learning Data Structures

Explain the backtracking paradigm as a form of pruned, exhaustive search.

Generate all subsets (the power set) of a given set of distinct integers.

Generate all possible permutations of a collection of distinct integers.

Solve the 'Combination Sum' problem, finding all unique combinations that sum to a target (with element reuse).

Solve the 'Combination Sum II' problem, finding all unique combinations where each number may only be used once.

Solve the N-Queens problem using backtracking with constraint propagation.

Solve the 'Sudoku Solver' problem by applying backtracking on a 2D grid.

Partition a string into all possible palindromic substrings using backtracking.

Implement recursive preorder, inorder, and postorder traversals of a binary tree.

Implement iterative versions of preorder, inorder, and postorder traversals using a stack.

Perform a level-order traversal of a binary tree using a queue.

Compute the maximum depth (height) and diameter of a binary tree.

Check if a binary tree is height-balanced.

Find the lowest common ancestor (LCA) of two nodes in a binary tree.

Determine the left, right, top, and bottom views of a binary tree.

Construct a binary tree from its inorder and preorder/postorder traversal sequences.

Implement search, insertion, and deletion operations in a Binary Search Tree (BST).

Validate if a given binary tree is a valid BST.

Find the k-th smallest element in a BST.

Implement the heapify operation (sift-down) and build a max-heap from an array.

Use Java's `PriorityQueue` to implement min-heaps and max-heaps with custom comparators.

Solve 'Top K' problems, such as finding the k-th largest element in an array or a stream.

Find the median from a data stream using two heaps.

Merge K sorted arrays into a single sorted array using a min-heap.

Identify problems with optimal substructure and the greedy-choice property.

Solve the 'N meetings in one room' problem (interval scheduling) using a greedy strategy.

Solve the 'Job Sequencing' problem with deadlines and profits using a greedy approach.

Apply the Dutch National Flag algorithm to sort an array of 0s, 1s, and 2s in a single pass.

Find the majority element in an array, progressing from a hash map to the optimal Boyer-Moore voting algorithm.

Apply the 'Binary Search on Answer' paradigm to solve optimization problems (e.g., Aggressive Cows, Allocate Books).

Find the median of two sorted arrays of different sizes using a binary search approach on partitions.

Represent a graph using both an adjacency list and an adjacency matrix.

Implement Breadth-First Search (BFS) and Depth-First Search (DFS) traversals on a graph.

Use BFS/DFS to solve grid-based problems like 'Number of Islands' and 'Rotten Oranges'.

Detect cycles in both undirected and directed graphs using DFS.

Perform a topological sort on a Directed Acyclic Graph (DAG) using both DFS and Kahn's algorithm (BFS).

Find the shortest path from a single source in a weighted graph using Dijkstra's algorithm with a priority queue.

Implement the Disjoint Set Union (DSU) data structure with path compression and union by rank/size.

Find a Minimum Spanning Tree (MST) using Kruskal's algorithm with DSU.

Identify overlapping subproblems and optimal substructure to solve problems with DP.

Solve 1D DP problems (e.g., Climbing Stairs, House Robber) using both memoization and tabulation.

Solve 2D/Grid DP problems (e.g., Unique Paths, Minimum Path Sum).

Solve knapsack-style DP problems (0/1 Knapsack, Subset Sum, Coin Change).

Solve string-based DP problems (e.g., Longest Common Subsequence, Edit Distance).

Solve the 'Longest Increasing Subsequence' problem, progressing from an O(n^2) DP solution to an O(n log n) solution with binary search.

Implement a Trie (Prefix Tree) with insert, search, and startsWith operations.

Use a Trie to solve problems like finding the longest word with all prefixes or counting distinct substrings.