Rutgers CS 112: Data Structures
CS 112 (01:198:112) is the second core CS course at Rutgers, covering linked lists, stacks, queues, trees, hash tables, and graphs in Java, along with algorithm analysis. It's a prerequisite gate for nearly all upper-level CS courses and a key input for declaring the major.
Fennie is independent and not affiliated with Rutgers University. This is an unofficial study guide.
Build my CS 112 study planWhat makes it hard
CS 112 is widely considered harder than CS 111 — the projects are bigger, the exam problems require implementing and analyzing structures rather than using them, and Big-O analysis shows up everywhere. Students who passed 111 on assignment grades alone often hit a wall when exams demand writing linked-structure code from scratch.
What you'll cover
- • Linked lists
- • Stacks and queues
- • Binary trees and BSTs
- • Hash tables
- • Graphs and traversals
- • Big-O analysis and sorting
The CS 112 study guide
How to study for Rutgers CS 112, step by step.
- 1
Refresh CS 111 Java and recursion before day one
CS 112 assumes object and recursion fluency immediately. A week of review before the semester — rewriting a recursive method or two from scratch — prevents the early drowning that sinks so many students.
- 2
Implement every structure yourself at least once
Reading the provided linked list code is not knowing linked lists. Build each structure in a scratch project — exams ask you to write linked-node and tree code from a blank page.
- 3
Start projects the week they're assigned
CS 112 projects are bigger than anything in 111 and the debugging tail is long. The students who start late are the ones who lose both the project points and the exam-prep time.
- 4
Drill Big-O until it's reflexive
Runtime analysis appears on every exam. For each structure, know the complexity of every operation and be able to justify it — then practice on past department exams under time pressure.
- 5
Spread it all out with Fennie
Upload the CS 112 syllabus and Fennie's Daily Plan gives each data structure implementation practice before the next one arrives, paced to your project deadlines and exams, with complexity flashcards generated from your actual materials. Free to start.
Start my CS 112 plan free
How Fennie helps with CS 112
Fennie's Daily Plans spread CS 112's data structures across the semester so each one gets implementation practice before the next arrives. Chat through pointer manipulation in linked lists or why an operation is O(log n), and drill flashcards on runtime complexities — guaranteed exam material.
FAQ
Is CS 112 harder than CS 111?
Most Rutgers students say yes. The conceptual load is higher, the projects are longer, and exams test implementing structures from scratch plus runtime analysis.
What grade do I need in CS 112 to declare the CS major?
Rutgers CS has GPA-based declaration requirements tied to CS 111/112 and the math prerequisites. Check the current department requirements, as thresholds have changed over the years.
How should I prepare for CS 112?
Be fluent in Java objects and recursion before day one — CS 112 assumes it. During the course, implement every structure yourself at least once rather than just reading the provided code.
Pass CS 112 with a plan, not a cram
Upload your CS 112 materials and Fennie generates a Daily Plan paced to your deadline — plus chat, flashcards, and quizzes built from the actual course content.
Get started freeMore Rutgers courses
CS 111 — Introduction to Computer Science
CS 111 (01:198:111) is the first course for Rutgers CS majors and minors, taught in Java. It covers programming fundamentals — variables, loops, arrays, recursion, and basic object-oriented concepts — through autograded programming assignments and high-stakes exams.
CS 205 — Introduction to Discrete Structures I
CS 205 (01:198:205) is Rutgers' discrete math course for CS majors: logic, proofs, sets, functions, relations, and combinatorics. It's the theory backbone for later courses like algorithms, and it runs alongside the programming sequence.
CS 211 — Computer Architecture
CS 211 (01:198:211) covers the fundamentals of modern computer systems: C programming, data representation and computer arithmetic, assembly language, Boolean algebra and digital logic, and the design of the processor, cache, and memory. It's where Rutgers CS students drop from Java down to the machine.
CS 214 — Systems Programming
CS 214 (01:198:214) teaches students to build, debug, and test large programs in C on Unix, with heavy emphasis on tools — debuggers, profilers, version control, and IDEs — and on understanding how programs execute and how to measure and optimize performance. It's a core systems course in the Rutgers CS curriculum.