Data structure
A data structure is an organized representation of data and its relationships that supports defined operations for storing, accessing, or modifying it.
Grokking Data Structures
A data structure is an organized representation for storing data that defines relationships among elements and the operations and access constraints applicable to them.
- How it is used
- Organizes stored information for useful access and manipulation, and guides container choices in software problems.
- How deep it goes
- Defines relationships and operations, distinguishes abstract types from implementations, and gives selection steps without requiring a particular implementation.
- Examples
- Uses a checkout queue, an emergency-room admission problem, and list, stack, and queue representations.
- What you can do after
- Evaluate/understand which structure fits required operations, ordering, performance, memory use, and other constraints.
Fast Python: High performance techniques for large datasets
- How it is used
- Uses data structure selection to improve Python data-processing performance and memory use.
- How deep it goes
- Explains lookup complexity and container memory estimation through benchmarks and implementation details, while noting limits of general memory estimates.
- Examples
- Benchmarks list and set membership and estimates the memory footprint of nested station data.
- What you can do after
- Diagnose inefficient Python structures and evaluate replacements against their access patterns and memory costs.
Read how Fast Python: High performance techniques for large datasets explains data structure →
Advanced Algorithms and Data Structures
A concrete implementation of an abstract data type consisting of data storage organization and algorithms that manipulate the stored data.
- How it is used
- Guides the choice of storage and operations for practical tasks such as inventory queries.
- How deep it goes
- Defines the ADT–implementation distinction and gives a workflow for specifying operations, representation, and performance.
- Examples
- Uses an indexed character array and an inventory requiring search by name and resupply priority.
- What you can do after
- Evaluate/understand it: select a structure for required operations and weigh performance, memory, library use, and customization.
Read how Advanced Algorithms and Data Structures explains data structure →
Fabulous Adventures in Data Structures and Algorithms
A data structure is an organization of data that supports storing, accessing, and manipulating it.
- How it is used
- Organizes information to support required operations, with representation chosen after defining those operations.
- How deep it goes
- Defines the term briefly, works through immutable list and stack designs, and defers dynamic updates to the word-list example.
- Examples
- Uses an immutable linked list, an immutable stack with shared tails, and an autocomplete word-list interface.
- What you can do after
- Build it from scratch in C# by specifying operations, handling empty cases, and examining performance.
Read how Fabulous Adventures in Data Structures and Algorithms explains data structure →
Python How-To
A data structure is an organized representation of data together with the operations or access patterns associated with that representation.
- How it is used
- Uses containers to manage multiple objects in Python projects and select data or actions for a task.
- How deep it goes
- Explains common containers, access patterns, type hints, and copying through examples, without exhaustively reviewing container functionality.
- Examples
- Uses task urgency dictionaries, function dispatch, and copied task tags to illustrate container use.
- What you can do after
- Apply Python containers to store and access project data, select functions, and avoid unintended sharing when copying.
Get Programming: Learn to code with Python
A data structure is an organized representation for storing and accessing information in a particular format.
- How it is used
- Uses data structures to organize information and select suitable representations for programming tasks.
- How deep it goes
- Defines the idea, contrasts modifiable containers, and works through converting document text into a list.
- Examples
- Uses country lists, mutable containers, cleaned text, and a word list extracted from a sonnet.
- What you can do after
- Evaluate and choose a simple data type or structure for a task, then use a list to process document words.
Read how Get Programming: Learn to code with Python explains data structure →
Machine Learning Algorithms in Depth
A data structure is a scheme for storing and organizing data to support particular access and update operations.
- How it is used
- Supports implementing machine-learning algorithms efficiently by matching storage and access patterns to computational tasks.
- How deep it goes
- Defines structures, classifies them, and compares operation complexities, but does not derive their internal implementations in detail.
- Examples
- Uses arrays, dynamic arrays, maps, sets, hash tables, linked lists, stacks, binary search, and comparison-based sorting.
- What you can do after
- Apply it via from-scratch implementations by selecting structures according to required operations and runtime constraints.
Read how Machine Learning Algorithms in Depth explains data structure →
C++ Concurrency in Action, Second Edition
An organization of data that supports particular operations for storing, accessing, or modifying it.
- How it is used
- Designs structures for safe access by multiple threads while considering where concurrent operations can proceed.
- How deep it goes
- Works through design guidelines and lock-based implementations; points to atomic, lock-free designs without detailing them here.
- Examples
- Uses stacks, queues, hash maps, and linked lists as lock-based concurrent structure examples.
- What you can do after
- Evaluate data structures for concurrency by identifying race risks and opportunities for parallel access.
Read how C++ Concurrency in Action, Second Edition explains data structure →
Python Workout: 50 ten-minute exercises
A data structure is an organized representation for storing and manipulating data in a program.
- How it is used
- Transforms file contents into structured Python values for comparisons, counting, grouping, and further processing.
- How deep it goes
- Works through dicts, lists, and nested dicts, but does not develop data-structure internals or implementation trade-offs.
- Examples
- Uses country populations, vowel counts, login-shell groups, numeric input factors, and nested user records.
- What you can do after
- Builds Python dictionaries and related structures from file contents, then performs meaningful queries and aggregations.
Read how Python Workout: 50 ten-minute exercises explains data structure →
Software Engineering for Data Scientists
A data structure is an organized representation of data that supports particular access and manipulation operations.
- How it is used
- Uses data structures to optimize Python code for computational efficiency as data size and operation counts grow.
- How deep it goes
- Briefly compares sets, priority queues, and NumPy arrays for search-related efficiency without developing their implementations.
- Examples
- Uses searching for a value and large data-science workloads as motivating cases.
- What you can do after
- Evaluate data structures as optimization choices for searches and other operations on growing datasets.
Read how Software Engineering for Data Scientists explains data structure →
Practical Automation with PowerShell: Effective scripting from the console to the cloud
A data structure is an organized representation of data and associated relationships for storing and processing information.
- How it is used
- Drives reusable PowerShell automation by representing registry keys, expected values, and evaluation logic in external serialized data.
- How deep it goes
- Defines fields, comparison operators, arrays, and nested tests, then extends the representation toward classes without detailing the complete function.
- Examples
- Uses registry security-baseline settings, four condition types, a comparison table, and a PowerShell hashtable with nested tests.
- What you can do after
- Build it from scratch by modeling registry requirements and supplying reusable functions with maintainable external data.
Also covered in
- Pandas Workout: 200 exercises to make you a stronger data analyst
- Rust Servers, Services, and Apps
- Acing the CCNA Exam: Volume 2 Advanced Networking and Security
- Inside AI
- Algorithms Every Programmer Should KnowIn early access (MEAP)
- Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu
- Python Workout, Second Edition
- Rust in Action: Systems programming concepts and techniques
- Simple Object-Oriented Design: Create clean, maintainable applications
- Code Like a Pro in Rust
- Julia as a Second Language
- Object-Oriented Software Design in C++
What to know first
- arrayAn array is an ordered collection of elements organized in one or more dimensions and accessible by position or index.
- PythonPython is a high-level, general-purpose, dynamically typed programming language with readable syntax and support for multiple programming paradigms.
- listA list is an ordered collection of elements arranged in a sequence.
- functionA function is a callable unit of program code that performs a computation or operation, can accept inputs, and may produce a result or side effect.
Related concepts
- Mapincludes · A map is an associative data structure that stores key-value associations and supports retrieving values by key.
- listincludes · A list is an ordered collection of elements arranged in a sequence.
- queueincludes · A queue is an ordered collection that holds items for retrieval or processing, commonly in first-in, first-out order.
- arrayincludes · An array is an ordered collection of elements organized in one or more dimensions and accessible by position or index.
- structincludes · A struct is a named composite type or data structure that groups multiple fields or values into one structured unit.
- k-d treeincludes · A k-d tree is a binary space-partitioning tree that organizes points in multidimensional space by recursively comparing coordinate dimensions.
Questions about data structure
What is data structure?
A data structure is an organized representation of data and its relationships that supports defined operations for storing, accessing, or modifying it.
Which Manning books explain data structure?
Grokking Data Structures, Fast Python: High performance techniques for large datasets, Advanced Algorithms and Data Structures, Fabulous Adventures in Data Structures and Algorithms, Python How-To, Get Programming: Learn to code with Python, Machine Learning Algorithms in Depth, C++ Concurrency in Action, Second Edition and 3 more.
What should I know before learning data structure?
Manning books that teach data structure usually introduce array, Python, list and function first.
What kinds of data structure are there?
Kinds of data structure include Map, list, queue, array, struct and k-d tree.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.










