UVA CS 2100: Data Structures and Algorithms 1
CS 2100 is the first course of UVA's renumbered CS core — data structures and algorithms in Java, covering lists, stacks, queues, trees, hash tables, and runtime analysis, with required labs alongside lecture. It replaced the old CS 2110/2150 path and is the gateway the rest of the major builds on.
Fennie is independent and not affiliated with University of Virginia. This is an unofficial study guide.
Build my CS 2100 study planWhat makes it hard
Two transitions hit at once: Python to Java (types, compilation, verbosity) and using structures to building them. Linked-structure manipulation and recursion demand reasoning about references abstractly, where trial-and-error coding stops working. The pace assumes CS 111x fluency from day one, and students patching intro-level gaps mid-course fall behind fast.
What you'll cover
- • Java fundamentals and object-oriented programming
- • Lists, stacks, and queues
- • Linked structures and references
- • Recursion
- • Trees and binary search trees
- • Hash tables
- • Big-O runtime analysis
The CS 2100 study guide
How to study for UVA CS 2100, step by step.
- 1
Front-load the Java transition
Types, compilation, and class syntax are friction you can't afford while learning data structures on top. Spend the first two weeks writing small Java programs daily until the language itself stops costing thought.
- 2
Draw every linked-structure operation
For each insert, delete, and traversal, diagram what every reference points to before and after the operation. Exams test this by hand, and the diagram habit is the difference between reasoning and guessing.
- 3
Build an inductive mental model for recursion
Trust the recursive call to handle the smaller case while you verify one frame. Tracing every call of every example burns students out; the inductive leap is the actual skill.
- 4
Attach a runtime to everything you write
Note the Big-O of each method as you implement it and be ready to defend it. Runtime questions are fixed exam material and free points for students who made the habit early.
- 5
Start assignments the day they release
Debugging reference bugs and recursion takes calendar days, not heroic nights. The students above the curve are the ones who started early, almost without exception.
- 6
Space the hard topics with Fennie
Upload your CS 2100 syllabus and Fennie's Daily Plan spreads linked-list and recursion practice across weeks, paces review to exam dates, and generates quizzes from the actual course content. Free to start.
Start my CS 2100 plan free
How Fennie helps with CS 2100
Fennie's Daily Plans give CS 2100's stacked transitions — Python to Java, using structures to building them — the spaced practice they need, paced to labs, assignments, and exams. Chat traces what every reference points to through each operation and what each recursive call does, until you can run the code in your head, which is exactly what the exams test.
FAQ
Is CS 2100 at UVA hard?
It's the CS major's first real filter. You're learning Java while also learning to build linked structures and reason about recursion — two transitions at once. Students who start assignments early and practice hand-tracing get through; deadline coders and pattern-matchers are who the curve exposes.
What happened to CS 2110 and CS 2150 at UVA?
They were retired in the CS curriculum renumbering. The current core is CS 2100 (DSA 1), CS 2120 (Discrete Math and Theory 1), CS 2130 (Computer Systems and Organization 1), and CS 3100 (DSA 2). If you see advice referencing 2110 or 2150, it's about the old curriculum — the content roughly maps but the courses differ.
How do I prepare for CS 2100?
Make sure CS 1110/1111 material is genuinely fluent — functions, lists, basic objects — and get a head start on Java syntax before the semester. During the course, draw diagrams for every linked-structure operation and start assignments the day they release; both habits separate the top of the curve from the middle.
Pass CS 2100 with a plan, not a cram
Upload your CS 2100 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 UVA courses
CS 1110 — Introduction to Programming
CS 1110 is UVA's Python-based introduction to programming, assuming no prior experience — the entry point for prospective CS majors, minors, and a wide range of other students. It covers variables, control flow, functions, lists and dictionaries, file handling, and basic objects, with weekly labs and programming assignments.
CS 2120 — Discrete Mathematics and Theory 1
CS 2120 is the discrete math course of UVA's CS core — logic, proofs, sets, functions, induction, and basic graph and number theory — the mathematical foundation for algorithms and theory courses later in the major. It's most students' first proof-based course.
CS 2130 — Computer Systems and Organization 1
CS 2130 takes UVA CS students below the languages they know — binary representation, gates and circuits, assembly, and C programming with pointers and memory — building a working model of how computers actually execute code. Labs run alongside lecture, and it leads into CSO2.
CS 3100 — Data Structures and Algorithms 2
CS 3100 is the algorithms half of UVA's DSA pair — graph algorithms, greedy methods, divide and conquer, and dynamic programming, with runtime analysis and correctness reasoning throughout. It draws directly on both CS 2100's structures and CS 2120's proof techniques.