LeetCode 919: Complete Binary Tree Inserter
A clear explanation of maintaining a complete binary tree inserter using level-order indexing.
Tag
Design
67 notes
LeetCode 911: Online Election
A clear explanation of Online Election using preprocessing and binary search over vote times.
LeetCode 901: Online Stock Span
A clear explanation of Online Stock Span using a monotonic decreasing stack with accumulated spans.
LeetCode 900: RLE Iterator
A clear explanation of designing an iterator over a run-length encoded sequence without expanding it.
LeetCode 895: Maximum Frequency Stack
A clear explanation of designing a stack that pops the most frequent value, breaking ties by most recent insertion.
LeetCode 622: Design Circular Queue
A clear explanation of Design Circular Queue using a fixed array, a front pointer, and a size counter.
LeetCode 244: Shortest Word Distance II
A clear explanation of the Shortest Word Distance II problem using preprocessing and two pointers.
LeetCode 981: Time Based Key-Value Store
A clear explanation of designing a time-based key-value store using a hash map and binary search.
LeetCode 855: Exam Room
A clear explanation of simulating an exam room by maintaining occupied seats in sorted order.
LeetCode 933: Number of Recent Calls
A clear explanation of solving Number of Recent Calls using a queue as a sliding time window.
LeetCode 716: Max Stack
A clear explanation of designing a stack that supports push, pop, top, peekMax, and popMax.
LeetCode 715: Range Module
A clear explanation of designing a range module that can add, query, and remove half-open intervals.
LeetCode 710: Random Pick with Blacklist
A clear explanation of selecting a uniformly random integer while excluding blacklisted values using remapping and hashing.
LeetCode 707: Design Linked List
A clear explanation of implementing a linked list from scratch using nodes, a dummy head, and a size counter.
LeetCode 706: Design HashMap
A clear explanation of designing a hash map without using built-in hash table libraries.
LeetCode 705: Design HashSet
A clear explanation of designing a hash set without using built-in hash table libraries.
LeetCode 703: Kth Largest Element in a Stream
A clear explanation of maintaining the kth largest element in a stream using a fixed-size min heap.
LeetCode 745: Prefix and Suffix Search
Support fast prefix and suffix queries by indexing every prefix-suffix combination with the largest word index.
LeetCode 732: My Calendar III
Track the maximum number of overlapping calendar events using a sweep line difference map.
LeetCode 731: My Calendar II
Allow double bookings but reject triple bookings using overlap interval tracking.
LeetCode 729: My Calendar I
Implement a calendar that accepts a booking only when it does not overlap with any existing booking.
LeetCode 677: Map Sum Pairs
Design a map that supports key-value insertion and prefix-sum queries using a hash map and trie.
LeetCode 676: Implement Magic Dictionary
Design a dictionary that can check whether a word can match a stored word after changing exactly one character.
LeetCode 642: Design Search Autocomplete System
A trie-based design for returning the top three historical sentences for a typed prefix.
LeetCode 641: Design Circular Deque
An array-based circular buffer solution for implementing a fixed-size double-ended queue.
LeetCode 635: Design Log Storage System
A design solution for storing timestamped logs and retrieving IDs by inclusive time range at a chosen granularity.
LeetCode 631: Design Excel Sum Formula
A design solution for a small Excel-like spreadsheet that supports set, get, and dynamic sum formulas.
LeetCode 604: Design Compressed String Iterator
A guide to implementing a lazy iterator over a run-length encoded string without fully decompressing it.
LeetCode 232: Implement Queue using Stacks
A detailed explanation of implementing a FIFO queue using two LIFO stacks with amortized constant time operations.
LeetCode 588: Design In-Memory File System
A clear design guide for implementing an in-memory file system with directory listing, directory creation, file append, and file read operations.
LeetCode 535: Encode and Decode TinyURL
A clear explanation of designing a simple URL encoder and decoder using a hash map and generated keys.
LeetCode 460: LFU Cache
A clear explanation of designing an LFU cache with O(1) average get and put operations.
LeetCode 449: Serialize and Deserialize BST
Serialize a binary search tree compactly with preorder traversal and rebuild it using BST value bounds.
LeetCode 432: All O'one Data Structure
Design a data structure that supports increment, decrement, get minimum key, and get maximum key in average O(1) time.
LeetCode 385: Mini Parser
A clear explanation of parsing a serialized nested integer string using a stack.
LeetCode 384: Shuffle an Array
A clear explanation of shuffling an array uniformly using the Fisher-Yates algorithm while supporting reset.
LeetCode 381: Insert Delete GetRandom O(1) - Duplicates Allowed
A clear explanation of designing a randomized multiset with average O(1) insert, remove, and getRandom operations.
LeetCode 380: Insert Delete GetRandom O(1)
A clear explanation of designing a randomized set with average O(1) insert, remove, and getRandom operations.
LeetCode 379: Design Phone Directory
A clear explanation of designing a phone directory that can allocate, check, and release numbers efficiently.
LeetCode 362: Design Hit Counter
A clear explanation of designing a hit counter for the last 5 minutes using a queue with compressed timestamps.
LeetCode 359: Logger Rate Limiter
A clear explanation of designing a logger that prints each message at most once every 10 seconds using a hash map.
LeetCode 355: Design Twitter
A clear explanation of implementing a simplified Twitter using hash maps, sets, timestamps, and a heap.
LeetCode 353: Design Snake Game
A clear explanation of implementing Snake Game with a deque for body order and a set for constant-time collision checks.
LeetCode 352: Data Stream as Disjoint Intervals
A clear explanation of maintaining disjoint sorted intervals from a stream using insertion and merging.
LeetCode 348: Design Tic-Tac-Toe
A clear explanation of Design Tic-Tac-Toe using row, column, and diagonal counters for constant-time winner checks.
LeetCode 346: Moving Average from Data Stream
A clear explanation of Moving Average from Data Stream using a queue and rolling sum.
LeetCode 341: Flatten Nested List Iterator
A clear explanation of Flatten Nested List Iterator using lazy stack-based flattening.
LeetCode 308: Range Sum Query 2D - Mutable
A clear explanation of Range Sum Query 2D - Mutable using a 2D Fenwick Tree for efficient updates and rectangle sum queries.
LeetCode 303: Range Sum Query - Immutable
A clear explanation of Range Sum Query - Immutable using prefix sums for constant-time range queries.
LeetCode 297: Serialize and Deserialize Binary Tree
A preorder DFS codec for converting a binary tree to a string and reconstructing the same tree from that string.
LeetCode 295: Find Median from Data Stream
A two-heap data structure for adding numbers from a stream and returning the current median in constant time.
LeetCode 288: Unique Word Abbreviation
A hash map design for checking whether a word's abbreviation is unique in a dictionary.
LeetCode 284: Peeking Iterator
A wrapper iterator design that supports peeking at the next element without advancing the iterator.
LeetCode 281: Zigzag Iterator
A queue-based iterator design for returning elements from two vectors in alternating order, with a clean extension to k vectors.
LeetCode 271: Encode and Decode Strings
A clear explanation of the Encode and Decode Strings problem using length-prefix encoding.
LeetCode 251: Flatten 2D Vector
A clear explanation of the Flatten 2D Vector problem using row and column pointers to implement an iterator.
LeetCode 225: Implement Stack using Queues
A clear explanation of implementing a LIFO stack using only FIFO queue operations.
LeetCode 211: Design Add and Search Words Data Structure
A clear explanation of designing a word dictionary with addWord and wildcard search using a Trie and DFS.
LeetCode 208: Implement Trie Prefix Tree
A clear explanation of implementing a Trie with insert, search, and startsWith operations.
LeetCode 173: Binary Search Tree Iterator
A clear explanation of designing an iterator over a BST using controlled inorder traversal with a stack.
LeetCode 170: Two Sum III - Data Structure Design
A clear explanation of designing a data structure that supports add and find operations for pair sums.
LeetCode 155: Min Stack
A clear explanation of designing a stack that can return the current minimum element in constant time.
LeetCode 146: LRU Cache
Design an LRU cache with O(1) get and put operations using a hash map and doubly linked list.
6.25 Choosing the Right Sort
Select the appropriate sorting algorithm based on input size, data characteristics, memory constraints, and required guarantees such as stability or worst-case bounds.
5.24 Real-World Hash Table Design
Choose and implement hash tables that perform reliably under mixed key types, uneven access patterns, and adversarial input.
5.22 Hybrid Hash Structures
Combine hash tables with other data structures to handle skewed distributions, heavy deletions, and mixed workloads.
5.2 Hash Functions
Design and evaluate hash functions that distribute keys uniformly across buckets while remaining fast to compute.