Tagged articles
Linked List
54 articles · Page 1 of 1
This article provides a comprehensive guide to LeetCode 21 Merge Two Sorted Lists, covering iterative and recursive solutions, 10 common pitfalls with fixes, interview follow-up questions, and extensions to k-way merge, helping candidates move from merely passing to demonstrating engineering judgment.
Algorithm PitfallsIterative AlgorithmK-way Merge
0 likes · 28 min read


liandkAug 28, 2026 · Fundamentals
This tutorial explains linked lists with a vivid array‑vs‑list analogy, outlines their core structure, shows real‑world scenarios, provides fully commented Python code with sample output, and highlights common pitfalls and a quick decision guide for choosing between arrays and linked lists.
AlgorithmData StructuresLinked List
0 likes · 6 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 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.
ConcurrencyData StructuresLinked List
0 likes · 37 min read

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.
AlgorithmLeetCodeLinked List
0 likes · 7 min read

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

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.
C++Data StructuresLinked List
0 likes · 10 min read

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

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.
AlgorithmData StructuresLinked List
0 likes · 12 min read

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.
Data StructuresLinked ListQueue
0 likes · 6 min read

This comprehensive guide walks you through Python's core data structures—including lists, stacks, queues, linked lists, trees, heaps, and graphs—explaining their characteristics, common operations, and step‑by‑step code examples, while also covering related algorithms such as recursion, depth‑first and breadth‑first search, cycle detection, and Dijkstra's shortest‑path algorithm.
AlgorithmsData StructuresGraph
0 likes · 77 min read

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.
Drag-and-DropLinked ListMySQL
0 likes · 9 min read

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.
HashMapJavaLinked List
0 likes · 5 min read

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.
AlgorithmC++Linked List
0 likes · 25 min read

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.
C++Function PointerLinked List
0 likes · 11 min read

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.
Data StructuresGoLinked List
0 likes · 5 min read

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.
AlgorithmsData StructuresGo
0 likes · 6 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 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.
AlgorithmLinked Listarrays
0 likes · 7 min read

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.
C++Linked ListLinux
0 likes · 55 min read

This article explains how to reverse a singly‑linked list in groups of K nodes by locating each segment's head and tail, reversing the segment, and recursively processing the remainder, with a complete Go implementation and step‑by‑step reasoning.
AlgorithmInterviewLinked List
0 likes · 4 min read

The article explains how to detect a cycle in a singly‑linked list using fast and slow pointers, then locate the cycle’s entry node by resetting the slow pointer to the head and moving both pointers one step at a time, with full Go implementation provided.
AlgorithmGoLinked List
0 likes · 4 min read

This article explains a recursive solution in Go for LeetCode problem 92, detailing how to reverse a sublist of a singly linked list between given positions by first locating the start node, using a helper to reverse the first n nodes, and correctly reconnecting the remaining parts.
GoLeetCodeLinked List
0 likes · 5 min read

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.
AlgorithmK-way MergeLinked List
0 likes · 9 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 introduces linked lists as a fundamental data structure, compares them with arrays, explains single, doubly, and circular variants, demonstrates insertion, deletion, and boundary handling with dummy nodes, and details two‑pointer techniques for cycle detection and finding the list’s midpoint.
AlgorithmData StructuresJava
0 likes · 15 min read

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.
ConcurrencyLinked Listc-programming
0 likes · 22 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

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.
Linked Listalgorithm fundamentalsc-programming
0 likes · 7 min read

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.
Go ProgrammingIndex structureLinked List
0 likes · 17 min read


JavaEdgeOct 27, 2021 · Interview Experience
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.
AlgorithmC++Go
0 likes · 6 min read

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

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.
AlgorithmLinked Listcycle detection
0 likes · 4 min read

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.
AlgorithmsData StructuresJava
0 likes · 24 min read

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.
AlgorithmData StructuresLeetCode
0 likes · 14 min read

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.
Classroom LearningLinked ListPhysics
0 likes · 5 min read

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.
AlgorithmData StructuresJava
0 likes · 10 min read

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.
Add Two NumbersAlgorithmJava
0 likes · 7 min read

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.
AlgorithmsData StructuresLinked List
0 likes · 12 min read


政采云技术Dec 29, 2020 · Frontend Development
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.
FiberLinked ListReact
0 likes · 18 min read

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.
AlgorithmsData StructuresDynamic Programming
0 likes · 9 min read

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.
Linked Listblack-box testingc-programming
0 likes · 8 min read

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.
Array ImplementationJavaLinked List
0 likes · 8 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


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 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.
Data StructuresDatabase InternalsLinked List
0 likes · 12 min read


ITPUBNov 26, 2019 · Fundamentals
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.
Linked ListLinus Torvaldscode quality
0 likes · 6 min read

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.
AlgorithmLinked Listk-group reversal
0 likes · 7 min read

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.
Data StructuresLinked ListLinux kernel
0 likes · 5 min read

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.
ComplexityData StructuresHashMap
0 likes · 50 min read

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.
Data StructuresLinked List
0 likes · 9 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
