Tagged articles
collision-resolution
16 articles · Page 1 of 1
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.
collision-resolutionhash functionhash table
0 likes · 5 min read

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.
C languagePythoncollision-resolution
0 likes · 20 min read

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.
capacitycollision-resolutiondata structure
0 likes · 9 min read

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.
capacitycollision-resolutionhash function
0 likes · 9 min read

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.
chainingcollision-resolutiondata structures
0 likes · 13 min read

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.
chainingcollision-resolutiondata structures
0 likes · 3 min read

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.
chainingcollision-resolutiondata structures
0 likes · 3 min read

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.
Pythoncollision-resolutiondata structures
0 likes · 13 min read

This article explains Java HashMap's internal structure, including the array‑linked list and red‑black tree design, load factor, collision resolution methods, resizing process, key selection, thread‑safety concerns, and the hash calculation algorithm, providing detailed insights for developers.
HashMapJDKJava
0 likes · 17 min read

This article explains the purpose of HashMap's load factor, the trade‑offs between space utilization and collision probability, describes common collision‑resolution techniques such as open addressing, rehashing and chaining, and shows why the default load factor of 0.75 is chosen based on Poisson‑distribution analysis.
HashMapJavaPoisson distribution
0 likes · 12 min read

This article explains the purpose of HashMap's load factor, why the default value is 0.75, and describes various collision‑resolution techniques such as open addressing, linear and quadratic probing, rehashing, overflow areas, and chaining, supported by code examples and a Poisson‑distribution analysis.
HashMapJavaPoisson distribution
0 likes · 11 min read

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.
HashMapJavaPoisson distribution
0 likes · 11 min read

This article explains why HashMap relies on a 0.75 load factor, how load factor balances space utilization and collision probability, the various collision‑resolution strategies, and the statistical reasoning—particularly Poisson distribution—that led to choosing 0.75 over other values.
HashMapJavacollision-resolution
0 likes · 12 min read

This article explains why Java's HashMap adopts a default load factor of 0.75, covering hash table basics, collision‑resolution strategies, the Poisson‑distribution analysis that justifies the value, and the trade‑offs between space efficiency and lookup performance.
HashMapJavacollision-resolution
0 likes · 11 min read

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.
Algorithmcollision-resolutiondouble hashing
0 likes · 16 min read

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.
JavaScriptcollision-resolutiondata structures
0 likes · 10 min read
