Data Structures and Algorithms

Compare constant, logarithmic, linear, and quadratic growth before choosing an implementation.

Break a problem into smaller calls and understand the call stack and base case.

How values are arranged, accessed, inserted, removed, and updated.

Contiguous memory, indexes, traversal, insertion, deletion, and dynamic resizing.

Understand the difference between fixed-size memory blocks and auto-expanding lists.

Learn how grids and matrices are mapped onto linear computer memory.

Query the sum of any subarray in constant time using a precomputed array.

Apply massive overlapping range updates in constant time per update.

Store massive arrays efficiently when most of their elements are zero or empty.

Nodes, references, traversal, insertion, deletion, and reversal.

Master the mechanics of one-way node traversal and the fast/slow pointer technique.

Leverage backward pointers for O(1) deletions and complex caching structures.

Build a continuous ring of nodes where the tail connects back to the head.

Last-in-first-out and first-in-first-out processing with practical examples.

Explore array vs linked-list implementations and expression evaluation.

Explore the First-In-First-Out processing model and its critical role in BFS.

Use modulo arithmetic to build efficient, fixed-size ring buffers.

Double-ended queues allow insertion and deletion at both the front and rear.

Character storage, scanning, matching, prefixes, and frequency counting.

Achieve O(log N) search times in a linked list using multiple layers of express lanes.

Maintain a strictly increasing or decreasing invariant to solve 'next greater element' problems.

Combine a deque with a monotonic invariant to conquer sliding window problems.

Query and update arbitrary array intervals in logarithmic time.

Implement Binary Indexed Trees for hyper-efficient prefix sums with minimal memory.

Find the deepest node that is an ancestor of two specific targets.

Calculate the longest path between any two nodes in a tree structure.

Sort all suffixes of a string to solve complex substring problems efficiently.

Compress all suffixes of a string into a powerful, navigatable Trie.

Trade absolute certainty for immense space savings in set membership queries.

Learn how priority queues process the most urgent items first using heap structures.

Roots, children, depth, traversal, binary search trees, and balanced trees.

Understand the foundations of binary trees, nodes, leaves, and hierarchical data.

Learn how the BST property enables fast lookups and sorted retrievals.

Master self-balancing trees using height differentials and rotations.

Explore the relaxed balancing rules that power standard library maps and sets.

Learn the wide, shallow trees designed specifically for disk storage and databases.

Explore Pre-order, In-order, Post-order, and Level-order traversal strategies.

Build efficient prefix trees for autocomplete and string dictionaries.

Vertices, edges, breadth-first search, depth-first search, and visited sets.

Keys, hash functions, collisions, sets, maps, and constant-time lookup.

Maintain the smallest or largest available item while values are added and removed.

Store words by shared prefixes for lookup and autocomplete.

Track connected components with union and find operations.

Compare selection, insertion, merge, quick, and heap-based sorting.

Linear search, binary search, and the conditions that make binary search valid.

Move two indexes through a sequence without repeatedly rescanning it.

Maintain a changing range while adding and removing boundary values.

Choose, explore, undo, and continue through combinations and arrangements.

Save answers to repeated subproblems and build the final answer from them.

Make the best safe local choice and explain why it cannot damage the final answer.

Shortest paths, topological ordering, minimum spanning trees, and connectivity.

Use fast bitwise operators to represent sets or do math at the hardware level.