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 choice to improve Python processing time and memory efficiency without assuming that larger infrastructure is necessary.
- How deep it goes
- Works through lookup timings and object-size inspection, explaining hash-based lookup while treating its complexity as an approximation.
- Examples
- Compares timed membership tests on 100,000-element lists and sets, then inspects a dictionary containing file data.
- What you can do after
- Diagnose/debug with `%timeit` and `sys.getsizeof`, then choose containers according to lookup pattern and memory footprint.
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 built-in containers to organize multiple objects for everyday Python project tasks.
- How deep it goes
- Defines containers and works through access, type hints, and copying, without attempting an exhaustive review of their functionality.
- Examples
- Shows numbered prime-list output, task urgency mappings, action-to-function lookup, and a copied task with shared tags.
- What you can do after
- Apply built-in Python containers to choose access patterns and recognize when copying a nested container leaves mutable data shared.
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 →
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.
Related concepts
- Mapincludes · A map is an associative data structure that stores key-value pairs and supports retrieving values by key.
- queueincludes · A queue is an ordered collection that holds items for retrieval or processing, typically removing them in the order they were added.
- listincludes · A list is an ordered collection of elements arranged in a sequence.
- arrayincludes · An array is an indexed, ordered collection of elements arranged in one or more dimensions, with elements accessed by position.
- structincludes · A struct is a composite data type or structure that groups related fields or values into a single 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.
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.