This article explains Redis Sorted Set’s underlying implementation using skiplist and listpack, compares their storage strategies, and demonstrates how to build a real‑time game leaderboard with practical command examples and score calculations.
This article explains the Redis Sorted Set data type, its underlying storage mechanisms (listpack and skiplist + dict), the internal structures and algorithms, and demonstrates how to build a real‑time game leaderboard using ZADD, ZRANGE and ZREVRANK commands.
This article explains how Redis stores set and sorted‑set objects using dual encodings—intset vs hashtable for sets and skiplist vs ziplist for sorted sets—detailing their internal structures, upgrade mechanisms, configuration thresholds, and the essential commands for manipulating these data types.
The article explains Redis’s set and sorted‑set data structures, detailing how sets use intset or hashtable encodings and how sorted sets employ skiplist or ziplist encodings, including the conditions for each encoding, the underlying C structs, upgrade processes, and common Redis commands.
The article explains the structural differences between B+ trees and skip lists, compares their read‑write performance in MySQL and Redis, and shows why MySQL prefers B+ trees while Redis adopts skip lists for its in‑memory ZSET implementation.
This article compares B+ trees and skip lists, explaining their structures, insertion and search complexities, and why MySQL chooses B+ trees for disk‑based indexing while Redis prefers skip lists for in‑memory sorted sets, highlighting trade‑offs in read/write performance and I/O costs.
This article explains Redis's superior performance by detailing its six underlying data structures—Simple Dynamic Strings, hash tables, ziplist, quicklist, skiplist, and integer sets—covering their implementations, memory optimizations, collision handling, and lookup complexities, with code examples and diagrams.
This article explains how Redis stores set and sorted‑set objects using two underlying data structures, details the intset and hashtable encodings, describes the upgrade process with concrete examples, and lists the common commands for manipulating these collections.
This article explains why Redis stores set and sorted‑set objects using two different internal encodings, describes the intset and hashtable representations for sets, the skiplist and ziplist representations for sorted sets, shows the upgrade process with code examples, and lists the common commands for manipulating these data structures.
This article explains how Redis internally stores set and sorted‑set objects using intset, hashtable, ziplist, and skiplist encodings, the conditions that trigger each representation, the upgrade process, and the essential Redis commands for manipulating these data structures.
The article explains Redis’s internal low‑level structures—ziplist, skiplist, intset, quicklist, zipmap, and stream—detailing their memory‑efficient layouts, operations, use cases, and how they combine (e.g., quicklist merging linked lists with ziplists) to deliver high performance in the in‑memory database.
This article explains why Redis is ultra‑fast by exploring its in‑memory design and the nine fundamental data structures—SDS, linked lists, ziplist, hash tables, skiplist, intset, quicklist, and listpack—that power keys, values, and internal objects, complete with code examples and version‑specific changes.
This article explains the structures of B+ trees and skip lists, compares their insertion and search behaviors, and shows why MySQL prefers B+ trees for disk‑based indexing while Redis adopts skip lists for in‑memory operations.
This article explains the structures of B+ trees and skip lists, compares their read and write performance, and details why MySQL chooses B+ trees for indexing while Redis and RocksDB prefer skip lists, highlighting trade‑offs in disk I/O, fan‑out, and balancing overhead.
This article explains how Redis stores Set and Sorted Set objects using dual internal representations—intset and hashtable for sets, skiplist and ziplist for sorted sets—detailing their structures, encoding selection criteria, upgrade processes, command usage, and the reasons behind combining dictionaries with skiplists for optimal performance.
This article explains how Redis achieves high performance by using specialized in‑memory data structures such as SDS, quicklist, listpack, hash tables, skip‑lists and integer sets, detailing their design, evolution across versions, memory‑efficiency tricks, and the trade‑offs that make Redis a lightning‑fast key‑value store.
This article explains how Redis implements its Sorted‑Set data type by starting from a basic ordered singly linked list, analyzing its insertion and query complexities, introducing the skiplist structure, deriving its O(log N) performance, and detailing the underlying C source code for creation, insertion, lookup, and deletion.
This article explains how Redis implements its Sorted‑Set using a skiplist, starting with the basics of a singly linked list, analyzing insertion and query complexities, deriving the skiplist structure and its O(log N) performance, and comparing it with hash tables, balanced trees, and B‑trees.
This article explains the role and data structure of Memtable in LevelDB, introduces the probabilistic SkipList design, analyzes its time and space complexities, and provides a full Java implementation of a SkipListMap with code examples and a brief look at LevelDB's own SkipList implementation.
Redis sorted sets (zsets) combine a hash table with a skiplist that provides O(log N) search, insertion, and deletion, using forward, backward, and span pointers to maintain element order and rank, enabling fast score‑based queries, leaderboards, and range operations via commands such as ZADD, ZRANK, and ZRANGE.
The article systematically explains how HBase's MemStore uses a SkipList‑based model and introduces successive memory‑management optimizations—MemStoreLAB, ChunkPool, off‑heap chunks, CompactingMemStore and the CCSMap data structure—to reduce object overhead, GC pressure and improve throughput.
This article explains the internal implementations of Redis’s five major data structures—simple dynamic strings (SDS), linked lists, dictionaries, skiplists, integer sets, and ziplists—detailing their definitions, memory layouts, key characteristics, and how Redis leverages them for high‑performance storage and retrieval.
This article explains the SkipList data structure, its characteristics and operations, and shows how Java’s ConcurrentSkipListMap implements a thread‑safe map using SkipList nodes, index layers, random level generation, and lock‑free algorithms for put, get, remove and size operations.
This article examines WiredTiger’s novel data‑organization design, its in‑memory page and disk‑extent structures, skiplist‑based insert handling, MVCC update lists, compression mechanisms, and performance test results, providing practical configuration advice for MongoDB deployments.
