Algorithm

A practical framework for choosing data structures and algorithms by operations, constraints, complexity, and memory/locality.

Contiguous indexed storage, constant-time random access, resizing, insertion/deletion costs, and cache locality.

Hashing, buckets, collisions, load factor, resizing, and expected versus worst-case lookup complexity.

Singly/doubly linked lists, insertion/deletion, traversal, pointer techniques, and locality trade-offs.

FIFO queues, dequeues, circular buffers, bounded queues, and priority-queue distinctions.

Uniqueness collections implemented with hashing, balanced trees, bitmaps, or specialized structures.

LIFO storage, push/pop/peek operations, recursion, parsing, monotonic stacks, and implementation choices.

Rooted trees, binary trees, BSTs, balanced trees, traversals, heaps, tries, and B-tree families.

A self-balancing binary search tree with color invariants that keep height logarithmic.

Probabilistic ordered structure with multiple forward-pointer levels and expected logarithmic search/update.

Binary heap representation and priority-queue operations such as push, peek, pop, and heapify.

Compact set membership and counting over dense integer domains using bits.

Probabilistic membership testing with no false negatives for inserted items and tunable false positives.

Graph modeling, adjacency lists/matrices, directed/undirected and weighted graphs, and common traversals/problems.

Disjoint-set union with find/union, path compression, and union by rank/size.

Log-structured merge-tree write path, sorted runs, compaction, read/write amplification, and storage-engine trade-offs.

Historical compact sequential Redis encoding and the general memory-versus-update-cost trade-off of packed representations.

Multiway balanced search trees optimized for block/page-oriented storage and their relationship to B+ trees.

Indexing selected block/range boundary keys to reduce index size while requiring local scans within the selected region.

Why indexes trade extra storage/write work for faster lookup, range, search, or aggregation paths.

Mapping terms to document postings for efficient full-text search.

LRU, LFU, FIFO, random and modern approximate policies, with workload-dependent hit-rate trade-offs.

Solving overlapping subproblems with memoization/tabulation by defining state, transition, initialization, and answer.

Making locally optimal choices only when the problem structure proves they compose into a global optimum.

Split a problem into smaller independent subproblems, solve them, then combine their results.

Recursive problem decomposition, base cases, call-stack cost, tail recursion caveats, and iterative alternatives.

Search a decision tree by choose–recurse–undo, with pruning and state management.

Recursive or explicit-stack DFS for graphs/trees, visitation state, cycle handling, and complexity.

Logarithmic search over a monotonic/sorted domain, including boundary variants.

Adjacent-swap sorting with quadratic time and mainly educational value.

Sequentially scanning elements when no useful index/order exists.

In-place comparison sorting using heap construction followed by repeated root extraction.

Stable O(n log n) divide-and-conquer sorting by merging sorted halves.

Stable in-place insertion into a sorted prefix, efficient for small or nearly sorted inputs.

Partition-based sorting with O(n log n) expected time, pivot selection, and worst-case safeguards.

Repeatedly selecting the minimum/maximum with quadratic comparisons and few swaps.

Comparing sorting algorithms by time, space, stability, adaptiveness, locality, and data constraints.

The basic CAS semantics, use cases, ABA problem, and CPU atomic-instruction implementation.

A historical CAS-based lock-free queue implementation note and its safe-memory-reclamation boundary.