This article introduces seven fundamental data structures—arrays, queues, stacks, linked lists, trees, graphs, and hash tables—explaining their concepts, typical use cases, strengths, and limitations to help developers choose the right tool for efficient program design.
This article explains MySQL index fundamentals, covering what indexes are, their advantages and drawbacks, underlying data structures such as hash tables and B‑/B+‑trees, and the classification of clustered, non‑clustered, primary, secondary, unique, prefix, and full‑text indexes, with practical SQL examples and diagrams.
This article explains the fundamentals of database indexing, covering what indexes are, their advantages and drawbacks, underlying structures such as hash tables, B‑tree and B+‑tree, different index types (clustered, non‑clustered, primary, secondary) in MySQL, and practical examples with code snippets.
This article explains why caching is crucial, walks through the classic interview question of implementing an O(1) LRU cache, and provides a complete Python solution using a hash table combined with a doubly linked list, including complexity analysis, common pitfalls, and alternative approaches.
This article explains LeetCode problem 398—Random Pick Index—detailing two solutions: a hash‑map preprocessing method for fixed arrays and a reservoir‑sampling approach for streaming data, complete with Java, C++, and Python implementations and complexity analysis.
This article explains the fundamentals of database indexes, covering what indexes are, their underlying structures such as B‑Tree, B+‑Tree and hash tables, their advantages and drawbacks, and the various index types—including primary, secondary, clustered and non‑clustered—used in MySQL engines.
This article explains the LRU cache eviction strategy, details its O(1) get and put operations using a combined hash table and doubly linked list, and provides a complete Java implementation with step‑by‑step code examples and design rationale.
This article explores Go's map type in depth, covering its underlying hash table mechanics, key requirements, concurrency considerations, and a comprehensive set of practical techniques—including existence checks, JSON conversion, sorting, slicing, multi-dimensional maps, and real-world examples for analytics and log processing.
This article dives deep into Swift's Dictionary implementation, explaining its underlying hash‑table structure, memory layout, bucket calculation, probing strategies, copy‑on‑write semantics, performance optimizations, and conflict‑resolution techniques, all illustrated with real source code and debugging screenshots.
This article dives deep into Swift's Dictionary implementation, explaining its underlying hash‑table structure, memory layout, variant storage, probing strategies, copy‑on‑write semantics, conflict resolution, load‑factor handling, and automatic resizing, all illustrated with real code and debugger screenshots.
The article reflects on the challenges of choosing college majors and then provides a comprehensive solution to LeetCode problem 1640, detailing the problem statement, examples, and multiple language implementations using sorting, binary search, and hash‑table techniques.
This article explains the fundamentals of database indexes, covering their purpose, underlying data structures such as B‑Tree, B+‑Tree, and hash tables, the advantages and drawbacks, different index categories in MySQL, and practical SQL examples for primary, secondary, and unique indexes.
To meet the ultra‑low latency demands of modern recommendation systems, the authors designed a distributed batch‑query architecture featuring the NeighborHash optimization—a cache‑line‑aware hash table that reduces memory accesses, combined with NVMe‑backed storage and AMAC techniques, achieving high throughput and near‑optimal bandwidth utilization.
This article provides an in‑depth analysis of the Java ConcurrentHashMap implementation, covering its constructor logic, hash‑table sizing, the core put and get operations, element counting with addCount, multi‑threaded resizing via transfer, treeification of bins, removal, computeIfAbsent, and the design choices that forbid null keys and values to simplify concurrency handling.
This article presents a lightweight algorithm service solution that combines an offline pre‑computed tag knowledge base with a real‑time data warehouse using Flink, Doris, Hive SQL and Python to achieve short development cycles, agile iteration, low cost, and scalable deployment for classification and clustering tasks.
This article traces the evolution of hash tables from early chain‑based designs to modern open‑addressing Swiss Table implementations, explains Go 1.24’s map redesign with groups, control words, and SIMD tricks, and examines the challenges of incremental growth, iteration semantics, and future performance improvements.
This article explains the fundamentals of hash tables, covering their definition, advantages, core concepts like hash functions and collision resolution, practical Python dictionary usage with code examples, and common application scenarios such as fast look‑ups, frequency counting, and deduplication.
This article examines Go 1.24’s new Swiss map implementation, covering its compatibility with the legacy map, the extendible hashing mechanism that enables incremental expansion, performance improvements, and remaining challenges such as concurrency limits and memory fragmentation.
This article explains Python's dict, set, and frozenset containers, lists their most frequently used methods, demonstrates how to subclass dict and create a container class, and describes the hash‑table implementation details that give these data structures their high performance.
This article dissects Python’s built‑in set type, explaining how add, pop, remove, copy, update, union and other set operations map to low‑level C functions, how the hash table handles collisions, dummy entries, resizing, and the finger optimization that speeds up element removal.
This article explains Python's set type, covering its typical use cases, core API methods, and a deep dive into the CPython C implementation—including the PySetObject layout, hash table mechanics, field behavior, and differences from dictionaries.
The article explains Python's dict resizing mechanism, detailing when the hash table grows (when used entries reach two‑thirds of capacity), how the new size is chosen as the smallest power‑of‑two ≥ ma_used × 3, and the exact steps the interpreter takes to reallocate and rebuild the underlying key and entry arrays.
This article explains Java's HashMap implementation, covering its bucket array, linked‑list and red‑black tree handling, hash function perturbation, dynamic resizing, and thread‑safety considerations, providing code examples and diagrams for clear understanding.
This article presents four algorithmic interview problems covering travel scheduling with priority constraints, optimal homework task ordering, maximizing distinct garden beauty scores after a single flip operation, and reconstructing insertion sequences for a linear‑probing hash table, each with detailed analysis, solution ideas, and reference Python code.
This article dissects Python's dictionary implementation, explaining the PyDictObject layout, the combined and split hash‑table designs, memory‑optimisation techniques, insertion and lookup processes, ordered iteration, and precise memory‑size calculations with concrete code examples.
The article explains how Python maps a dict key to a hash‑table slot, the two classic collision‑resolution strategies (separate chaining and open addressing), why Python uses an iterative probing function, and walks through the core C functions that perform the lookup and slot‑finding logic.
The article explains how Python's dict uses a hash table to provide constant‑time insertion, deletion, and lookup, demonstrates its speed advantage over lists with benchmarks, and details the handling of collisions, resizing, and the underlying array‑based implementation.
A whimsical yet technical dialogue among Go, C++, Python, Java, and C# representatives reveals the storage structures, collision‑resolution strategies, hash‑to‑index mapping techniques, and resizing policies used in their hash table implementations, highlighting trade‑offs and design choices.
An imaginative conference narrates how various programming language implementations—Go's map, C++'s unordered_map, Java's HashMap, Python's dict, and C#'s HashTable—discuss storage structures, collision‑resolution strategies, hash‑to‑index mapping, and initial capacity and resizing policies, highlighting their differing algorithms and trade‑offs.
Redis achieves its remarkable speed through in‑memory storage, an efficient hash table design, single‑threaded execution that eliminates context switches, epoll‑based I/O multiplexing, progressive rehashing, and cached timestamps, all of which together enable near O(1) operations and minimal latency.
This article explains why Redis achieves exceptional speed by leveraging in‑memory storage, an efficient hash‑table data structure, a single‑threaded event loop, epoll I/O multiplexing, incremental rehashing, and cached timestamps, providing a comprehensive view of its performance optimizations.
Explore the seven core data structures—arrays, queues, stacks, linked lists, trees, graphs, and hash tables—detailing their real‑world analogies, typical use cases, strengths, and drawbacks, so you can choose the right structure for efficient, reliable software design.
This article walks through nine progressively faster Go implementations for the One Billion Row Challenge, detailing baseline measurements, map optimizations, custom parsing, integer arithmetic, scanner removal, custom hash tables, and parallel processing that ultimately reduce processing time from 1 minute 45 seconds to under 4 seconds.
This article explains the concept of hashing and hash tables, describes their characteristics and common collision‑resolution strategies such as open addressing, linear and quadratic probing, chaining, and rehashing, and provides complete Python implementations including a simple hash class, a dynamic map class, and a custom dictionary.
This article explains RocketMQ's random indexing mechanism, detailing its on‑disk three‑segment hash table structure, the compact format conversion process, multi‑threaded write and query workflows, layered system design, crash‑recovery strategy, and comparisons with RocksDB and InnoDB storage engines.
This article walks you through the fundamentals of hash tables, explains bucket arrays and hash functions, discusses collision resolution strategies, and provides a complete Java implementation of a simple HashMap called ThirdHashMap with code, tests, and performance notes.
This article reviews essential data structures such as arrays, linked lists, stacks, queues, hash tables, and trees, explains their characteristics and trade‑offs, and introduces fundamental algorithm categories including sorting, searching, greedy, divide‑and‑conquer, and dynamic programming, with useful visualization links.
This article explains what Python dictionaries are, how they are implemented using hash tables, their key characteristics, various ways to create and access them, how to perform add, delete, and update operations, view their contents, and use dictionary comprehensions for concise construction.
This article explains how Redis achieves high performance by storing data in memory and using a variety of specialized data structures—such as SDS, quicklist, listpack, hash tables, and skip lists—to implement its key‑value store, covering their designs, trade‑offs, and evolution across Redis versions.
This article explains how hash tables store key‑value pairs as array entries, describes hash collisions when different keys map to the same index, and outlines two common resolution methods—open addressing and chaining—while also providing visual illustrations and practical insights.
This article explains the fundamentals of hash tables, how they store key‑value pairs, the nature of hash collisions, and the two primary resolution strategies—open addressing and chaining—illustrated with clear examples and diagrams.
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 provides a comprehensive analysis of Go's map implementation, covering its hash‑table foundation, key type constraints, hash function characteristics, collision resolution strategies, runtime initialization, internal structures like hmap and bmap, and the various operations for creation, access, update, deletion, and resizing.
This article explores Redis’s internal data structures—including simple dynamic strings, linked lists, and dictionaries—detailing their encoding constants, implementation differences across versions, performance advantages, and rehashing mechanisms that enable high‑throughput, memory‑efficient operations.
The article details Redis’s core low‑level data structures—Simple Dynamic Strings (SDS) with length‑aware headers, a custom doubly linked list for O(1) head/tail access, and a hash‑table dictionary employing MurmurHash, incremental rehashing, and packed headers to optimize memory and performance across versions.
The article presents Tubes, Alibaba’s high‑performance terminal renderer, and argues that a hash‑table‑based reactive data system—tracking dependencies, triggering updates only for changed inputs, and making Tubes idempotent—eliminates manual loop control, reduces developer burden, and delivers up to 1,350× read speed‑up and hundreds of milliseconds faster first‑screen rendering on low‑end devices.
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 basic structure of hash tables, how keys are mapped to array indices, the problem of hash collisions, and two common resolution strategies—open addressing and chaining—illustrated with diagrams and a concise summary.
This article explains the concept of hashing and hash tables, describes their characteristics and collision‑resolution strategies, showcases practical Python implementations with load‑factor handling and resizing, and highlights common applications such as dictionaries and network session tables.
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 introduces the classic Two Sum problem, explains its brute‑force O(n²) approach, then presents an optimal O(n) hash‑table solution and a more advanced sort‑plus‑binary‑search method, providing complete C++ implementations and performance comparisons for each technique.
This article compares the lookup speed of Python lists and sets on large datasets, presents benchmark code and results, and explains why sets are dramatically faster by examining the internal C‑level implementations of list (dynamic array) and set/dict (hash table) including resizing rules and collision‑resolution strategies.
This article benchmarks Python list versus set lookups on large datasets, explains why sets are dramatically faster, and delves into the internal C‑level implementations of list as a dynamic array and set/dict as hash tables, including resizing rules and collision handling.
The article explains how to quickly determine whether an integer exists among ten million numbers by comparing hash tables, boolean arrays, bitmaps, and Bloom filters, and shows practical Java and Redis implementations with code examples and memory‑usage analysis.
The article explains that Python dictionaries are hash tables with average O(1) lookup, describes how their internal structure changed in Python 3.6 to separate indices and entries, resulting in ordered iteration and significant memory savings.
This article introduces the B16 hash table, a novel design that deliberately tolerates a higher hash‑collision probability and leverages SIMD instructions to achieve faster lookups, lower memory overhead, and a compact read‑only variant comparable to minimal perfect hash functions.
This article introduces core data structures—hash tables, heaps, and graphs—explains their definitions, visual representations, and key operations, then delves into fundamental graph algorithms such as BFS, Dijkstra, Floyd, minimum spanning trees, and topological sorting, illustrating each with examples and code.
This article introduces core data structures—hash tables, heaps, and graphs—explains their definitions, typical applications, and key algorithms such as shortest‑path (BFS, Dijkstra, Floyd), minimum spanning tree (Prim, Kruskal), and topological sorting, and provides a complete Java implementation of Dijkstra.
This article explains why Redis achieves exceptionally high performance by combining pure in‑memory operations, a global hash table with O(1) lookups, efficient data structures such as SDS, ziplist, quicklist and skiplist, a single‑threaded event loop with non‑blocking I/O multiplexing, and adaptive encoding strategies.
This article explains why Redis achieves exceptional speed by examining its memory‑only architecture, single‑threaded event loop, and the specialized data structures—global hash tables, SDS strings, ziplist, quicklist, skiplist, and intset—that provide O(1) or O(log N) operations, along with non‑blocking I/O multiplexing.
This article explains why Redis is exceptionally fast by detailing its in‑memory design, global hash table with O(1) lookups, incremental rehashing, specialized data structures such as SDS, ziplist, quicklist, skiplist and intset, as well as its single‑threaded event loop and epoll‑based I/O multiplexing.
This article revisits traditional hash table design, then introduces a novel approach that deliberately leverages a controlled probability of hash collisions combined with SIMD parallelism, presenting the B16 and B16Compact hash tables, their structures, algorithms, and experimental results showing superior speed and space efficiency compared to unordered_map and F14.
This article explains Python’s built-in dict and set structures, comparing them with lists, demonstrating their fast key-value lookups, handling missing keys, and common operations like insertion, deletion, and set algebra, while providing clear code examples and practical tips for effective use.
This article explains MySQL's hash index by introducing fundamental data structures such as arrays, dictionaries, linked lists, and hash tables, discussing their advantages and disadvantages, and showing how they are used in MySQL with practical code examples.
This article explains why Redis is fast, describes its underlying data structures and how keys and values are stored using hash tables and hash buckets, discusses hash collisions and chain hashing, and details the progressive rehash mechanism that maintains performance as data grows.
This article explains the principles of hash tables, how hash functions are used for data sharding in distributed databases such as DBLE, compares hash‑modulo and consistent‑hash approaches, and discusses their advantages, limitations, and practical configuration tips.
This article provides a comprehensive introduction to fundamental data structures, core algorithm concepts, and classic sorting techniques, explaining their definitions, basic operations, time and space complexities, stability considerations, and practical use cases for developers seeking to strengthen their programming foundations.
This article explains why Java's HashMap adopts a default load factor of 0.75, describing the concept of load factor, various collision‑resolution strategies such as open addressing and chaining, and how Poisson‑distribution analysis justifies the 0.75 threshold as a balanced trade‑off between space utilization and lookup cost.
This article introduces eight fundamental data structures—arrays, linked lists, stacks, queues, hash tables, trees, heaps, and graphs—explaining their definitions, core operations, typical applications, and visual illustrations to help programmers master essential concepts for software development and technical interviews.
The article explains how limited hash spaces cause collisions, then compares open hashing (separate chaining) and closed hashing techniques—linear probing, double hashing, and random hashing—detailing their insertion, search, and deletion algorithms along with the performance trade‑offs and load‑factor analysis for each method.
This article explains how hashing transforms data lookup from linear or logarithmic time to constant O(1) time by using hash functions and hash tables, illustrates the concept with a simple modulo‑based example, and discusses load factor and collision issues.
This article introduces eight fundamental data structures—arrays, linked lists, stacks, queues, hash tables, trees, heaps, and graphs—explaining their definitions, core operations, typical applications, and key characteristics to help developers build a solid foundation.
This article explains the fundamentals of hash tables, compares their performance with arrays, linked lists, and binary trees, describes how Java's HashMap handles collisions using chaining and treeification, and details the evolution from JDK 7 to JDK 8, including the design of ConcurrentHashMap for thread safety.
This article explains how InnoDB uses REDO logs to recover a crashed MySQL database, detailing the steps of locating checkpoints, scanning log segments, parsing mini‑transactions, storing records in hash tables, and applying them to restore data consistency.
This article explains the concept of hash functions and hash tables, illustrates how they map data to array indices, discusses collision resolution methods, and details Redis's internal dictionary implementation, including zipmap optimization, operation complexities, and practical usage differences between hashes and sets.
This article explains how Redis relies on hash tables as the underlying dictionary structure for its databases and data types, detailing the dict layout, collision handling, progressive rehash algorithms, and the safe and unsafe iterator mechanisms used to traverse the hash table.
The article details how Redis’s incremental rehashing can double memory usage and trigger massive key eviction and scan inconsistencies in large‑scale clusters, explains the underlying dictionary structures, demonstrates the cursor bug when tables shrink, and presents a memory‑guard and scan‑cursor patch that resolves both problems.
This article explains how Redis uses a dual‑hashtable structure and a progressive rehash process to handle hash collisions, detailing the rehash conditions, migration steps, and performance implications for in‑memory key‑value storage.
This article explains Redis's dictionary structure, the conditions that trigger rehashing, the step‑by‑step incremental rehash process, and provides the core C implementation code, illustrating how Redis maintains high performance while resizing its hash tables.
This article recounts a 2017 internal high‑performance competition where a C server handling a 40 million‑row user‑info dataset was progressively optimized through data compression, custom hash tables, memory layout redesign, and a thread‑pool model, ultimately achieving a four‑fold throughput increase.
This article explains the fundamentals of hash tables, covering their basic concepts, construction methods, various collision‑resolution techniques such as open addressing and chaining, and compares several widely used hash functions with performance insights.
This article explores how to implement recursive and non‑recursive DOM tree searches, hash‑based lookups, and several classic sorting algorithms—including quick sort and merge sort—in JavaScript, discussing their time and space complexities, stability considerations, and practical performance tips for front‑end development.
This article explains how Python implements dictionaries with hash tables, details the hash function for strings, demonstrates collision handling via open addressing and quadratic probing, and walks through the underlying C structures, initialization, insertion, resizing, and deletion processes.
An extensive overview of fundamental data structures—including linked lists, stacks, queues, various tree types, binary search trees, tries, binary indexed trees, segment trees, heaps, hash tables, and graphs—covers definitions, characteristics, time complexities, and visual illustrations to aid understanding and practical implementation.
This comprehensive guide explains fundamental data structures—including linked lists, stacks, queues, various tree types, binary indexed trees, segment trees, heaps, hash tables, and graphs—detailing their definitions, variants, typical operations, and time‑complexity characteristics for efficient algorithm design.
This article explores two fundamental implementations of the HashMap data structure, comparing traditional Hash Tables with Hash Array Mapped Tries (HAMT), while analyzing their collision resolution strategies, hash functions, time and space complexities, and practical applications in modern programming languages like Ruby and functional paradigms.
This article analyzes the nf_conntrack table‑full issue encountered during high‑concurrency OpenStack upgrades, explains how connection tracking works and is stored in a hash table, and provides practical parameter and iptables adjustments to improve memory usage and lookup performance.
This article explains how Oracle protects shared resources with enqueue queues, details the naming of TM queue locks per table, describes the resource structure (KSQRS) that tracks owners, waiters and converters, and shows how hash tables and related parameters manage these structures efficiently.
This article demystifies PHP’s internal architecture, covering its design philosophy, four‑layer system, SAPI interfaces, execution flow with opcodes, the Zend hash table, variable handling via zval, reference counting, and resource management, providing a comprehensive guide for backend developers.
