CS A132: Data Structures in Python

Course Outline of Record
Item	Value
Eff Term	Fall 2026
Curriculum Committee Approval Date	12/03/2025
Top Code	070600 - Computer Science (Transfer)
Units	4 Total Units (Lecture Units 3.5; Lab/Other Units 0.5)
Hours	90 Total Hours (Lecture Hours 63; Lab Hours 27)
Total Outside of Class Hours	126
Total Student Learning Hours	216
Course Credit Status	Credit: Degree Applicable (D)
Material Fee	No
Basic Skills	Not Basic Skills (N)
Repeatable	No
Open Entry/Open Exit	No
Grading Policy	Standard Letter (S)
Associate Arts Local General Education (GE)	Area 2 Mathematical Concepts and Quantitative Reasoning (OMTH)
Associate Science Local General Education (GE)	Area 2 Mathematical Concepts and Quantitative Reasoning (OMTH)

Course Description

This course emphasizes the design, implementation, and analysis of fundamental data structures and object-oriented programming using the Python programming language. Topics include arrays, stacks, queues, linked lists, trees, hashing, graphs, recursion, inheritance, polymorphism, and algorithm complexity. Students develop algorithms for searching, sorting, pattern matching, and tree operations such as traversal and balancing. This is the second course in the Computer Science AS-T transfer sequence. This course may be offered online. Prerequisites: Computer Science A122 or A131. PREREQUISITE: CS A122 or CS A131. Transfer Credit: CSU; UC. C-ID: COMP 132.C-ID: COMP 132.

Course Level Student Learning Outcome(s)

Design, implement, test, and debug Python programs using object-oriented programming principles.
Write Python programs that implement and apply core data structures (linked lists, array lists, stacks, queues, trees, and graphs).
Demonstrate proficiency with recursive methods by designing and coding recursive solutions to a variety of Python programming problems, including traversal and divide-and-conquer approaches.
Analyze and evaluate fundamental algorithms for searching, sorting (e.g., merge sort, quicksort, binary search), and structural operations, with emphasis on efficiency.

Course Objectives

Discuss and apply fundamental data structures and their memory representations in Python.
Design, implement, and evaluate data structures including lists, stacks, queues, sets, dictionaries (maps), trees, heaps, and hash tables.
Analyze algorithm efficiency using mathematical foundations, recursion, iteration, and asymptotic notation.
Implement and evaluate algorithms for sorting, searching, hashing, and graph processing (e.g., traversal, shortest path, spanning tree, topological sorting).
Apply recursion to solve problems using traversal and divide-and-conquer strategies.
Explain and apply object-oriented programming concepts, including classes, inheritance, and polymorphism, in Python.
Design and debug object-oriented programs demonstrating encapsulation, modularity, and code reuse.
Select and justify appropriate data structures and algorithms to create efficient, maintainable, and reusable software.

Lecture Content

Python Programming Review
1. Python's core data types and sequence operations
2. Mutable vs. immutable objects
3. Functions, modules, and packages
4. Exception handling
Mathematical and Algorithmic Foundations
1. Algebraic foundations for algorithms
2. Logarithms and exponent rules
3. Growth rates and asymptotic notation
Algorithm Analysis
1. Big-O notations and growth rates
2. Running time calculations
3. Comparing iterative and recursive algorithms
4. Amortized analysis
5. Case study: Maximum subsequence sum problem
Object-Oriented Programming in Python
1. Software development principles
2. Object-oriented design goals and patterns
3. Class definitions and encapsulation
4. Inheritance and polymorphism
5. Shallow vs. deep copying
6. Code reuse and design patterns in Python
Array-Based Structures
1. Low-level arrays and memory representation
2. Dynamic arrays and amortization
3. Python sequence types (list, tuple, array)
4. Multidimensional arrays and nested lists
5. Efficiency and limitations of array-based structures
Linked Lists
1. Singly-linked lists
2. Circular linked lists
3. Doubly-linked lists
4. The positional list ADT
5. Comparison: Link-based vs. array-based sequences
Stacks
1. The stack ADT and interface
2. Array-based and linked-list implementations
3. Role of stacks in recursion
4. Applications: balanced parentheses, postfix evaluation
Queues
1. The queue ADT and its interface
2. Circular and priority queues
3. Deque (double-ended queue) ADT
4. Array-based and linked-list implementations
5. Applications: scheduling and simulations
Trees
1. Tree terminology and properties
2. Tree traversal algorithms
3. Binary and binary search trees
4. General tree implementations
Balanced Trees
1. Tree balancing operations
2. AVL trees
3. Splay trees
4. 2–3 trees and B-trees
5. Red-black trees
Priority Queues (Heaps)
1. Binary heap
2. Applications of priority queues
3. The selection problem
4. Event simulation
Hashing and Maps
1. Hash functions and efficiency considerations
2. Collision resolution (separate chaining, open addressing)
3. Linear and quadratic probing, double hashing
4. Rehashing and load factor
5. Python dictionaries and sets (hash-based collections)
Sorting Algorithms
1. Insertion sort
2. Shell sort
3. Heapsort
4. Merge sort
5. Quicksort
6. Radix sort
7. Decision trees for sorting
8. Comparative performance analysis
Graph Algorithms
1. Graph terminology
2. Directed, undirected, and acyclic graphs
3. Adjacency list/matrix graph representations
4. The Graph ADT and its operations
5. DFS and BFS traversals
6. Topological sort and DAG scheduling
7. Shortest-path algorithms (unweighted, Dijkstra’s)
8. Minimum spanning trees (Prim’s, Kruskal’s)
9. Network flow overview and applications
Algorithm Design Techniques
1. Divide and conquer algorithms
2. Greedy algorithms (scheduling, Huffman coding, bin packing)
3. Dynamic programming (memoization, tabulation)
4. Backtracking and exhaustive search
5. Randomized algorithms and random number generators

