#datastructures

1d ago · 5 min read · TL;DR: When I'm building high-traffic chat systems, a standard list lookup for profanity is too slow because search time grows with the size of the dictionary. I use a Trie (prefix tree) to move to O(

Join discussion

DSDoogal Simpsondoogal.dev

0

Why Your Linked List Wants to Be a Bloody Tree

1d ago · 5 min read · Quick Answer: A linked list hits a wall when searching because it’s stuck in linear O(n) time. By giving every node two pointers instead of one, you create a Binary Search Tree (BST). This wacky struc

Join discussion

DSDoogal Simpsondoogal.dev

0

32-Element Branching: How Scala Vectors Solve Immutable Memory Pressure

3d ago · 5 min read · TL;DR: Traditional immutable arrays are slow because updating an element requires a full O(n) copy. Scala’s Vector solves this by using a 32-way branching trie. This enables structural sharing, allowi

Join discussion

DSDoogal Simpsondoogal.dev

0

Why the Ring Buffer is the Foundation of High-Performance Systems

3d ago · 5 min read · TL;DR: Array-based queues are often dismissed due to O(n) shifting costs, but the ring buffer circumvents this by using wrapping head and tail pointers. This design provides O(1) access and superior c

Join discussion

DSDoogal Simpsondoogal.dev

0

Your Undo Button is Just a Stack of Pancakes

5d ago · 5 min read · TL;DR: I implement undo functionality using a Stack data structure because it follows the Last-In-First-Out (LIFO) principle. Each state change is pushed onto the stack. When I trigger an undo, I pop

Join discussion

DSDoogal Simpsondoogal.dev

0

Why Dynamic Arrays Aren't Actually Dynamic

Mar 7 · 5 min read · TL;DR: Standard arrays are fixed-size by design to ensure O(1) access. Dynamic arrays manage this constraint by over-allocating memory and periodically resizing. By growing the backing array geometric

Join discussion

DSDoogal Simpsondoogal.dev

0

Why Removing the Head of Linked List is Constant Time

Mar 6 · 5 min read · TL;DR: A linked list is a chain of nodes where each element knows its neighbor's location. While searching for an element takes O(n) time because you must jump through every preceding link, removing t

Join discussion

DSDoogal Simpsondoogal.dev

0

The Pointer Arithmetic of Constant Time: Why Arrays Scale O(1)

Mar 5 · 5 min read · TL;DR: Array indexing is O(1) because it relies on a single pointer calculation: base_address + (index * element_size). Since arrays use contiguous memory allocation, the CPU uses the base register an

Join discussion

DSDoogal Simpsondoogal.dev

0

Preventing Stack Overflows: Why Base Case Placement is Critical

Mar 1 · 5 min read · TL;DR: I use recursion to solve complex nested problems, but every call pushes a new frame onto the stack. To avoid memory exhaustion and application crashes, I must implement a base case—a conditiona

Join discussion

SRSreekar Reddyesreekarreddy.hashnode.dev

0

🎢 Queues Explained Like You're 5

Feb 2 · 1 min read · A line at an amusement park Day 39 of 149 👉 Full deep-dive with code examples The Amusement Park Line You're in line for a roller coaster: [Exit] ← Person 1 ← Person 2 ← Person 3 ← [Entrance] First person in line → First to ride! First In, First Ou...

Join discussion

Tag feed

Tag feed

#datastructures

Scaling Profanity Filters: Why I Use Tries for Real-Time Chat

Why Your Linked List Wants to Be a Bloody Tree

32-Element Branching: How Scala Vectors Solve Immutable Memory Pressure

Why the Ring Buffer is the Foundation of High-Performance Systems

Your Undo Button is Just a Stack of Pancakes

Why Dynamic Arrays Aren't Actually Dynamic

Why Removing the Head of Linked List is Constant Time

The Pointer Arithmetic of Constant Time: Why Arrays Scale O(1)

Preventing Stack Overflows: Why Base Case Placement is Critical

🎢 Queues Explained Like You're 5

#datastructures

Search Hashnode

#datastructures

Scaling Profanity Filters: Why I Use Tries for Real-Time Chat

Why Your Linked List Wants to Be a Bloody Tree

32-Element Branching: How Scala Vectors Solve Immutable Memory Pressure

Why the Ring Buffer is the Foundation of High-Performance Systems

Your Undo Button is Just a Stack of Pancakes

Why Dynamic Arrays Aren't Actually Dynamic

Why Removing the Head of Linked List is Constant Time

The Pointer Arithmetic of Constant Time: Why Arrays Scale O(1)

Preventing Stack Overflows: Why Base Case Placement is Critical

🎢 Queues Explained Like You're 5