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 the design, implementation, and practical use of the Linux kernel's intrusive linked‑list data structure, covering its core concepts, list_head definition, common macros, insertion, deletion, traversal, optimization techniques, concurrency control with RCU and memory barriers, and real‑world examples in device drivers and process scheduling.
This article explains the fast‑slow (tortoise‑hare) pointer technique, lists its common applications such as cycle detection, middle‑node finding, palindrome checking, and demonstrates three LeetCode‑style solutions with step‑by‑step explanations and full Python code.
An insightful story warns against cutting valuable talent, followed by a detailed Java solution that inserts the greatest common divisor between each pair of nodes in a singly linked list, complete with algorithm explanation, code, complexity analysis, and edge‑case handling.
This article demonstrates how to simulate object‑oriented programming in C by using structs and function pointers, defines a list interface, provides a full implementation with insertion, deletion, traversal, and testing code, and explains why such techniques improve readability and maintainability.
A detailed walkthrough of a friend's first‑round interview at Toutiao, covering self‑introduction, project deep‑dive, OS scheduling, TCP reliability, SQL join, and two linked‑list reversal implementations, with the exact questions and code shown.
This article explains practical Python implementations for reversing a linked list using iterative and recursive approaches, merging two or multiple sorted linked lists, handling edge cases such as empty inputs, and includes complete code samples with complexity analysis for each method.
This guide outlines the core data structures—arrays, 2D arrays, queues, linked lists, stacks, trees, and hash maps—explaining their characteristics, typical use‑case scenarios, and concrete examples to help embedded developers write efficient, scalable code.
The article compares two backend implementations for drag‑and‑drop ordering—using a simple position column (array model) and a doubly linked list with prev_id and sibling_id—detailing their MySQL schemas, update logic, performance trade‑offs, and practical considerations such as pagination and locking.
This article explains the internal architecture of Java's HashMap, covering its array of buckets, linked‑list handling of hash collisions, and the conversion to red‑black trees for high‑collision scenarios, supplemented with code examples and visual diagrams.
This article explains the differences between array‑based sequential storage and pointer‑based linked storage, introduces singly, doubly and circular linked lists, and provides complete C implementations for creation, insertion, deletion, and traversal with clear diagrams and step‑by‑step code examples.
This article shows how C can achieve object‑oriented‑style design by using structs to model classes and function pointers as methods, providing concrete code examples such as a linked‑list implementation, interface definition, and test harness to illustrate the technique.
This article provides an in‑depth exploration of Go’s container/list package, detailing its internal linked‑list structures, core methods, performance characteristics, practical code examples, and ideal use‑cases for scenarios requiring frequent insertions and deletions.
This article introduces the concept, characteristics, and core operations of singly linked lists, then provides a complete Go implementation with node definitions, insertion at head and tail, deletion, traversal, and a test program to demonstrate usage.
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 explains the fundamental concepts of linked lists, contrasting them with arrays through memory allocation analogies, illustrating how linked lists provide dynamic, non‑contiguous storage, their node structure, advantages, disadvantages, and practical implementation considerations across programming languages.
This article explains the core Linux kernel data structures—including doubly linked lists, kfifo queues, IDR mappings, and red‑black trees—detailing their design, key macros like container_of and offsetof, and providing complete C code samples for initialization, insertion, traversal, and deletion.
This article explains how to merge multiple sorted linked lists (or arrays) into a single ascending list using a min‑heap priority queue, presents two Python solutions—one converting arrays to linked lists and another operating directly on arrays—along with detailed code, example, and complexity analysis.
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 the design and C implementation of a five‑level hierarchical timing wheel, covering its data structures, pointer handling with bitwise operations, timer insertion, modification, deletion, cascade processing, and a demo program that highlights blocking behavior of long‑running timer callbacks.
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.
This article introduces the five common linked‑list variations, explains head pointers and head nodes, compares singly and doubly linked lists, and provides a complete C implementation of a doubly circular linked list with functions for creation, traversal, insertion, and deletion.
The article explains skip list fundamentals, shows how probabilistic multi‑level indexing yields O(log n) search and O(n) space, provides a complete Go implementation with insertion, deletion and search functions, compares Redis’s enhanced skip list used in sorted sets, and answers common design questions.
This article explains how to determine whether a singly linked list contains a cycle using three approaches—brute‑force, hash‑marking, and the optimal fast‑and‑slow pointer technique—providing Go and C++ implementations that achieve minimal time and O(1) space complexity suitable for a Tencent interview.
This article introduces the fundamentals of data structures and algorithms, covering basic structures such as arrays and linked lists, common sorting algorithms, advanced structures like B+ trees and red‑black trees, explains Big O notation, and provides Java code examples for dynamic arrays, linked lists, queues, and stacks.
This article explains how to determine whether a singly linked list contains a cycle using the fast‑slow pointer technique, derives the mathematical reasoning for locating the cycle entry point, and provides a complete Java implementation that returns the node where the cycle begins or null if none.
This comprehensive guide explains core data concepts, defines data, data objects, elements and types, explores logical and physical structures, details sequential, linked, indexed and hash storage, and provides Java code examples for arrays, linked lists, stacks, queues, trees, binary search trees, AVL and red‑black trees, illustrating how to choose and implement appropriate structures for real‑world problems.
This article presents detailed explanations, algorithmic ideas, and complete Go code for reversing an entire singly linked list, reversing a sub‑list between positions m and n, finding the intersection node of two lists, detecting cycles, and partitioning a list around a pivot value.
The article discusses methods for teaching circuit fault diagnosis in a classroom setting, focusing on modeling circuit components as edges and using a linked list to manage break points dynamically.
This article explains the core concepts of recursion by walking through an array‑sum example and a LeetCode linked‑list removal problem, detailing the necessary base case, recursive formula, and providing complete Java implementations with step‑by‑step visual illustrations.
This article explains how to solve LeetCode's "Add Two Numbers" problem by representing integers with reversed linked lists in Java, detailing both an iterative method and a recursive solution, complete with code examples and analysis of time and space complexities.
This article provides a concise overview of eight essential data structures—arrays, linked lists, stacks, queues, hash tables, trees, heaps, and graphs—explaining their definitions, core operations, and typical applications in software development and computer science.
This article explains how React 16's Fiber architecture replaces the recursive VDOM traversal with a cooperative, time‑sliced update model that splits work, uses linked‑list structures, assigns priorities, and allows tasks to be paused, resumed, or aborted for smoother rendering and better user experience.
This article compiles a comprehensive list of over 400 algorithm and data‑structure problem solutions—including dynamic programming, backtracking, DFS/BFS, binary‑tree, linked‑list, stack, sorting, searching and classic puzzles—organized by topic and linked to detailed explanations for easy reference.
This article explains how to treat a polynomial addition and multiplication program as a black box, outlines its input/output format, describes a linked‑list implementation with key functions, and presents critical, equivalence‑class, and loop‑related test cases along with practical debugging tips.
This article explains the concept of FIFO queues, outlines their key properties, and provides three Java implementations—using an array, a linked list, and a List—complete with source code, usage examples, and typical application scenarios.
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.
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 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.
In a candid interview, Linus Torvalds shares his pragmatic engineering mindset, explains why Git was his second major project, and demonstrates how a clean pointer‑indirection technique can simplify linked‑list element removal, contrasting it with a more cumbersome approach.
The article explains how to solve a variant of the linked‑list reversal problem where every K nodes are reversed as a group starting from the tail, using recursion and double reversal techniques, and provides complete Java implementations for the algorithm.
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.
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 concept of linked lists versus sequential array storage, why JavaScript developers might need them, and provides step‑by‑step code to implement singly and doubly linked lists, custom array‑like APIs, and a circular list, along with performance trade‑offs and a GitHub reference.
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.
