UCLA CS 32: Introduction to Computer Science II
CS 32 is UCLA's data structures course in C++, covering recursion, linked lists, stacks, queues, trees, hash tables, and algorithm analysis. Its multi-thousand-line projects, including the famous game-engine project, are a step change in scale from CS 31.
Fennie is independent and not affiliated with UCLA. This is an unofficial study guide.
What makes it hard
The projects are the legend: Project 3 in particular regularly consumes 30+ hours inside an already compressed quarter, and the spec rewards careful reading as much as coding. Exams mix code-writing with data structure theory, and the ten-week format means project crunch and midterms overlap by design.
What you'll cover
- • Object-oriented design and inheritance
- • Recursion
- • Linked lists, stacks, and queues
- • Trees and binary search trees
- • Hash tables
- • Algorithm efficiency and Big-O
The CS 32 study guide
How to study for UCLA CS 32, step by step.
- 1
Re-sharpen CS 31 pointers before day one
CS 32 assumes pointers, dynamic memory, and classes from the first lecture. Rusty pointer skills are the most common cause of early-quarter struggles, so rework that material before the quarter starts.
- 2
Start Project 3 the day it releases
The famous game-engine project regularly consumes 30-50 hours inside a ten-week quarter. Read the spec twice before coding; understanding it deeply saves more time than any debugging skill.
- 3
Map the quarter's collisions in week one
Project deadlines and midterms overlap by design in CS 32. Put every due date and exam on one calendar immediately and plan backward, because discovering a collision in week six is too late.
- 4
Hand-trace structures for the exams
Exams mix code-writing with theory: trace linked-list operations, draw tree insertions, and drill Big-O for every structure. Passing the autograder is not the same skill as exam tracing on paper.
Today
Today's CS 32 plan
What a Fennie Daily Plan looks like for CS 32. Yours is built from your own syllabus and adapts every day to your deadlines and progress.
First plan free, no card required. Fennie is independent and unaffiliated with your school.
FAQ
How hard is CS 32 at UCLA?
It's the most workload-intensive lower-division CS course at UCLA. The material is standard data structures, but the projects are huge for a ten-week quarter; students who start Project 3 the day it's released consistently fare better than stronger programmers who start late.
How long does CS 32 Project 3 take?
Reports of 30-50 hours are common. It's a large object-oriented design project where understanding the spec deeply before coding saves more time than any debugging skill. Start immediately and read the spec twice.
What should I review before CS 32?
Be airtight on CS 31's pointers, dynamic memory, and classes; CS 32 assumes them from day one. Rusty pointer skills are the most common cause of early-quarter struggles.
More UCLA courses
CS 31: Introduction to Computer Science I
CS 31 is UCLA's intro programming course, taught in C++, covering control flow, functions, arrays, pointers, and basic program design. It's the first required course for CS majors and a common choice for engineering and math students adding programming skills.
CS 33: Introduction to Computer Organization
CS 33 is UCLA's computer organization course, taking students below C into machine-level representation, x86-64 assembly, the memory hierarchy and caches, linking, and concurrency basics. It follows CS 32 and is where CS majors first see what their code becomes on real hardware.
CS 35L: Software Construction
CS 35L is UCLA's software-construction course, teaching the practical toolchain upper-division CS assumes: the Unix/Linux command line, shell scripting, Git, build systems, Python and scripting, and a collaborative software project. Long associated with Professor Eggert, it's the course that turns students into functional engineers.
CS 111: Operating Systems Principles
CS 111 is UCLA's operating systems course, covering processes and threads, scheduling, synchronization, memory management and virtual memory, file systems, and protection, with substantial systems-programming projects in C. It's a core upper-division requirement and one of the most respected courses in the major.