Data Structures and Algorithms

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.

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

Array vs linked-list implementations, expression evaluation, and call-stack behaviour.

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

The First-In-First-Out processing model and its critical role in breadth-first search.

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

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

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

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

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.

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

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

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

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.

Query and update arbitrary array intervals in logarithmic time.

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

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

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

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

Store words by shared prefixes for lookup and autocomplete.

Build efficient prefix trees for autocomplete and string dictionaries.

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.

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

Track connected components with union and find operations.

Compare every sort on time, space, stability, and when to reach for it.

Swap adjacent pairs each pass, and stop early when a pass makes no swap.

Scan the unsorted tail for its minimum, then place it in one swap.

Grow a sorted prefix by shifting larger values right — fast on nearly sorted data.

Split to single values, then merge sorted runs in guaranteed O(n log n).

Partition around a pivot, and see why pivot choice decides the worst case.

Build a max-heap in place, then repeatedly extract the root.

Count occurrences instead of comparing, for small integer ranges.

Sort digit by digit with a stable pass per position.

Spread values across buckets, sort each, then concatenate.

Insertion sort over shrinking gaps, moving values far in one step.

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

Halve the search space each step, and get the boundary conditions right.

Move two indexes through a sequence without repeatedly rescanning it.

Maintain a changing range while adding and removing boundary values.

Build an LPS table and match without rewinding the text pointer.

Roll a substring hash and verify every collision candidate.

Choose two pointers, frequency maps, windows, or stacks from the required invariant.

Use Euclid, modular arithmetic, LCM identities, and binary exponentiation.

Test primes and generate a full range by striking multiples from p².

Split independent subproblems, solve recursively, and analyze the combine recurrence.

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

Turn repeated recursive states into explicit cache hits and misses.

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

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

Merge the two least frequencies repeatedly to build an optimal prefix tree.

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

Explore a graph level by level with a queue and visited set.

Grow and unwind the active call stack while exploring a graph.

Drain in-degrees with Kahn's algorithm or reverse DFS finish order.

Use directed colors or undirected union-find to expose cycle witnesses.

Finalize nonnegative shortest paths with a min-heap and distance table.

Relax every edge and expose a reachable negative cycle on the extra pass.

Build an MST with Kruskal and Prim while rejecting cycle edges.

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