Category
data structures
23 articles across 2 sub-topics
Two Pointer Technique: Solving Pair and Partition Problems in O(n)
TLDR: Place one pointer at the start and one at the end of a sorted array. Move them toward each other based on a comparison condition. Every classic pair/partition problem that naively runs in O(n²)
Tries (Prefix Trees): The Data Structure Behind Autocomplete
TLDR: A Trie stores strings character by character in a tree, so every string sharing a common prefix shares those nodes. Insert and search are O(L) where L is the word length. Tries beat HashMaps on
Sliding Window Technique: From O(n·k) Scans to O(n) in One Pass
TLDR: Instead of recomputing a subarray aggregate from scratch on every shift, maintain it incrementally — add the incoming element, remove the outgoing element. For a fixed window this costs O(1) per
Merge Intervals Pattern: Solve Scheduling Problems with Sort and Sweep
TLDR: Sort intervals by start time, then sweep left-to-right and merge any interval whose start ≤ the current running end. O(n log n) time, O(n) space. One pattern — three interview problems solved.
In-Place Reversal of a Linked List: The 3-Pointer Dance Every Interviewer Expects
TLDR: Reversing a linked list in O(1) space requires three pointers — prev, curr, and next. Each step: save next, flip curr.next to point backward, advance both prev and curr. Learn this once and you unlock four reversal variants that appear constant...
Fast and Slow Pointer: Floyd's Cycle Detection Algorithm Explained
TLDR: Move a slow pointer one step and a fast pointer two steps through a linked structure. If they ever meet, a cycle exists. Then reset one pointer to the head and advance both one step at a time —
DFS — Depth-First Search: Go Deep Before Going Wide
TLDR: DFS explores a graph by diving as deep as possible along each path before backtracking, using a call stack (recursion) or an explicit stack. It is the go-to algorithm for cycle detection, path finding, topological sort, and connected components...
Cyclic Sort: Find Missing and Duplicate Numbers in O(n) Time, O(1) Space
TLDR: If an array holds n numbers in range [1, n], each number belongs at index num - 1. Cyclic sort places every element at its correct index in O(n) time using O(1) space — then a single scan reveals every missing and duplicate number. Five intervi...
Binary Search Patterns: Five Variants Every Senior Engineer Knows
TLDR: Binary search has five patterns beyond the classic "find the target": leftmost position, rightmost position, rotated array search, minimum in rotated array, and 2D matrix search. The root of every off-by-one bug is a mismatched loop condition a...
BFS — Breadth-First Search: Level-by-Level Graph Exploration
TLDR: BFS explores a graph level by level using a FIFO queue, guaranteeing the shortest path in unweighted graphs. Recognize BFS problems by keywords: "shortest path," "minimum steps," or "level order." Time: O(V + E). Space: O(V). Mark nodes visited...
Two Heaps Pattern: Find the Median of a Data Stream Without Sorting
TLDR: Two Heaps partitions a stream into two sorted halves. A max-heap holds everything below the median; a min-heap holds everything above it. Keep the heaps size-balanced and you can read the median from either top in O(1) — no sorting needed, ever...
Top K Elements Pattern: Find the Best K Without Sorting Everything
TLDR: To find the top K largest elements, maintain a min-heap of size K. For every new element, push it onto the heap. If the heap exceeds K, evict the minimum. After processing all N elements, the heap holds exactly the K largest. O(N log K) time — ...
K-Way Merge Pattern: Merge K Sorted Sequences with a Min-Heap
TLDR: K-Way Merge uses a min-heap with exactly one entry per sorted input list. Each entry stores the current element's value plus the coordinates to find the next element in that list. Pop the minimum (global smallest), append it to output, push the...
What are Hash Tables? Basics Explained
TLDR: A hash table gives you near-O(1) lookups, inserts, and deletes by using a hash function to map keys to array indices. The tradeoff: collisions (when two keys hash to the same slot) must be handled, and a full hash table must be resized. 📖 Th...
Understanding Inverted Index and Its Benefits in Software Development
TLDR TLDR: An Inverted Index maps every word to the list of documents containing it — the same structure as the back-of-the-book index. It is the core data structure behind every full-text search engine, including Elasticsearch, Lucene, and PostgreS...
How Bloom Filters Work: The Probabilistic Set
TLDR TLDR: A Bloom Filter is a bit array + multiple hash functions that answers "Is X in the set?" in $O(1)$ constant space. It can return false positives (say "yes" when the answer is "no") but never false negatives (never says "no" when the answer...
Exploring Different Types of Binary Trees
TLDR: A Binary Tree has at most 2 children per node, but the shape of the tree determines performance. A Full tree has 0 or 2 children. A Complete tree fills left-to-right. A Perfect tree is a symmetric triangle. A Degenerate tree becomes a linked li...
Exploring Backtracking Techniques in Data Structures
TLDR: Backtracking is "Recursion with Undo." You try a path, explore it deeply, and if it fails, you undo your last decision and try the next option. It explores the full search space but prunes invalid branches early, making it far more efficient th...
The Ultimate Data Structures Cheat Sheet
TLDR: Data structures are tools. Picking the right one depends on what operation you do most: lookup, insert, delete, ordered traversal, top-k, prefix search, or graph navigation. Start from operation frequency, not from habit. 📖 Why Structure Cho...
Tree Data Structure Explained: Concepts, Implementation, and Interview Guide
TLDR: Trees are hierarchical data structures used everywhere — file systems, HTML DOM, databases, and search algorithms. Understanding Binary Trees, BSTs, and Heaps gives you efficient $O(\log N)$ search, insertion, and deletion — and helps you ace a...
Mastering Binary Tree Traversal: A Beginner's Guide
TLDR: Binary tree traversal is about visiting every node in a controlled order. Learn pre-order, in-order, post-order, and level-order, and you can solve many interview and production problems cleanly. 📖 Four Ways to Walk a Tree — and Why the Orde...
Redis Sorted Sets Explained: Skip Lists, Scores, and Real-World Use Cases
TLDR: Redis Sorted Sets (ZSETs) store unique members each paired with a floating-point score, kept in sorted order at all times. Internally they use a skip list for O(log N) range queries and a hash table for O(1) score lookup — giving you the best o...
LLD for LRU Cache: Designing a High-Performance Cache
TLDR TLDR: An LRU (Least Recently Used) Cache evicts the item that hasn't been accessed the longest when it's full. The classic implementation combines a HashMap (O(1) lookup) with a Doubly Linked List (O(1) move-to-front) for overall O(1) get and p...