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.
What 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.
Today
Today's CS 2100 plan
What a Fennie Daily Plan looks like for CS 2100. 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 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.
More UVA courses
CS 1110: Introduction to Programming
CS 1110 is UVA's Python-based introduction to programming, assuming no prior experience. It is the entry point for prospective CS majors, minors, and a wide range of other students, covering 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. It is the mathematical foundation for algorithms and theory courses later in the major, and 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. The goal is 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.