Introduces the concepts of lists and arrays as fundamental data structures, explaining the problem they solve — organising collections of data in memory — and providing learners with a foundation for understanding how programs store and manipulate multiple values efficiently.
Topics
This module covers 7 topics. Open a topic to see its subtopics and the materials made for it.
- Topic 1Introduction to Lists and Arrays
- Topic 2Array Structure and Memory Layout
- Topic 3List Structure and Dynamic Behavior
- Topic 4Core Data Operations on Lists and Arrays
- Topic 5Introduction to Computational Complexity
- Topic 6Big O Notation Fundamentals
- Topic 7Applying Big O to List and Array Operations
Module Content
18 items of 4 types: Topic Detail, Topic Videos, Readings, Activities and Games. Your instructor made most of them with CourseBuilder+, a program that uses AI to draft course material; each type says how its items were made.
Topic Detail (7)
A detailed reading for each topic, covering its subtopics in order with explanations and examples — reading only, no videos (for the reading with videos, see Topic Detail with Video). Drafted with AI from the module's topics, subtopics and learning outcomes.
-
-
Explains how arrays are laid out in contiguous memory, how index-based addressing works at a low level, and why this structure has direct implications for performance, giving learners the mental model needed to reason about array efficiency.
-
Describes how lists differ from arrays by supporting dynamic resizing, explaining the underlying mechanisms that allow lists to grow and shrink at runtime and what that flexibility costs in terms of memory and performance.
-
Defines and illustrates the four core data operations — access, search, insertion, and deletion — as applied to lists and arrays, giving learners the vocabulary and conceptual baseline needed before comparing algorithmic efficiency across data structures.
-
Introduces computational complexity as a mathematical and conceptual framework for measuring how algorithm resource usage scales with input size, distinguishing it from raw execution speed and establishing the groundwork for Big O analysis.
-
Explains the fundamentals of Big O notation — including common complexity classes such as O(1), O(n), and O(n²) — and teaches learners how to read, write, and interpret Big O expressions to evaluate how code performance scales with data size.
-
Covers how Big O notation is applied to common list and array operations, explaining how to analyse and compare the time complexity of tasks such as access, search, insertion, and deletion so learners can reason about which data structure suits a given use case.
Topic Videos (8)
Videos for each topic: a short introduction to the topic, then up to three YouTube videos embedded, each with what it covers and why it is worth watching. The videos were found by an AI search of YouTube (well viewed, with captions where possible), and the page was written with AI.
-
An overview reading that defines data structures and contrasts arrays (fixed-size, contiguous, index-accessed) with linked lists (chained nodes), giving learners the conceptual foundation and vocabulary for the rest of the module.
-
A lesson on how arrays are laid out in contiguous memory and how element addresses are computed from a base address and index, used to explain why indexed access is constant-time and why array size is fixed.
-
A reading on lists as dynamic structures that grow and shrink at runtime, explaining how node linkage or resizing frees the programmer from predicting capacity in advance and how that differs from array behavior.
-
A topic covering the four core operations — access, search, insertion, and deletion — on lists and arrays, prompting learners to reason about how each operation works and what it costs on each structure.
-
An introduction to computational complexity that explains why algorithms are measured by counting operations as a function of input size n rather than by stopwatch timing on a particular machine.
-
A foundational lesson on Big O notation and common growth classes such as O(1), O(n), and beyond, teaching learners to describe and compare the growth curves of algorithm costs.
-
An applied topic that assigns Big O cost classes to access, search, insertion, and deletion on arrays versus linked lists, helping learners choose the right structure for a given usage pattern.
-
A consolidated module overview page compiling all seven topic readings on array and list structure, core operations, and Big O notation into a single document for review or printing.
Readings (1)
Reading for this module: drafted with AI from the module's topics, or brought in from the course's own files.
-
Covers how Big O notation is applied to common list and array operations, explaining how to analyse and compare the time complexity of tasks such as access, search, insertion, and deletion so learners can reason about which data structure suits a given use case.
Activities and Games (2)
Interactive activities and games that run in the browser — practice by doing. Drafted with AI from the module's topics.
-
This interactive drag-and-drop activity presents seven key terms related to lists, arrays, and Big O notation that learners must match to their correct definitions, providing immediate feedback on each attempt; instructors can use it as a formative assessment to check students' understanding of foundational vocabulary before or after the Module 2 lesson.
-
A drag-and-drop matching activity where learners pair common list and array operations (e.g., access, insertion, deletion) with their correct Big O time complexity descriptions, receiving immediate feedback on each match to reinforce understanding of algorithmic efficiency.