Topic
30 posts tagged “Data Structures”.
The Lycoris Team · · 5 min read LRU evicts whatever hasn't been used in the longest time; LFU evicts whatever has been used the fewest times. How each policy behaves and when to pick it.
The Lycoris Team · · 4 min read The Knuth-Morris-Pratt algorithm finds a pattern inside a text in linear time by never re-examining characters it has already matched.
The Lycoris Team · · 5 min read A ring buffer is a fixed-size array that wraps its read and write pointers around, giving O(1) enqueue and dequeue without ever resizing.
The Lycoris Team · · 5 min read A Fenwick tree, or binary indexed tree, answers prefix-sum queries and point updates in O(log n) with far less memory than a segment tree.
The Lycoris Team · · 4 min read Bit manipulation uses operators like AND, OR, XOR, and shifts to work directly on binary representations — the basics behind flags, masks, and fast math.
The Lycoris Team · · 4 min read When two keys hash to the same slot, a hash table needs a collision strategy. Chaining and open addressing solve it differently — here's the tradeoff.
The Lycoris Team · · 5 min read A segment tree answers range queries — sum, min, max — over an array in logarithmic time, and supports updates without rebuilding the whole structure.
The Lycoris Team · · 4 min read Backtracking solves problems by building candidate solutions incrementally and abandoning any path that can't lead to a valid answer. How it works, with examples.
The Lycoris Team · · 5 min read Union-find tracks a collection of disjoint sets and answers 'are these two items connected?' in near-constant time. How it works and where it's used.
The Lycoris Team · · 4 min read Topological sort orders the nodes of a directed acyclic graph so every dependency comes before what depends on it. How it works and where it's used.
The Lycoris Team · · 5 min read Two pointers walk a sorted array or string from both ends (or in tandem) to solve problems in one linear pass instead of nested loops.
The Lycoris Team · · 4 min read An LSM tree batches writes in memory and flushes them as sorted files on disk, trading read complexity for the fast, sequential writes many databases rely on.
The Lycoris Team · · 4 min read The sliding window technique tracks a moving subrange of an array or string, turning many O(n²) brute-force problems into a single O(n) linear pass.
The Lycoris Team · · 6 min read Dijkstra's algorithm finds shortest paths by exploring uniformly outward; A* reaches the same answer faster by using a heuristic to aim at the goal.
The Lycoris Team · · 4 min read A skip list is a layered linked list with shortcut pointers giving O(log n) search, insert, and delete — a simpler alternative to balanced trees.
The Lycoris Team · · 5 min read Greedy algorithms commit to the locally best choice at each step; dynamic programming weighs every subproblem. When each one actually works.
The Lycoris Team · · 4 min read Red-black and AVL trees both keep binary search trees balanced, but trade off rebalancing cost against lookup speed differently. How each works.
The Lycoris Team · · 4 min read A finite state machine models a system as a fixed set of states and the transitions between them. How FSMs work and where they show up in real software.
The Lycoris Team · · 4 min read An LRU cache evicts the least recently used item first when it runs out of room, keeping the most useful data in memory. Here's how it's built.
The Lycoris Team · · 4 min read A B-tree is a self-balancing tree that keeps data sorted with logarithmic search, insert, and delete time — the structure behind most database indexes.
The Lycoris Team · · 5 min read Quicksort and mergesort are the two classic O(n log n) sorting algorithms — how they differ in memory use, stability, and worst-case behavior.
The Lycoris Team · · 5 min read Graphs model networks of connected nodes; BFS and DFS are the two core ways to traverse them. How each works, and which to reach for.
The Lycoris Team · · 4 min read Stacks remove the most recent item first (LIFO); queues remove the oldest first (FIFO). How each works, their operations, and where they show up.
The Lycoris Team · · 4 min read A trie stores strings by sharing common prefixes across tree branches, making prefix lookups and autocomplete fast. How it compares to hash tables and BSTs.
The Lycoris Team · · 4 min read A heap is a tree-based structure that keeps the smallest or largest element at the root, enabling priority queues and heap sort in logarithmic time.
The Lycoris Team · · 5 min read A Bloom filter is a compact data structure that tests whether an item might be in a set, using far less memory than storing the set itself.
The Lycoris Team · · 4 min read A linked list stores elements as nodes linked by pointers rather than contiguous memory, trading fast random access for cheap insertion and removal.
The Lycoris Team · · 4 min read Dynamic programming solves complex problems by breaking them into overlapping subproblems and caching results, avoiding redundant recomputation.
The Lycoris Team · · 4 min read A binary search tree keeps every left descendant smaller and every right descendant larger than its parent. How lookups, inserts, and balance work.
The Lycoris Team · · 4 min read A hash table maps keys to array slots with a hash function for near O(1) lookups. How hashing, collisions, and resizing actually work under the hood.
