Cornell CS 2110: Object-Oriented Programming and Data Structures
CS 2110 is Cornell's second programming course, taught in Java and cross-listed as ENGRD 2110. It covers object-oriented design, data structures (lists, trees, hash tables, graphs), recursion, and an introduction to algorithmic analysis. It's the gateway most CS and engineering students name as the major's first real workload jump.
Fennie is independent and not affiliated with Cornell University. This is an unofficial study guide.
What makes it hard
The switch to Java plus the leap into real data structures hits at once: you reason about references, interfaces, and generics while assignments grow long and exams test implementing and tracing structures by hand. Trees, graphs, and recursion are the famous walls, and the curve reflects a class where pattern-copying stops working and genuine understanding shows.
What you'll cover
- • Object-oriented design in Java
- • Recursion
- • Lists, stacks, and queues
- • Trees and binary search trees
- • Hash tables
- • Graphs and graph algorithms
- • Big-O and runtime analysis
The CS 2110 study guide
How to study for Cornell CS 2110, step by step.
- 1
Get fluent in Java fast
If CS 1110 was Python, the syntax, static typing, and interfaces of Java are a real adjustment on top of harder material. Spend the first week getting comfortable so language friction isn't stacked on data-structure difficulty.
- 2
Draw every structure operation
For each insert, delete, and traversal on a list, tree, or graph, diagram what every reference points to before and after. Visual tracing is the skill the course builds, and prelims test it by hand.
- 3
Think inductively about recursion
Trust the recursive call to solve the smaller case while you reason about one frame. The students who trace every call of every example burn out; the inductive mental model is what makes recursion and tree algorithms click.
- 4
Start assignments the day they're released
Assignments get long, and debugging linked structures and recursion takes calendar days, not heroic nights. The curve fully exposes the gap between early starters and deadline coders.
- 5
Attach Big-O to everything you write
Note the runtime of each method as you implement it and be ready to justify it. Runtime-analysis questions are reliable prelim material and pure points for students who made it a habit.
Today
Today's CS 2110 plan
What a Fennie Daily Plan looks like for CS 2110. 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
Is CS 2110 at Cornell hard?
It's widely called the major's first big workload jump. The move to Java plus real data structures (trees, graphs, recursion) demands abstract reasoning that brute-force coding can't fake, and prelims test hand-implementation. Starting assignments early and practicing tracing gets students through.
What language is CS 2110 taught in?
Java. The course uses it to teach object-oriented design alongside data structures and algorithms, with an emphasis on interfaces, generics, and reasoning about references, a step up from the Python or MATLAB of the intro course.
Do I need CS 1110 before CS 2110?
Yes. CS 1110 or CS 1112 (or equivalent) is the prerequisite. CS 2110 assumes you can already write and trace basic programs, so it moves quickly into design and data structures rather than reviewing fundamentals.
More Cornell courses
CS 1110: Introduction to Computing: A Design and Development Perspective
CS 1110 is Cornell's Python-based first programming course, covering variables and types, functions, conditionals and loops, objects and classes, recursion, and testing. It's taken by intended CS majors and a large non-major population alike, and it leads into CS 2110 for those continuing in the major.
CS 2800: Discrete Structures
CS 2800 is Cornell's discrete mathematics course for CS majors, covering logic and proof, induction, sets, functions and relations, combinatorics, graph theory, basic probability, and finite-state machines. It's the bridge from coding to the mathematical reasoning the upper-level theory courses assume.
CS 3110: Data Structures and Functional Programming
CS 3110 is Cornell's famous functional-programming and data-structures course, taught in OCaml. It covers immutability, recursion, higher-order functions, modules and functors, formal specification and verification, and reasoning about correctness and complexity. It's a required CS core course and a notorious pace step-up after CS 2110.
CS 4820: Introduction to Analysis of Algorithms
CS 4820 is Cornell's upper-level algorithms course, covering greedy algorithms, divide and conquer, dynamic programming, network flow, and NP-completeness and reductions, with a heavy emphasis on proving correctness and analyzing complexity. It's a required CS core course and a capstone of the theory sequence.