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 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 explores Redis, a high‑performance in‑memory key‑value store, detailing its core data types—String, List, Hash, Set, ZSet—the underlying structures such as SDS, quicklist, hashtable, and intset, and demonstrates practical usage patterns like caching, rate limiting, and inventory control.
This article reviews nine frequently asked Python interview questions, covering lists, tuples, dictionaries, string reversal, memory management, sessions, cookies, tokens, GET vs POST, decorators, concurrency concepts, comprehensions, and generators, providing concise explanations and code examples.
This article introduces the concept of trees and binary search trees, defines a C struct for tree nodes, and provides complete implementations for creating nodes, inserting, deleting, searching, finding min/max, computing size and height, as well as recursive and non‑recursive traversals including pre‑order, in‑order, post‑order and level‑order.
This article explains the binary heap data structure, its array representation, heap property maintenance via maxHeapify, construction of a max‑heap, heap sort algorithm, and the implementation of a max‑priority queue in C, including full source code and theoretical analysis.
This article provides an in‑depth overview of Redis, covering why it is used for performance and concurrency, its single‑threaded architecture, core data structures and their scenarios, expiration policies, memory eviction strategies, consistency challenges, and practical solutions for cache penetration, snowballing, and concurrent key updates.
This guide introduces Redis as a high‑performance key‑value store, covering its core data structures, advantages, persistence mechanisms, publish/subscribe model, transaction handling, and replication strategies with practical command examples.
This article provides a comprehensive, image‑rich tutorial on red‑black trees, covering their definition, five core properties, node naming conventions, rotation and recoloring operations, detailed search algorithms, step‑by‑step insertion and deletion cases with visual illustrations, and answers to thought‑provoking exercises.
This guide explains the principles of stack (LIFO) and queue (FIFO) data structures, demonstrates how to implement them in Python using classes with methods for push, pop, enqueue, dequeue, and provides complete example code for both stack.py and queue implementations.
This article provides a clear, illustrated introduction to red‑black trees, covering their definition, fundamental properties, binary search tree background, traversal methods, rotation and recoloring techniques, and detailed insertion scenarios with JavaScript code examples, preparing readers for further study of deletions.
This article explains the concept of graphs as data structures, covering vertices, edges, directed and undirected graphs, degrees, and demonstrates how to store graphs using adjacency matrices and adjacency lists, comparing their space and time trade‑offs with clear examples and illustrations.
This article provides a comprehensive overview of red‑black trees, covering the underlying concepts of binary trees, binary search trees, balanced trees such as AVL, the five red‑black properties, insertion and deletion algorithms with color changes and rotations, and a detailed Java TreeMap source‑code illustration.
This article explains how to dramatically reduce Redis memory consumption—by up to 90%—through converting long string keys to integers, leveraging zipList‑encoded hashes, and distributing millions of key‑value pairs across many hash buckets while maintaining query performance.
An in‑depth guide covering Redis fundamentals, installation steps, daemon configuration, password setup, core commands for strings, lists, hashes, sets and sorted sets, internal encodings, and both RDB and AOF persistence mechanisms, complete with practical code examples and configuration snippets.
This tutorial introduces Python lists, explaining their characteristics, how to create them, and covering the most common operations such as indexing, slicing, concatenation, repetition, membership testing, built‑in functions, and list methods with clear code examples.
This article explains the fundamentals of hash tables, dives deep into Java's HashMap implementation—including JDK7 source code analysis of its internal structures, resizing logic, and key methods—while also covering common interview questions such as why the array size must be a power of two and the necessity of overriding both equals and hashCode.
This article compiles essential Java backend interview topics, covering the differences between TreeSet and HashSet, HashMap collision handling and resizing, ConcurrentHashMap's lock strategy, thread pool creation, synchronization primitives like CountDownLatch and CyclicBarrier, database indexing, CAP theorem, idempotence, locking mechanisms, JVM GC roots, reflection, dynamic proxies, distributed locks, ThreadLocal optimization, and key considerations for designing a high‑traffic seckill system.
The author recounts a grueling ByteDance video interview, detailing technical questions on Django deployment, Nginx configuration, uWSGI internals, Redis fundamentals, heap data structures and quick‑sort coding, while sharing hard‑earned career advice for developers preparing for high‑stakes interviews.
This article explains the differences between Java's ArrayList and LinkedList, detailing their internal implementations, performance characteristics for adding, inserting, deleting, and iterating elements, and provides code examples and benchmark results to guide when to choose each collection.
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.
An interview-style dialogue explains the distinctions between TreeSet and HashSet, the underlying implementations of HashMap versus TreeMap, and how red‑black trees provide balanced performance, covering hash collisions, treeification, and thread‑safety considerations in Java collections.
This article explains how to dramatically speed up Python programs by improving algorithms, choosing the right data structures, optimizing loops, leveraging lazy evaluation, using efficient string operations, list comprehensions, profiling tools, and advanced accelerators such as PyPy and Cython.
This article provides a detailed comparison of Java's List interface implementations—ArrayList, LinkedList, Vector, and Stack—explaining their underlying data structures, key methods such as get, set, add, and remove, performance characteristics, thread safety, and appropriate usage scenarios.
This article explains why large numbers of active Python objects can cause memory problems and presents several techniques—including using dicts, class __slots__, namedtuple, recordclass, Cython, and NumPy—to shrink object size and dramatically lower memory consumption.
This article explains the differences between Java's HashMap and TreeMap, covering their underlying implementations, performance characteristics, ordering behavior, and how to use a custom comparator to achieve descending order, helping developers choose the appropriate map based on ordering and efficiency needs.
This article provides a comprehensive overview and source‑code dissection of Java's ArrayList, covering its inheritance hierarchy, fields, constructors, addition, removal, modification, traversal, serialization, sorting, array conversion, thread‑safety considerations, and practical usage tips.
This article provides a concise overview of Hulu's 2020 campus recruitment, including company FAQs, detailed descriptions of four programming problems with input/output specifications, sample cases, and step‑by‑step solution analyses to help candidates prepare for the online coding test.
This article explains the fundamentals of red‑black trees, a self‑balancing binary search tree, covering their properties, recolor and rotation operations, step‑by‑step insertion cases, and practical questions such as Java 8 HashMap usage and deletion rules.
This article introduces Redis's fundamental and advanced data structures, explains how each is represented internally, and provides detailed examples of essential commands such as KEYS, EXISTS, DEL, EXPIRE, TTL, and TYPE, highlighting their usage, complexity, and best‑practice considerations.
This tutorial introduces Python by defining the language, explaining why it’s popular, and walking through core fundamentals such as variables, conditional statements, loops, lists, dictionaries, classes, encapsulation, getters/setters, and inheritance with clear code examples.
This article offers a clear, visual introduction to red‑black trees, covering binary search tree fundamentals, the four balancing rules, insertion cases with recolor and rotation steps, and step‑by‑step animated examples, helping readers grasp and remember the concepts through images and analogies.
The article examines the risks of using the dangerous FLUSHDB command in Redis, explores common alternatives like SCAN, async deletion, and expiration, and proposes a secondary‑index solution using sets and sorted sets to efficiently invalidate only the affected cache entries without blocking the service.
This article explains how library indexing inspires database indexing, introduces binary search trees, AVL trees, B‑Tree and B+Tree structures, and details InnoDB and MyISAM storage mechanisms, page organization, clustered versus non‑clustered indexes, and practical index‑optimization advice.
This article explains why Redis achieves exceptional performance by using pure in‑memory operations, a single‑threaded model, efficient data structures like SDS, skip‑list, ziplist, and various encoding and rehash optimizations that reduce memory allocation and CPU overhead.
This article summarizes a variety of practical methods—including Bloom filters, hashing, bit‑maps, heaps, bucket partitioning, database indexes, inverted indexes, external sorting, tries, and MapReduce—that can be used to efficiently handle and analyze extremely large data volumes in real‑world scenarios.
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.
This article presents 35 comprehensive multiple‑choice and essay questions covering VLANs, system calls, IP addressing, TCP/UDP, algorithmic puzzles, data structures, DNS, traceroute, and related reference answers, offering a solid self‑test for core computer‑science concepts.
This article explains Redis' core data types—strings, lists, sets, hashes, sorted sets, and more—detailing their characteristics, common commands, practical use‑cases such as caching, counters, distributed locks, and ranking, and provides best‑practice tips for key design and performance.
This article introduces Redis as an open‑source in‑memory store, outlines its core data structures—strings, hashes, lists, sets, sorted sets, bitmaps, hyperloglogs, and geospatial indexes—and provides concrete command examples, application scenarios, and best‑practice guidelines for effective usage.
This guide walks through Python’s fundamental data structures—strings, lists, tuples, dictionaries, and sets—showing how to create, manipulate, and query them with clear code examples for operations such as slicing, joining, sorting, and set mathematics.
This article explains how Redis stores all values as byte arrays, clarifies the five primary data structures, describes cluster slot mapping and node‑key relationships, and covers single‑threaded execution, transactions, pipelines, and the Redis protocol in detail.
This article explains why Redis delivers exceptional performance by examining its pure in‑memory operations, single‑threaded design, efficient data structures such as SDS, dictionaries, skip‑lists, zip‑lists, and the encoding and rehash strategies that keep latency low even under heavy load.
This article introduces recursion by outlining its three essential elements—function purpose, base case, and recurrence relation—and demonstrates each step with clear Java/C examples such as factorial, Fibonacci, frog‑jump, and linked‑list reversal, while also covering common pitfalls and optimization techniques.
This article introduces Scala arrays, covering their declaration, element access, multidimensional arrays, common operations such as iteration, summation, finding maximum values, concatenation, range creation, and a comprehensive list of array methods, all illustrated with clear code examples.
The article shares a developer’s experience interviewing at over 30 Chinese tech firms, breaking down three main interview focuses—data structures and algorithms, operating‑system and core‑technology knowledge, and project experience—while also offering practical advice on networking questions, open‑source tools, and how to evaluate a company's interview process.
The article shares the author’s interview experiences at over 30 companies and provides a comprehensive guide covering data‑structure and algorithm questions, core C++ concepts, operating‑system fundamentals, networking protocols, open‑source tools, project‑experience expectations, and practical advice for evaluating both technical and non‑technical aspects of potential employers.
In this article, Redis creator Antirez explains the rationale behind upcoming features such as RESP3, fine‑grained ACLs, multithreading approaches, storage improvements, and new data structures, while emphasizing the lack of a fixed roadmap and the community‑driven nature of Redis development.
This article explains the thread‑safe, ordered Java collection ConcurrentSkipListSet, compares it with TreeSet, describes its skip‑list based internal structure, lists its full API, and provides a multithreaded example demonstrating correct concurrent usage versus the failure of TreeSet.
This article explains the inner workings of Java 8's ConcurrentHashMap, covering how the table is initialized, how linked‑list bins are converted to red‑black trees, the resizing logic with tryPresize, and the multi‑threaded transfer process that moves entries to a larger table.
This article provides an in‑depth tutorial on Java 8’s HashMap and ConcurrentHashMap implementations, explaining their internal structures, red‑black tree conversion, resizing mechanisms, and step‑by‑step code analysis of put, get, and initialization processes, essential for interview preparation.
This article provides a comprehensive, step‑by‑step explanation of Java 7 HashMap and ConcurrentHashMap internals, covering their data structures, put/get algorithms, array initialization, resizing, segment locking, rehashing, and the concurrency considerations that ensure thread‑safe access.
This article introduces the Java JUC concurrent collection classes, detailing the thread‑safe List and Set implementations, the concurrent Map variants, and the various Queue types, while providing diagrams and brief explanations of their usage and characteristics.
Dan Abramov announced revised interview expectations for front‑end engineers, emphasizing practical JavaScript skills, performance awareness, core data structures, and a solid grasp of language fundamentals without requiring specific library knowledge, to help candidates better prepare for Facebook‑style interviews.
This article provides a comprehensive overview of Java's LinkedList class, covering its definition, internal node structure, constructors, element addition and removal methods, traversal techniques, iterator behavior, and concurrency considerations, all illustrated with complete source code examples.
This article provides a comprehensive overview of Java's ArrayList, covering its internal structure, key fields, constructors, core operations such as adding, removing, and searching elements, traversal techniques, fail‑fast behavior, and a comparison with Vector, all illustrated with original source code snippets.
This article guides beginners through the essentials of Python, covering why to learn it, how to get started, core data types, operators, functions, classes, modules, and advanced features, while offering motivational advice to persist through early challenges.
This guide outlines the ten core competencies—from data structures and version control to IDEs, databases, Unix, Excel, programming languages, networking, and scripting—that every new or aspiring software developer should master to build a successful career.
This article explains how Redis stores and encodes its five data types by using various in‑memory data structures such as SDS strings, linked lists, quicklists, hash tables, skip‑lists, intsets and zip‑lists, and it also covers object mapping, expiration policies, LRU eviction, and the RDB/AOF persistence mechanisms.
This article outlines eight actionable strategies—including investing in education, leveraging existing libraries, mastering data structures, using powerful IDEs, writing clean code, continuous learning, disciplined planning, and humility—to help programmers become more outstanding in their careers.
This article explains the concept of a priority queue, presents a interview‑style problem requiring O(log n) enqueue and dequeue operations, and shows how to implement the solution efficiently using a binary heap with detailed step‑by‑step illustrations and a complete JavaScript code example.
This article provides a detailed overview of Redis as an open‑source, in‑memory data store, covering its core features, common use cases such as caching and leaderboards, high‑performance characteristics, essential data structures and commands, configuration options, and practical recommendations for production deployment.
This article introduces several practical algorithmic tricks—using array indices as counters, applying modulo for circular traversal, employing two‑pointer methods for linked‑list problems, leveraging bit‑shift and bitwise operations, adding sentinel nodes, and optimizing recursive solutions with memoization and bottom‑up DP—each illustrated with Java code examples.
This article explains Redis's core data types—String, Hash, List, Set, and Sorted Set—its internal object model, persistence options (RDB and AOF) with their pros and cons, transaction characteristics, master‑slave replication mechanisms, and common caching scenarios and design considerations.
This comprehensive guide explains Redis fundamentals, its rich data structures and common commands, then dives into performance optimization, replication, and clustering, offering practical examples and best‑practice recommendations for building reliable, high‑performance Redis deployments.
This article introduces sorting algorithms, distinguishing internal and external sorting, listing major internal sorts, explaining their time‑complexity categories and stability properties, and providing visual illustrations for each algorithm along with a reference to an open‑source implementation.
Redis and Memcached differ significantly in data structure support, memory efficiency, performance, memory management, persistence options, and clustering capabilities, with Redis offering richer data types, server‑side operations, configurable persistence, and native clustering, while Memcached provides simpler key‑value storage, slab allocation, and client‑side distribution.
This article explains five practical techniques—list storage, in‑memory set, MD5 hashing, bitmap compression, and Bloom filter—to efficiently deduplicate URLs during large‑scale Python web crawling, highlighting their trade‑offs in speed, memory usage, and collision risk.
This article provides a detailed introduction to sorting algorithms, covering internal and external sorts, their time complexities and stability characteristics, and presents step‑by‑step Java implementations for bubble sort, selection sort, insertion sort, shell sort, merge sort, quick sort, heap sort, counting sort, bucket sort, and radix sort, accompanied by visual illustrations.
This comprehensive guide introduces Redis fundamentals, explores its diverse data structures and essential commands, and delves into advanced topics such as persistence, memory management, pipelining, transactions, clustering, and Java client choices, offering practical tips for deployment, optimization, and architectural decisions.
CopyOnWriteArrayList is a thread‑safe variant of ArrayList that achieves read‑write separation by copying the underlying array on each mutative operation, using a ReentrantLock for writes, making it ideal for read‑heavy, write‑light scenarios, and it differs from ArrayList in safety, performance, and concurrency behavior.
This comprehensive guide explores essential strategies for handling massive datasets, covering hash-based structures, bucket partitioning, heap and quicksort techniques, trie trees, Bloom filters, external sorting, and MapReduce, and demonstrates how to efficiently solve common interview problems such as top‑K queries and duplicate removal.
The article explains that machine‑learning programs rely on the same fundamental data structures as other software—especially arrays for linear algebra—but mastering their implementation, dynamic behavior, and alternatives such as linked lists, trees, heaps, stacks, queues, and hash maps is crucial for scaling and optimizing complex AI tasks.
This article explains the classic Linux kernel list linked‑list data structure, covering its definition, file locations, core operations such as initialization, insertion, deletion, replacement, moving, splitting and merging, the list_entry macro, usage examples, and important multithreading considerations.
An interview question about checking whether a new integer belongs to a set of 4 billion numbers leads to a discussion of distributed loading across eight machines, bitmap representation using 500 MB of memory, and interval‑based external sorting, illustrating practical big‑data algorithm design.
This article explains Python's frozenset type, detailing its immutable nature, creation syntax, differences from mutable sets, supported operations, membership testing, and practical code examples illustrating set algebra and method usage.
This article explains how to monitor Redis memory usage with the INFO command, interprets key metrics such as used_memory, used_memory_rss, and mem_fragmentation_ratio, and dives into Redis's internal memory layout, including allocators, redisObject, SDS, and the various object types and their encodings.
This article provides a comprehensive overview of Python, covering its nature as an interpreted, interactive, object‑oriented language, key benefits, coding conventions, memory management, debugging tools, core concepts like decorators, data structures, namespaces, lambda functions, testing, and many practical programming details for newcomers.
This article explains the fundamental principles of Java's HashMap, covering hash basics, time‑complexity of operations, the role of load factor and initial capacity, the resize algorithm without full rehashing, and the treeification of long buckets, illustrated with JDK 1.8 source code examples.
This article systematically explains common Java collection classes—including LinkedList, ArrayList, Stack, Queue, HashMap, and LinkedHashMap—highlighting their internal structures, key operations, performance characteristics, and JDK 8 differences, and it provides animated illustrations and full code snippets for each concept.
This article provides a comprehensive overview of the Java Collections Framework, detailing its core interfaces, common implementations such as List, Set, Queue, and Map, their underlying data structures, performance characteristics, and usage examples including legacy classes and specialized collections like PriorityQueue and LinkedHashMap.
This comprehensive guide explains what Redis is, its advantages over memcached, supported data structures, eviction policies, clustering options, persistence mechanisms, memory optimization techniques, and practical use‑cases such as caching, queues, leaderboards, and pub/sub, providing essential knowledge for developers and architects.
This article explains the fundamentals of binary operations, why hashCode is used, how Java's String hashCode is implemented, the rationale behind using the multiplier 31, and the detailed workings of HashMap's hash function, index calculation, capacity choices, and custom sizing recommendations.
This article provides a comprehensive overview of Redis, covering why it is used, its performance advantages, data structures, expiration and eviction strategies, cache‑database consistency, handling cache penetration and avalanche, and approaches to concurrent key competition.
The article explains Git’s fundamental architecture, describing how trees, blobs, and commits are stored as objects identified by hashes, how version history forms a linked list, and how optimizations such as directory sharding and garbage collection fit into this design.
This article explains how database indexes are implemented using B+ trees, describing their structure, advantages such as shallow depth and ordered leaf nodes, and how they reduce disk I/O, illustrating calculations of node capacity and emphasizing the importance of index size for performance.
This article explains the performance characteristics and implementation details of common linear data structures such as arrays, hash maps, sets, lists, linked lists, stacks, and queues, showing their time complexities, code examples, and how to choose the right structure for efficient programming.
This article explains the core design of Java's HashMap—including its hash function, array storage, and linked‑list collision handling—and walks through creating a simplified MiniHashMap implementation with interfaces, constructors, put/get methods, resizing, and testing.
Meitu Technology’s technical salon on June 9, 2018 in Xiamen showcased how its AI‑driven deep ranking, video‑clustering, and data‑structure‑based optimization techniques improve personalization, recommendation and economic‑focused problem solving for billions of mobile users, targeting mid‑senior R&D and algorithm engineers.
The article shares a seasoned Java developer’s journey from superficial framework use to deep source‑code study, emphasizing solid fundamentals such as HashMap internals, concurrency mechanisms, and performance‑oriented coding practices to build a robust J2EE skill set.
This guide walks through Python’s core data structures—strings, lists, tuples, dictionaries, and sets—detailing their creation, common built‑in methods, slicing, updating, and iteration with clear code examples, helping readers master essential operations for effective data manipulation.
This article provides a comprehensive analysis of Java's HashMap implementation, covering its class signature, inheritance hierarchy, hash function design, core operations such as get, put, and remove, internal data structures, resizing logic, iterator behavior, and serialization details, all illustrated with original source code snippets.
This article provides a high‑level overview of Java’s Collections Framework, explaining its core design principles, the top‑level Collection and Map interfaces, their sub‑interfaces such as List, Set, Queue, and Map, and the typical implementation naming conventions, helping developers understand and analyze collection classes.
This article explains Redis’s memory model—including memory statistics, allocation, object structures, internal encodings, and practical optimization strategies—providing detailed insights into how Redis stores data, manages memory fragmentation, and how developers can estimate and reduce memory usage for high‑performance deployments.
This article provides an overview of Java's ArrayList class, explaining its dynamic array implementation, thread-safety considerations, key interfaces, constructors, capacity management, core methods, and internal mechanisms such as ensureCapacity, trimToSize, and serialization, accompanied by detailed source code excerpts and practical insights.
This article presents a comprehensive collection of Python performance‑boosting techniques—from choosing optimal data structures and using copy versus deepcopy, to leveraging generators, join, efficient string formatting, loop optimizations, C‑based modules, parallel programming, and the PyPy JIT—each illustrated with concrete code examples and benchmark results.
Binary Search Trees (BST) are dynamic, ordered binary trees that enable fast search, insertion, and deletion; this guide explains their definition, properties, traversal methods, and core operations—including search, minimum/maximum, successor/predecessor, insertion, and deletion—complete with pseudocode and illustrative examples.
This article provides concise explanations of core Java and system concepts—including JVM class loading, HashMap implementation, concurrency utilities, IPC mechanisms, garbage collection, sorting algorithms, networking protocols, Linux scheduling, deadlock conditions, hashing techniques, and database normalization—useful for technical interviews and foundational study.
This article explains the evolution from binary search trees to AVL and red‑black trees, introduces B and B+ trees, compares their properties and performance, and clarifies why B+ trees are the preferred indexing structure for MySQL databases.
This tutorial introduces Python by explaining what it is, why to learn it, and then walks through core fundamentals such as variables, conditional statements, loops, lists, dictionaries, iteration techniques, and object‑oriented concepts like classes, encapsulation, and inheritance, all illustrated with clear code examples.
