PassProfessor’s Computer Science II program is part of the expanding PassProfessor catalog. The program is organized chapter by chapter for chapter-based simulation exams matched to your textbook’s organization. Join the notify list and we will email you the day it opens — then use this guide to plan your studying.
This program is part of the expanding PassProfessor catalog — join the notify list and we’ll email you when enrollment opens.
This guide presents the standard scope of the undergraduate computer science II course — the data structures course — as general disciplinary background: program design with classes and generics in outline, recursion, algorithm analysis and Big-O, array-based and linked lists, stacks and queues, trees and binary search trees, heaps and priority queues, hash tables, sets and maps, graphs and traversals, and sorting and searching algorithms with their costs. It explains who takes the course, how its structures build on each other, how computing courses are honestly graded (your syllabus is the only authority), and a study method built for a course that grades both code and analysis. PassProfessor’s companion program organizes original practice chapter by chapter against this scope.
Computer Science II, in one paragraph
Computer Science II is the second course in the computing sequence — the data structures course: recursion and algorithm analysis with Big-O, lists in array and linked implementations, stacks and queues, trees and binary search trees, heaps and priority queues, hash tables, sets and maps, graphs and their traversals, and the sorting and searching algorithms, each presented as an abstract data type with interchangeable implementations at different costs. Its professional skill is selection: reading a workload and defending the structure whose ledger of operation costs fits it.
Who takes computer science II, and why?
Computer Science II is the gateway course of the computing major, and its audience is set by that role:
- Computer science majors in their first or second year take it as the required sequel to the introductory course — the point where the major’s real subject, data structures, begins.
- Software engineering, data science, and related computing students take it because every later course in their programs — databases, systems, algorithms, machine learning — assumes its structures and its cost language.
- Students from other majors adding computing in mathematics, engineering, and the sciences take it as the second step of a minor or a double major, and meet programming at design scale for the first time.
Whichever path you are on, the scope of the course itself is broadly the same — the discipline has a settled core, and undergraduate courses teach that core in a recognizable order. Instructors differ in emphasis, depth, and exam style; they rarely differ in what the subject is.
The course, piece by piece
The standard computer science II course moves through five broad blocks. The table below describes each block’s content as general disciplinary knowledge — this is the background every student in the course is expected to build, whatever textbook their course assigns.
| Course block | What it covers |
|---|---|
| Foundations | Abstraction and generics in outline, recursion, and algorithm analysis. The course’s two languages — how components are specified, and how their costs are stated — before any structure is built. |
| Linear structures | Lists in both implementations, stacks, and queues. Sequences with discipline: what order elements enter, leave, and are reached, and what each discipline costs. |
| Tree structures | Trees and binary search trees, then heaps and priority queues. Hierarchy and partial order — searching and selection made faster by shape. |
| Hashing and collections | Hash tables, then sets and maps. Membership and association at average-case speed, with the course’s implementation-choice argument stated in full. |
| Graphs, sorting, and design | Graphs and traversals, sorting, searching compared, and integrated design in outline. The general case, the classical algorithms, and the professional skill of choosing. |
Three structural facts about the course shape how you should study it:
- Abstract data type and implementation are different things. A stack is a contract — push, pop, peek — that arrays and linked nodes both honor at different costs. The course’s most common exam trap is an item that changes the implementation and asks what changed: the behavior, nothing; the costs, everything.
- Every operation has a price, and the course keeps the ledger. Big-O costs are attached to operations from the lists chapter onward, and cumulative items are workload problems: given a mix of insertions, lookups, and deletions, total the ledger for each candidate structure. Selection, not memorization, is the graded act.
- Shape is a hidden variable in half the structures. Search trees degenerate into lists, hash tables degrade as they fill, heaps depend on completeness. Exams test the shape conditions — insertion order, load factor, balance in outline — because a structure’s guarantees are statements about its shape.
How computer science II courses are graded — honestly
There is no official answer here, and any page that gives you one is inventing it. Computer Science II has no administering body, no published exam format, no passing standard, and no retake policy, because it is not a licensing exam. Your instructor sets the number and format of chapter tests and unit exams, whether homework, projects, or participation are graded separately, and what the final covers. Your course syllabus is the only authority for all of that, and the first study act of the semester is reading it closely: note the exam dates, the chapters each exam covers, and whether the final is cumulative. What this guide can give you is the discipline’s standard scope (above), a chapter-by-chapter walk through the course (below), and a study method built for a cumulative, chapter-organized course — the things that transfer between instructors.
One more honesty note, because students ask: the components differ, but their logic does not. Homework and chapter quizzes reward steady contact with the material while it is current. Unit exams reward integration across a block of chapters. A cumulative final rewards retention — the willingness to keep early chapters retrievable after the course has moved on. A study plan that only ever serves the next test therefore mis-serves the final by design, which is why the planning section below treats retention as a standing task rather than an end-of-term emergency.
A note on editions, ordering, and local variation
No two sections of this course are identical, and the differences are worth naming precisely so you can discount them correctly. Textbooks divide the same scope differently: a topic that is one chapter in one book is two in another, and closing topics migrate between the end of this course and the start of the next in the sequence. Instructors reorder within that freedom — some front-load the chapters their later coursework needs most, some follow their book exactly. Assessment differs more than content does: one section’s midterm is another’s two unit exams, and project, participation, and homework weights are local decisions all the way down.
What does not vary is the discipline’s core: the scope summarized in this guide, the order in which its ideas depend on each other, and the points where students predictably lose marks. Those are properties of the subject, not of any syllabus. Plan against your own syllabus for dates and weights; plan against this guide for scope, sequence, and trouble spots — and when the two seem to disagree, your syllabus governs your grade while the guide still describes your subject.
How to study for computer science II
- *Read the syllabus like a contract.* Note how your course divides weight among written exams, programming assignments, and any lab or project work — computing courses grade code and analysis separately, and the syllabus’s split decides where study hours earn most.
- *Trace by hand before you code.* Pointer changes, traversals, percolations, probe sequences: draw them on paper until the trace is reliable. Code written from a sound trace debugs quickly; code written instead of a trace debugs all night.
- *Keep a cost table you build yourself.* One row per structure, one column per operation, filled in as each chapter lands. Building the table is the studying; by the final it is also the course’s single most useful review document.
- *Implement each structure once, cleanly.* A working list, stack, tree, and hash table of your own — however small — converts recognition into command. Reading implementations produces the feeling of knowledge; exams and assignments test the other kind.
- *Drill your weakest chapter, not your favorite.* Chapter results expose the leak — commonly pointer manipulation or Big-O of nested and recursive code. Analysis and implementation weaknesses compound, because later chapters assume both.
- *Simulate the written exams under time.* Sit timed sets of traces, cost questions, and short design items over exactly the chapters the test covers. Written computing exams are pacing tests as much as knowledge tests.
Planning the semester, block by block
A chapter-organized course has a rhythm, and planning in its rhythm beats planning against the calendar alone. The course moves through five broad blocks, from abstraction, classes, and generics, in outline to choosing a structure — integrated design work, in outline, and each block changes what good studying looks like.
In the opening block, the work is foundation: new vocabulary, new notation or procedure, and the first habits of the discipline. Study time here should be weighted toward accuracy over speed — slow, checked work that builds the representations everything else will stand on. Errors made carelessly in the first block are the most expensive in the course, because later chapters inherit them silently.
In the middle blocks, the work is integration. Chapters begin to cite each other: techniques combine, distinctions multiply, and exam items stop announcing which chapter they belong to. This is where mixed practice earns its keep — sets that draw from several chapters at once, so the skill being trained is recognizing which tool a problem wants, not merely executing the tool of the week. It is also where most students discover their real weak chapter, usually an early one whose gap only becomes visible when a later chapter spends it.
In the closing block, the work is consolidation under time. The material is mostly familiar; the challenge is retrieval speed and endurance across the full scope. Timed, cumulative practice is the right instrument here, and the correct measure of readiness is a cold solve — a problem answered correctly days after its chapter was last reviewed, without a warm-up set first.
Across all three phases, one habit separates the students who finish strong: a standing review rotation. A short weekly pass over earlier chapters — a handful of items from each, answered cold — keeps the early scope retrievable at trivial cost, and converts the final from a re-learning project into a review. The rotation is deliberately boring. That is what makes it work: it does not depend on motivation, deadlines, or panic, and it compounds quietly from the second week of the term onward.
The chapters, one by one
From CS I to CS II: Abstraction and Generics in Outline. In outline: the shift from writing programs to designing components — classes and interfaces as contracts, abstraction barriers, and generic types that let one structure hold any element type. The chapter sets the course’s vocabulary: behavior is specified first; implementation is chosen afterward, and can be changed.
Recursion. Functions that call themselves: base cases, recursive cases, tracing call stacks, and recursive algorithms over numbers, strings, and structures. Recursion is both a technique and the course’s first induction in disguise — the same reasoning that proves a recursive method correct designs it.
Algorithm Analysis and Big-O. Counting cost instead of seconds: growth rates, Big-O, Omega, and Theta in working use, worst and average cases, and the cost of loops, nested loops, and recursive recurrences in outline. This chapter supplies the language in which every later structure’s operations are priced and compared.
Lists: Array-Based and Linked Implementations. The list as an abstract data type, implemented twice: arrays with shifting and resizing, and linked nodes with pointer discipline — insertion, deletion, traversal, and the iterator pattern. The paired implementations teach the course’s central lesson: same behavior, different costs, chosen by use.
Stacks. Last-in, first-out discipline: the stack operations, array and linked implementations, and the canonical applications — expression evaluation, delimiter matching, undo, and the call stack revisited. Small structure, long reach: half its exam value is recognizing stack-shaped problems in disguise.
Queues and Deques. First-in, first-out discipline: queue operations, the circular array implementation and its wasted-slot bookkeeping, linked queues, and deques in outline. Simulation and scheduling give the chapter its applications, and the contrast with stacks — order preserved against order reversed — is its standard exam item.
Trees and Binary Search Trees. Hierarchy as a structure: tree vocabulary, traversals in their three orders, binary trees, and the binary search tree with its search, insertion, and three-case deletion. Balanced and degenerate shapes introduce the course’s recurring theme — a structure’s guarantees depend on its shape, not its intentions.
Heaps and Priority Queues. The heap as a nearly complete tree stored in an array: percolation up and down, building a heap efficiently, and the priority queue it implements — plus heapsort in outline. Index arithmetic replaces pointers here, and tracing that arithmetic precisely is the chapter’s graded skill.
Hash Tables. Direct addressing by computation: hash functions, collision resolution by chaining and open addressing, probing sequences, load factor, and rehashing. Average speed against worst-case honesty is the chapter’s argument, and choosing — or criticizing — a hash function is its most characteristic exam task.
Sets and Maps. Collections defined by membership and association: the set and map abstract data types, their tree-based and hash-based implementations, and the design question they pose — what operations must be fast decides what lives underneath. The chapter generalizes the course: ADTs first, implementations as interchangeable engines.
Graphs and Their Traversals. Vertices, edges, and the two standard representations — adjacency matrix against adjacency lists — with breadth-first and depth-first traversal, connected components, and shortest paths in outline. Graphs are where structure choice has the least default answer, so representation costs are examined comparatively from the start.
Sorting Algorithms. Ordering as a studied problem: the elementary sorts and their quadratic costs, mergesort’s divide and conquer, quicksort and its pivot discipline, heapsort in outline, and lower-bound reasoning in brief. Exams grade tracing, cost analysis, and algorithm selection for a described workload — rarely code production alone.
Searching and Search Structures Compared. Finding as a studied problem: sequential and binary search with their preconditions, and the course’s structures repriced as search engines — lists, search trees, heaps, and hash tables against a workload’s mix of insertions, deletions, and lookups. Comparison, the course’s closing argument, is made explicit here.
Choosing a Structure: Integrated Design in Outline. In outline: design case work — reading a problem’s operation mix, constraints, and data shape, then defending a structure choice with costs. Most courses run this as projects and cumulative review rather than a taught unit; the outline mirrors that reality and closes the course where practice begins.
Where students lose points
Pointer updates in the wrong order
Linked-list insertions and deletions lose the rest of the list when a reference is overwritten before its successor is saved. The repair is ritual: draw the nodes, number the pointer changes, and never let a step destroy the only path to a node that is still needed.
Big-O answered from the code’s appearance
Nested loops get reflexively labeled quadratic even when the inner loop’s bound shrinks, and recursive costs get guessed from the number of calls alone. Count operations against input size deliberately — write the sum or the recurrence — rather than pattern-matching the code’s silhouette.
Binary search tree deletion improvised case by case
The three cases — leaf, one child, two children — collapse into ad hoc rewiring that breaks the ordering invariant. Learn deletion as the cases, with the successor rule for the two-child case stated in words before any diagram is drawn.
Hashing treated as magic rather than arithmetic
Students trust the table and cannot trace a probe sequence, predict clustering, or say when rehashing triggers. Work collisions by hand at high load factors; the table’s average-case speed is a claim about arithmetic the student should be able to reproduce.
Frequently asked questions
What is Computer Science II actually about? Data structures and their costs: how information is organized in memory — lists, stacks, queues, trees, heaps, hash tables, graphs — how the classical algorithms over them work, and how to choose among them by analyzing what each operation costs at scale.
Why does the second course change character from the first? Computer Science I teaches expressing solutions as programs. Once programs manipulate large collections, organization dominates: the same task runs instantly or never finishes depending on the structure underneath. The second course exists because that difference — not syntax — is the discipline’s core.
What is an abstract data type? A specification of behavior — what operations exist and what they promise — separated from any implementation. A queue is an ADT; a circular array and a linked list are two implementations of it. The separation lets programs be written against contracts and implementations be swapped by cost.
What does Big-O actually tell me? How an operation’s cost grows as input grows, ignoring constant factors and small inputs: constant, logarithmic, linear, linearithmic, quadratic. It predicts scaling behavior — which structure survives a workload a thousand times larger — not stopwatch times on one machine.
Array list or linked list — which is better? Neither, unconditionally: arrays win at random access and lose at mid-list insertion; linked lists invert both. The course’s recurring exercise is reading a workload’s operation mix and letting the ledger decide — the question ‘which is better’ is incomplete without ‘for what.’
Why are hash tables fast if collisions happen? Because a good hash function spreads keys so collisions stay rare at sane load factors, making lookup average-case constant. The honesty is in the qualifiers — average, good function, load factor — and the course examines all three rather than the slogan.
What is the hardest part of the course? For most students, two things: pointer discipline in linked structures, where one misordered update corrupts a list, and analysis, where costs must be counted rather than intuited. Both yield to the same remedy — slow, drawn, by-hand tracing in practice.
How is this course graded? By your instructor’s syllabus: typically written exams over traces, analysis, and concepts, plus programming assignments graded separately, and sometimes lab or project work. There is no external standard — the syllabus is the only authority, and this guide invents none.
How should I study for Computer Science II? Trace everything by hand first — pointers, traversals, probes, sorts — keep a self-built cost table across all structures, and implement each structure once yourself. Then rehearse written exams timed, because traces and analysis under pacing are the graded performance.
Does the course use a particular language? Institutions choose — commonly a mainstream object-oriented language — and the choice is stated in your syllabus. The structures, invariants, and costs are language-independent; syntax is the vehicle, not the subject, which is why the guide names none.
What comes after Computer Science II? Algorithms courses deepen the analysis, databases build on trees and hashing, operating systems spend queues and graphs, and software engineering builds on the abstraction habits. The course is the major’s load-bearing wall; later courses assume it held.
What is recursion doing in a structures course? Trees are recursive structures, the elegant sorts are recursive algorithms, and traversing either is unnatural iteratively. Recursion arrives early because the course’s second half is written in it — and because its correctness reasoning, induction, returns in the algorithms course.
Is Computer Science II the same as a data structures course? Yes — at most institutions the second course in the sequence is the data structures course, under one name or the other. Syllabi vary in chapter order and depth, but the structural core — the structures, their costs, and their algorithms — is the settled content this guide describes.
Using this guide with the practice program
This guide and the companion Computer Science II practice program are built to be used together, in a specific order. The guide comes first: read the block map and the chapter walk for the part of the course you are entering, so the scope and the trouble spots are familiar before you practice against them. Forewarned is a real effect in a cumulative course — knowing where students lose points in a chapter changes what you notice while your instructor teaches it.
Then practice in the program’s own rhythm. Drill the chapter you are currently in while it is current, in short sets, and let the chapter-level results tell you the truth about the chapter while repair is still cheap. When a graded test approaches, switch instruments: a timed simulation over exactly the chapters the test covers, taken in one sitting, under the same constraints your syllabus describes. Afterward, return to this guide’s trouble-spot section for the chapters the simulation exposed — the diagnosis there is written for exactly that moment.
Before midterms and finals, widen the lens. Work the integrated material that combines chapters, because cumulative exams are written that way, and re-read the structural facts at the top of this guide: they describe how the course’s parts connect, which is what a final actually examines. If a chapter’s results stay weak after honest drilling, treat that as information about sequence, not effort — in a course built like this one, a stubborn chapter is usually standing on a cracked earlier one, and the repair belongs there.
A last word on what neither this guide nor the program can do. Neither can read your syllabus, attend your lectures, or know your instructor’s emphases — the local facts that decide real grades. Use both as they are designed to be used: as the discipline-level map and rehearsal space that make your own course’s local facts easier to master, week by week, while the semester is still young enough for the work to compound.
Disclaimer
PassProfessor is an independent exam-preparation and study provider, based in Salt Lake City, UT and operating entirely online. This guide is general course background and study guidance only: it is not affiliated with, endorsed by, or sponsored by any textbook publisher, textbook author, college, university, or instructor, and it reproduces no textbook content. Your course syllabus is the authority for your course’s schedule, formats, and grading.