Trade-off Summary: Arrays provide O(1) random access and superior cache performance but incur O(n) cost for insertions/deletions. Linked lists excel at O(1) insertions/deletions anywhere but sacrifice random access speed and add per-element memory overhead for pointers. Choose based on your access pattern — random access favors arrays, frequent mid-list modifications favor linked lists.

Trade-off Summary: BSTs maintain sorted order enabling range queries and ordered operations at O(log n) cost, but Hash Maps deliver superior average-case O(1) lookups. If your workload is lookup-heavy with no ordering needs, hash maps win on performance. For ordered data access patterns, BSTs (or their balanced variants like AVL/Red-Black) are the clear choice.

Trade-off Summary: BFS guarantees shortest paths in unweighted graphs and processes level-by-level, making it ideal for level-order problems. DFS uses less memory for deep graphs and naturally handles recursion and backtracking scenarios. BFS requires O(V) queue space while DFS only needs O(H) stack depth — choose based on graph shape and memory constraints.

Trade-off Summary: Dynamic programming and memoized recursion solve the same class of problems but differ in execution approach. Top-down memoization is easier to derive from recursive definitions and can skip unreachable states, while bottom-up DP avoids recursion stack overhead and can optimize tabulation order. For interview clarity, top-down with memoization is often more explainable, while bottom-up is more space-efficient in production.

Trade-off Summary: Both min-heaps and max-heaps provide O(log n) insertion and O(log n) extraction of the extreme element. The choice depends entirely on whether you’re processing smallest or largest elements first. Dijkstra’s algorithm uses min-heap to always process the shortest known distance, while max-heap is useful for priority queues where higher values have priority. Some problems require both — consider using a median finder with two heaps instead.

Trade-off Summary: Divide & conquer breaks problems into independent subproblems, solves them recursively, then combines results — making it applicable to problems like sorting and closest pair. Greedy makes locally optimal choices at each step, betting they lead to global optimum — valid for MST (Kruskal/Prim) and Huffman coding. The key difference: divide & conquer explores all paths then combines, while greedy commits to one path. Always verify the greedy choice property before committing to greedy over DP or divide-and-conquer.

Trade-off Summary: Both support O(log n) point updates and range queries, but segment trees use 4n space while Fenwick trees use n space. Segment trees handle arbitrary associative operations and support lazy propagation for range updates. Fenwick trees are simpler and more memory-efficient but only handle prefix aggregates. For competitive programming, start with Fenwick for prefix problems — upgrade to segment tree only when you need range updates or non-prefix queries.

Trade-off Summary: LeetCode dominates FAANG interview preparation with its extensive question bank organized by company and topic. Codeforces excels at competitive programming contests and algorithmic speed — ideal for improving contest rating. HackerRank offers better enterprise assessment tools and structured learning paths. Most serious interview candidates use LeetCode as primary tool supplemented with Codeforces for speed practice. Don’t rely on just one platform — each has different strengths for different goals.