UMN CSCI 1933: Introduction to Algorithms and Program Development
CSCI 1933 is the second course in UMN's CS sequence, taught in Java. It covers object-oriented design, basic data structures like linked lists and binary trees, recursion, and intro algorithm analysis. It's the bridge from 'I can write Python' to 'I can build software,' and CS-major admission math makes its grade matter.
Fennie is independent and not affiliated with University of Minnesota Twin Cities. This is an unofficial study guide.
What makes it hard
The double transition is the trap: a new language (Java's types, compilation, and verbosity after Python) and genuinely harder material (implementing data structures rather than only using them) at the same time. Projects are substantially longer than 1133's, and students who start them late discover that debugging linked structures takes days, not nights.
What you'll cover
- • Java and object-oriented design
- • Inheritance and interfaces
- • Linked lists, stacks, and queues
- • Binary trees
- • Recursion in depth
- • Intro algorithm analysis and Big-O
The CSCI 1933 study guide
How to study for UMN CSCI 1933, step by step.
- 1
Get past Java's friction in the first two weeks
Types, compilation errors, and class boilerplate feel hostile after Python. Write small Java programs daily early on so the language stops costing attention before the data structures arrive.
- 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 what makes the code writable.
- 3
Start projects the day they're released
CSCI 1933 projects are a step up in length and debugging linked structures eats calendar days. The grade gap between early starters and deadline coders is the most predictable pattern in the course.
- 4
Attach Big-O to everything you implement
Note the runtime of each method as you write it and be able to justify it. Analysis questions are reliable exam points, and the habit builds the intuition CSCI 4041 will later assume.
- 5
Keep recursion sharp from 1133
Trees make recursion load-bearing rather than optional. If recursive thinking was shaky in 1133, rehab it in week one. This course assumes it and builds on it immediately.
Today
Today's CSCI 1933 plan
What a Fennie Daily Plan looks like for CSCI 1933. 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 CSCI 1933 at UMN hard?
It's the course where the CS sequence gets real: a new language (Java) plus implementing data structures, with projects much longer than 1133's. Students who start projects early and practice tracing linked structures consistently get through; deadline coders struggle visibly.
How is CSCI 1933 different from CSCI 1133?
1133 teaches you to program (Python); 1933 teaches you to build and analyze (Java, data structures, Big-O). The projects are longer, the grading is stricter, and the material assumes 1133's fundamentals are fluent.
Does CSCI 1933 matter for getting into the CS major?
Yes. Performance in the intro CSCI sequence factors into CS-major admission at UMN, so the grade carries real weight. Treat it as a course to master rather than merely pass.
More UMN courses
CSCI 1133: Introduction to Computing and Programming Concepts
CSCI 1133 is UMN's first programming course, taught in Python. It covers problem solving, control flow, functions, recursion, and intro object-oriented programming, and it's required for CS majors and taken by a wide range of CSE students. Lectures pair with weekly lab sections where you write code under TA supervision.
CSCI 2011: Discrete Structures of Computer Science
CSCI 2011 is UMN's discrete math course for CS majors: logic, proof techniques, sets, functions, induction, counting, and graph basics. It's the first math course most students take where the answer is an argument, not a number, and it underpins everything from algorithms to theory of computation.
CSCI 2021: Machine Architecture and Organization
CSCI 2021 takes UMN CS students below the languages they know: C programming, memory and pointers, data representation, x86-64 assembly, the memory hierarchy, and how programs actually execute. Projects involve real C code and binary-level reasoning, and the course is a prerequisite gate for the systems track.
CSCI 4041: Algorithms and Data Structures
CSCI 4041 is UMN's core algorithms course: sorting, heaps, hash tables, balanced trees, graph algorithms, dynamic programming, and the analysis machinery to reason about all of it. It's required for the CS major, central to technical interview prep, and widely named among the major's most demanding courses.