Lab Content

The following programming labs and exercises are designed to help students master the topics learned by providing hands-on practice for a comprehensive understanding of the material:

Lists and ADTs: Implementing lists and abstract data types (ADTs); using iterables and iterators; comparing array-based and linked representations.
Stacks: Expression evaluation, recursion support, and practical applications.
Queues: FIFO structures, circular and priority queues, and basic simulations.
Trees: Implementing and traversing binary trees, search trees, and balanced trees.
Sets and Dictionaries: Building sets and dictionaries, frequency counting, and lookups using built-in types or custom implementations.
Hashing: Hash table construction, collision handling, and efficiency experiments.
Priority Queues (Heaps): Implementing heap operations using the heapq module and solving scheduling problems.
Sorting: Implementing and comparing algorithms across different input types.
Graph Algorithms: Representing graphs as adjacency lists and adjacency matrices, performing traversals, and applying classic algorithms (shortest path, MST, topological sort).

Method(s) of Instruction

Lecture (02)
DE Live Online Lecture (02S)
DE Online Lecture (02X)
Lab (04)
DE Live Online Lab (04S)
DE Online Lab (04X)
Directed/Independent Study (40)

Instructional Techniques

Lecture, demonstration, videos and programming exercises.

Reading Assignments

Students will spend a minimum of 4 hours per week reading the textbook and/or other reading material assigned. Students will be expected to follow along with the exercises in the reading material.

Writing Assignments

Students will spend a minimum of 6 hours per week writing code.

Out-of-class Assignments

Students will spend a minimum of 6 hours weekly completing exercises and/or programming assignments.

Study Non-Contact Hours Recommended

126

Methods of Student Evaluation

Midterm Exam
Final Exam
Short Quizzes
Written Assignments
Projects (Individual/Group)
Problem Solving Exercises

Demonstration of Critical Thinking

Test and quizzes; coding assignments; programming projects, discussion/reflection.

Required Writing, Problem Solving, Skills Demonstration

Written exams; coding assignments; lab exercises; programming projects, short technical reports.

Textbooks Resources

1. Required Horstmann, C.. Big Java, Early Objects , 7th ed. Hoboken, NJ: Wiley, 2018

Resources Subscreen

Textbook: Kent D. Lee , Steve Hubbard. Data Structures and Algorithms with Python. Springer (2024).

Eligible Discipline(s)

Computer science: Master’s degree in computer science or computer engineering OR bachelor’s degree in either of the above AND master’s degree in mathematics, cybernetics, business administration, accounting or engineering OR bachelor’s degree in engineering AND master’s degree in cybernetics, engineering mathematics, or business administration OR bachelor’s degree in mathematics AND master’s degree in cybernetics, engineering mathematics, or business administration OR bachelor’s degree in any of the above AND a master’s degree in information science, computer information systems, or information systems OR the equivalent. Note: Courses in the use of computer programs for application to a particular discipline may be classified, for the minimum qualification purposes, under the discipline of the application. Master's degree required.

Academic Catalogs