Tagged articles
Hash Table
92 articles · Page 1 of 1
An interviewer's comprehensive breakdown of LeetCode Two Sum, revealing why the check-then-put pattern prevents self-matching, how HashMap achieves O(1) lookup via hash perturbation and red-black trees, and engineering optimizations like pre-allocation and overflow protection.
Algorithm OptimizationEngineering PracticesHash Table
0 likes · 32 min read


liandkSep 1, 2026 · Fundamentals
This article explains how hash tables achieve near‑constant‑time lookups by hashing keys to direct storage slots, compares their speed to arrays, linked lists, stacks, and queues, shows real‑world uses, demonstrates a full Python implementation, and warns about common pitfalls.
Data StructuresHash TablePython
0 likes · 7 min read

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.
Data StructuresHash TableLinked List
0 likes · 6 min read

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.
B-TreeHash TableMySQL
0 likes · 9 min read

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.
B+ TreeDatabase IndexesHash Table
0 likes · 9 min read

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.
Hash TableLRU cachealgorithm interview
0 likes · 11 min read

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.
AlgorithmHash Tableleetcode-398
0 likes · 8 min read

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.
B-TreeData StructuresDatabase Indexes
0 likes · 10 min read

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.
Hash TableJavaLRU cache
0 likes · 10 min read

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.
GoHash TableJSON
0 likes · 10 min read

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.
Data StructuresHash TableSWIFT
0 likes · 27 min read

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.
Data StructuresHash TableSWIFT
0 likes · 26 min read

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.
AlgorithmHash TableLeetCode
0 likes · 9 min read

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.
B-TreeDatabase IndexesHash Table
0 likes · 9 min read

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.
Hash TableNVMeRecommendation System
0 likes · 19 min read

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.
CASConcurrentHashMapHash Table
0 likes · 36 min read

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.
DorisFlinkHash Table
0 likes · 16 min read

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.
Go mapHash Tableopen-addressing
0 likes · 17 min read

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.
Hash Tablecollision-resolutionhash function
0 likes · 5 min read

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.
Extendible HashingGoHash Table
0 likes · 13 min read

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.
Hash TablePythondict
0 likes · 12 min read

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.
ADDCOPYHash Table
0 likes · 30 min read

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.
CPythonData StructuresHash Table
0 likes · 18 min read

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.
Hash TableMemory ManagementPython
0 likes · 12 min read

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.
ConcurrencyData StructuresHash Table
0 likes · 6 min read

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.
Hash TableSimulationcoding interview
0 likes · 15 min read

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.
CPythonData StructuresHash Table
0 likes · 24 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 languageHash TablePython
0 likes · 20 min read

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.
Data StructuresHash TablePython
0 likes · 9 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.
Hash Tablecapacitycollision-resolution
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.
Hash Tablecapacitycollision-resolution
0 likes · 9 min read

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.
Hash TableRedisRehash
0 likes · 7 min read

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.
EpollHash TableIncremental Rehash
0 likes · 7 min read

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.
Hash TableLinked Listarrays
0 likes · 8 min read

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.
1BRCConcurrencyHash Table
0 likes · 20 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.
Data StructuresHash Tablechaining
0 likes · 13 min read

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.
Distributed SystemsHash TableMessage Indexing
0 likes · 16 min read

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.
Data StructuresHash TableHashMap
0 likes · 13 min read

This article explains how to implement an O(1) LRU cache in Go by combining a hash table with a doubly linked list, detailing the put and get operations, eviction policy, and providing complete, ready‑to‑run source code along with illustrative diagrams.
Cache EvictionData StructuresGo
0 likes · 4 min read

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.
AlgorithmsDynamic ProgrammingHash Table
0 likes · 8 min read

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.
CRUDHash TablePython
0 likes · 13 min read

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.
Data StructuresHash TableListpack
0 likes · 49 min read

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.
CollisionData StructuresHash Table
0 likes · 4 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.
Data StructuresHash Tablechaining
0 likes · 3 min read


