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.

Build my CS 32 study plan

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.
5
Let Fennie defuse the crunch
Upload the CS 32 syllabus and Fennie's Daily Plans schedule project starts early and exam prep continuously — exactly the collision this course engineers — with Big-O flashcards and quizzes generated from your actual materials. Free to start, and the project code stays yours.
Start my CS 32 plan free

How Fennie helps with CS 32

Fennie's Daily Plans are built for exactly the CS 32 problem: projects and midterms colliding in a ten-week quarter, solved by starting everything early on a schedule. Use chat to reason through data structure trade-offs and recursion until they're second nature, and quiz yourself on Big-O and tree operations before each exam — the projects themselves are your own work.

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.

Pass CS 32 with a plan, not a cram

Upload your CS 32 materials and Fennie generates a Daily Plan paced to your deadline — plus chat, flashcards, and quizzes built from the actual course content.

Get started free

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.