政采云技术Oct 18, 2022 · Databases
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.
Data StructuresHash TableRedis
0 likes · 12 min read

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.
Data StructuresGoHash Table
0 likes · 21 min read


ITPUBJul 6, 2022 · Databases
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.
Data StructuresHash TableLinked List
0 likes · 17 min read

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.
C++Data StructuresHash Table
0 likes · 18 min read

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.
Front-end ArchitectureHash TablePerformance Optimization
0 likes · 16 min read


ITPUBJun 3, 2022 · Backend Development
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.
Data StructuresHash TableRedis
0 likes · 45 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.
Data StructuresHash Tablechaining
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.
Data StructuresHash TablePython
0 likes · 13 min read

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.
Data StructuresHash TableListpack
0 likes · 43 min read

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.
AlgorithmC++Hash Table
0 likes · 8 min read

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.
Data StructuresHash TableList
0 likes · 13 min read

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.
Data StructuresHash TableList
0 likes · 12 min read

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.
BitmapBloom filterData Structures
0 likes · 15 min read

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.
Hash TablePythondata structure
0 likes · 5 min read

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.
B16Hash TableSIMD
0 likes · 15 min read

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.
Data StructuresDijkstraGraph Algorithms
0 likes · 16 min read

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.
DijkstraGraphHash Table
0 likes · 16 min read

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.
Data StructuresHash TableIO Multiplexing
0 likes · 20 min read

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.
Data StructuresHash TableI/O multiplexing
0 likes · 20 min read

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.
Hash TableI/O multiplexingRedis
0 likes · 19 min read

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.
B16C++Data Structures
0 likes · 17 min read

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.
Data StructuresHash TableImmutable Objects
0 likes · 9 min read

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.
Data StructuresDatabase IndexingHash Table
0 likes · 10 min read

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.
Data StructuresHash TableRehash
0 likes · 11 min read

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.
DBLEHashHash Table
0 likes · 8 min read

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.
AlgorithmsComplexityData Structures
0 likes · 20 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.
Hash TableHashMapJava
0 likes · 11 min read

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.
Data StructuresHash TableLinked List
0 likes · 12 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.
AlgorithmHash Tablecollision-resolution
0 likes · 16 min read

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.
CollisionHash TableO(1) lookup
0 likes · 5 min read


ITPUBMar 25, 2020 · Fundamentals
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.
Data StructuresGraphHash Table
0 likes · 13 min read

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.
ConcurrentHashMapData StructuresHash Table
0 likes · 23 min read

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.
Hash TableInnoDBMini-transaction
0 likes · 23 min read

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.
Data StructuresHashHash Table
0 likes · 8 min read

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.
Data StructuresHash TableRedis
0 likes · 14 min read

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.
C++Hash TableMemory Management
0 likes · 26 min read

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.
Hash TableRedisRehash
0 likes · 6 min read

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.
C++Database InternalsHash Table
0 likes · 8 min read

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.
C++Data CompressionHash Table
0 likes · 13 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.
Data StructuresHash TableJavaScript
0 likes · 10 min read

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.
AlgorithmDOMHash Table
0 likes · 20 min read

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.
Hash TablePythonc-implementation
0 likes · 8 min read


ITPUBApr 27, 2017 · Fundamentals
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.
GraphHash TableLinked List
0 likes · 9 min read


ITPUBApr 23, 2017 · Fundamentals
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.
AlgorithmsData StructuresHash Table
0 likes · 9 min read

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.
Algorithm ComplexityData StructuresHAMT
0 likes · 12 min read

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.
Hash TableLinux kernelconnection tracking
0 likes · 16 min read


ITPUBSep 5, 2016 · Databases
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.
Database InternalsEnqueueHash Table
0 likes · 11 min read


21CTONov 15, 2015 · Backend Development
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.
BackendHash Tableopcode
0 likes · 16 min read
