CMSI 2120

CMSI 2120 - Data Structures Syllabus

20 min read

Professor Tainã Coleman • taina.coleman[at]lmu.edu • Fall 2026

CMSI 2120 is a 4-Unit intermediate-level programming class that teaches students how to craft efficient and space-conscientious applications by analyzing and then choosing the “right” data organization for a task. Although Java is the course’s language of focus, students will learn core concepts that permeate all programming languages, as well as language-agnostic tools to analyze and think deeply about implemented algorithms.

Learning Outcomes

By the course’s end, students will:

  • gain experience with an enterprise programming language (Java), advanced topics in object-oriented programming, and software development best practices, logistics, and test-driven development.
  • understand analytic programming concepts such as asymptotics, time-complexity, and space-complexity — that not all programs are created equal; two programs that perform the same task may not do so with the same efficiency or cleanliness.
  • be introduced to a wide range of Data Structures and Abstract Data Types (ADTs), learning which are best suited for which tasks, including: lists, stacks, queues, heaps, priority queues, hash tables, sets, maps, trees, search trees, tries, and graphs.
  • gain a deeper understanding of class hierarchies and inheritance, object-oriented programming, and both implementing and applying data structures programmatically.
  • learn the interfaces for popular Java collections, and how to use them in a variety of non-trivial programming tasks.
  • identify beneficial and detrimental interactions between ADTs and algorithms that operate with them.

Prerequisites

Prerequisites

Before taking this course, you must have strong foundations in the fundamentals of programming (CMSI 185).

This class uses Java for its concrete examples, homework, and exams. We will spend the first few weeks of the course covering the Java necessary to succeed in the course and beyond, though we will not dwell on basics like how or when to use iteration or conditionals.

If you require additional practice, you may learn through our textbook (see next section) and any number of online tutorials — a list of which can be found on this LMU CMSI resources page.

Git and GitHub

Additionally, you should be comfortable with the fundamentals of Git, and managing GitHub repositories.

We will be using PostCommit for assignment distribution and collection, so advance comfort with these tools will make your life easy.

Need a refresher? Take a look at the GitHub Tutorials here.

Texts

We will be “using” two optional textbooks for the course, which will primarily cover or dive deeper into the theoretical material than we have the time to during lecture:

Although these specific texts are not mandatory for the course, they contain all concepts that we will be covering in great detail, and your exams will expect that you deeply understand these concepts.

These are also popular textbooks with many editions; any edition will likely match what we cover in the course, so you may purchase whichever you like (if any).

Additionally, I will provide abbreviated course notes for our lectures on my course page (see Notes tab)

Resources will be provided throughout the course detailing any additional topics that are not sufficiently contained in the above text. These resources will be free and publicly available.

Lecture Attendance

Lecture attendance is mandatory and counts for 5% of your grade (see Grade Decomposition). You may miss up to 2 classes without your grade being impacted. If you miss class you’ll be missing out on lecture content that will not be posted online, classwork (see below), and hints for homework and exams. If you miss a lecture, the important points will be sketched in our course notes posted on this site’s Notes tab.

Lectures are participatory in nature, often with exercises and group-work to facilitate learning. Laptops are discouraged for note-taking, but encouraged for working on in-class problems.

Workload Expectations

As this is a 4-Unit class, it is expected that you will be allocating an average of 9 hours outside of lectures per week working on course assignments, reading, and studying. Some weeks will have less material to keep you busy, and others more, but be aware that this is a work-intensive course that may require you to spend a lot of time programming!

Slack Messaging

Alongside email exchanges, you may reach me via the Slack messaging service (Slack is a chat client that can be downloaded here) in the LMUCS channel (lmucs.slack.com).

Office Hours

Attending on Zoom

Please message me on email or Slack to let me know you are attending office hours on Zoom.

Teaching Assistants

In addition to my office hours, this course has the following stellar TAs who are versed in its topics and are here to help:

  • Erika Siao and Danny Divinsky
  • Office hours: see the TA Schedule

Tentative Schedule of Topics

The following constitutes the tentative schedule for topics to be covered in the course. This is largely an approximation for what we will cover each lecture, and is subject to change.

Exam Topics

Exam topics may differ from this schedule; see the Materials tab of our course site for each exam’s stated topics.

Assignment Deadlines

Homework deadlines are not listed on this page as they are sensitive to the pace of the lectures — see the Homework tab on the main course page for these. Classwork dates are listed under Assignments & Grading below.

#DateLectureWhat we cover
1Tue Sep 1The (bitter) Taste of JavaIntroductions, syllabus, Java vs. Python, and development environment setup
2Thu Sep 3To Make a Cup of Java, First, You Must Invent the UniversePrimitives, arrays, and Strings
3Tue Sep 8Controlling the Flow of JavaControl flow, method design, and test-driven development
4Thu Sep 10Keeping it ClassyJava class design and object-oriented programming
5Tue Sep 15Inheriting Some Wisdom!Inheritance, overriding, and the Object superclass
6Thu Sep 17Remember Memory!Stack vs. heap, references, and garbage collection
7Tue Sep 22Enlisted To List! (Part I)ArrayLists and dynamic arrays
8Thu Sep 24Enlisted To List! (Part II)ArrayList implementation and the debugger
—Tue Sep 29No classClass cancelled.
9Thu Oct 1 (recorded)Enlisted Again: The Linkening! (Part I)Linked lists and nodes. No in-person class — watch the recorded lecture and send questions via Slack or email.
10Tue Oct 6Enlisted Again: The Linkening! (Part II)Iterators and linked-list operations
10Thu Oct 8Enlisted Again: The Linkening! (Part II) (continued)Finishing iterators and linked-list operations
—Tue Oct 13Exam I reviewNo new material — we review lectures 1-10 for Thursday’s exam.
—Thu Oct 15Exam INo lecture — exam in class.
11Tue Oct 20Stacking Up the Data StructuresStacks and queues
12–13Thu Oct 22Analyze This + Big-O No! More Runtime Analysis!Total cost functions, big-O notation, and runtime analysis practice
14Tue Oct 27Sorting, Searching, Success!Analyzing the classic sorting and searching algorithms
15Thu Oct 29The Stack is Calling!Recursion and the call stack
16Tue Nov 3Their Bark is Worse Than Their Byte: Part ITrees: vocabulary, structure, and traversals
17Thu Nov 5Their Bark is Worse Than Their Byte: Part IIBinary search trees: insertion, search, and balance
18Tue Nov 10Their Bark is Worse Than Their Byte: Part IIITries and ternary search trees
19Thu Nov 12Balancing ActSelf-balancing trees
20Tue Nov 17Heaping on the Data StructuresHeaps and priority queues
21Thu Nov 19High Priority ProgrammingPriorityQueue applications
22Tue Nov 24A Sorting AffairHeapSort and advanced sorting
—Thu Nov 26No classThanksgiving Holiday.
23Tue Dec 1Hash Out or Crash OutHash functions, collisions, and load factor
24Thu Dec 3Hell Hash No Fury!Rehashing, Maps, and Sets
25Tue Dec 8Warning - Graphic Content!Graphs and their representations
—Thu Dec 10Exam II reviewNo new material — we review everything since Exam I.
—See the LMU Final Exam ScheduleExam IINon-cumulative, during the final exam period.

Assignments & Grading

Grade Decomposition

Grades will be assigned based on the following weighted coursework:

  • [5%] Attendance: Students are allowed to miss up to 2 classes without having their grade impacted. After that, I will deduct the amount of missed classes using missed_classes/total_classes for the percentage.

  • [10%] Classwork: Small classwork assignments will be given throughout each week, with in-class time allocated for their completion. You will have the opportunity to work on these in groups and with my assistance during class, and you submit them electronically by their listed due dates. Your lowest classwork grade will be dropped.

  • [15%] PostCommit Quizzes: Short, in-class quizzes that ask you to explain, in plain English, the code you submitted, delivered through PostCommit. Each answer is scored on a 0 to 2 scale for how well it demonstrates understanding of your own code, and your grade for this component is the average credit across every question you are asked over the semester.

    PostCommit is an app developed here at LMU CS department that uses AI to help you prepare for technical interviews by answering plain-English questions about your own assignment submissions.

    • Sign in: go to lmu.postcommit.ai and sign in with your LMU credentials. There is no separate registration — I add you to the course roster, so if you do not see CMSI 2120 listed, contact me.
    • Connect GitHub: the first time you sign in, complete the Connect GitHub item on your dashboard. This is required before you can access any assignment repository.
    • Accept each assignment: open the assignment in PostCommit and accept it. A private repository is created for you, and the Open repository button takes you to it.
    • Submit: complete each assignment by its deadline. For group assignments, you must create or join your team in PostCommit before you start work -- your team shares one repository, and a teammate can invite you with a private join code.
    • Take the quiz: for most programming assignments, a customized quiz will probe your understanding of the code you committed. You will answer in plain English, similar to a technical interview. To participate, you must:
      • Be present in class when the quiz is offered (scheduled after the assignment deadline, TBA in class)
      • Bring your own laptop or lease one from the department / ITS
      • Take the quiz on your device.

    Grading. Each answer you give is scored by PostCommit on a 0 to 2 scale for how well it demonstrates understanding of your own code. Those scores convert to credit as follows:

    PostCommit scoreWhat it meansCredit
    2Mastery — you explained the concept-to-code mapping precisely, using appropriate vocabulary100%
    1Gist — you had some of the right ideas, but not the depth or accuracy to show mastery50%
    0No understanding demonstrated, or no answer given0%

    Your grade for this component is the average credit across every question you are asked over the semester. An answer that conveys the gist earns half credit, so it is always worth answering: a partial explanation scores far better than a blank.

    Feedback. After the class completes a quiz, individualized feedback is available in the app on the quality and depth of your responses.

    Code-understanding accountability

    Consistently low scores may indicate that you need additional help understanding the material, or may raise concerns about whether the submitted code is truly your own work. In either case, I may reach out to schedule a meeting to discuss your understanding of your submissions. If it is determined that you cannot adequately explain your own code, this may be treated as an Academic Honesty Violation and handled according to university policy.

  • [40%] Homework: Larger assignments with heavy coding required. Programming style and comments are graded as well. All homework assignments are weighted equally. Expect roughly 5-6 assignments in total, apportioned once every ~2.5 weeks. Your lowest homework grade will be dropped.

  • [30%] Exams: There will be 2 exams (a midterm and final). Your best exam score will constitute 2/3 of the exam grade, with your worse score constituting the remaining 1/3. For example, if your 2 exam scores were 60 and 90, then your weighted exam score for the course will be 80.0 (= 60*(1/3) + 90*(2/3))

Classwork Schedule

Each classwork is introduced in class once we’ve covered the material it needs, with in-class time set aside to start it, and is then due at 11:59 PM one week later. Bonus classworks are optional and add points to a Homework grade rather than to your classwork average.

ClassworkAssignedDue (11:59 PM)
Classwork 1Tue Sep 1Tue Sep 8
Classwork 2Thu Sep 10Thu Sep 17
Classwork 3Thu Sep 24Tue Oct 6
Classwork 4Tue Oct 20Tue Oct 27
Classwork 5 [Bonus]Tue Oct 20Tue Oct 27
Classwork 6Tue Nov 10Tue Nov 17
Classwork 7 [Bonus]Tue Dec 1Tue Dec 8

If we fall behind

These dates follow the tentative schedule above and shift with it. If we do not reach a classwork on the date listed, its deadline slides accordingly and the Classwork page is updated — that page is always the authoritative one.

Final Grades

Final letter grades are given based on the university scale of grade percentages:

  • A: 93 - 100
  • A-: 90 - 92
  • B+: 86 - 89
  • B: 83 - 85
  • B-: 80 - 82
  • C+: 76 - 79
  • C: 73 - 75
  • C-: 70 - 72
  • D: 65 - 69
  • F: 64 and below

Fractional grade percentages at 0.5 or over will be rounded up, so an 89.5% will be considered a 90% (A-), but an 89.4% will be considered an 89% (B+) on the above scale.

That said, these are only the guaranteed grade assignments: if your “final” grade is an 82%, you are guaranteed a B- or better, but you might still get an A if 82% is the top score.

Extra Credit

Extra credit opportunities will be sporadically available during lectures / exams; if you are present and can hand in an attempt at the extra credit opportunities, you will receive bonus points!

If you receive all extra credit opportunities, you can gain a maximum +2% on your final grade. These bonuses are applied post-curve, so no student’s grade is lowered by another student’s bonus points.

Submission Standards

Each of your submitted homeworks and projects are subject to the following constraints:

  • Assignment posting: all assignments (classwork, homework, or otherwise) will be announced in class and posted on this site with due dates. You are responsible for checking this site / your email for any updates to assignments and their associated deadlines.
  • Late Policy: assignments are due at exactly the time indicated by the method specified. Assignments that are late will not be considered for grading. There are no exceptions to this rule.
  • Individual Work: students are encouraged to talk and think about problems in groups, but each submission should be their own, containing no code that has been copy-pasted from another student. We take plagiarism very seriously, and each submission will be run through a similarity-checking mechanism to ensure fairness. Code or homework which we believe to be shared innapropriately between students or copied from the internet is subject to severe disciplinary action (not that you would, just sayin’). The following are examples of unacceptable behavior in this course: If you plan to copy anything from the internet, ask first!
  • Copying non-trivial amounts of code from the internet into an assignment (excluding small things from StackOverflow like how to use Java Streams to simplify some code).
  • Copying another group’s solutions on a classwork exercise (sharing between group members is encouraged… that’s what it means to… you know… group up).
  • Style: assignments which are sloppily submitted without proper formatting, style, and comments are subject to penalties. We will discuss what constitutes such offenses in class, though you should be familiar with clean coding standards from your introductory courses.
  • Development Environment: This course requires IntelliJ IDEA (download it here). It is what I use for all in-class demonstration, and it is the only environment in which I can guarantee support during class and office hours. The Community Edition is free, and students can get the Ultimate Edition at no cost through the JetBrains student license. Each assignment is distributed as a ready-to-open project through PostCommit, you should not need to configure anything by hand. You are expected to be able to develop iteratively using JUnit tests and to use Git / PostCommit for your version control.

Academic Integrity

Students are encouraged to talk and think about problems in groups, but each submission should be their own, containing no code that has been copy-pasted from another student. No matter who you got help from, by the time you submit your assignment you should be able to explain every line of code in your submission! We take plagiarism very seriously, and each submission will be run through a similarity-checking tool. We are very methodical about reporting academic honesty violations and do not hesitate to escalate any suspected cases through official university channels.

Danger

All forms of plagiarism will result in severe disciplinary action.

The following are examples (not a comprehensive list!) of unacceptable behavior in this course:

  • Copying non-trivial amounts of code from ANY other source into an assignment (excluding small things from StackOverflow like how to use list comprehension to simplify some code). This includes code found on the internet or through the use of a generative AI model like ChatGPT.
  • Copying code from another student’s submission.
  • Copying another student’s solutions on a classwork exercise.
  • Re-using or copying work or solution sets from a previous semester, even if it is your own work from when you previously took the course.

Danger

If you plan to copy anything from the internet, ask first!

On Responsible AI usage

Academic honesty includes the appropriate use of technology as an aid for learning and productivity. This includes but is not limited to LLM-based generative artificial intelligence tools such as Claude, ChatGPT, Gemini, and Copilot.

Modern GenAI provides fast solutions to a variety of computing problems but must be used responsibly to get the most out of your education. GenAI will not always be helpful, especially when asked to write code for scenarios it cannot recognize. It cannot independently validate the code that it produces, and will frequently produce bugs and security vulnerabilities, making things worse for you. It will not be available for job interviews. As a student and future software professional, you have a moral and ethical responsibility to deeply understand every line of the software you author and should therefore employ GenAI in your coursework sparingly, especially when its use might rob you of the stretch-zone learning that comes from crafting programs on your own.

That said, there are several acceptable use cases of GenAI in programmatic assignments, including:

  • Generating short documentation strings and type hints.
  • Finding examples and explanations for syntactic forms [e.g., how to use the spread operator; how to assign variables directly from an array or object; how to construct a dictionary comprehension; how to unwrap an optional, and so on]. Prompt the AI for the how-to’s, not your final code.
  • Interpreting error messages, as these might be pretty cryptic! Sometimes the AI can be a useful tutor when explaining things it is familiar with.
  • Generating unit tests for edge cases. When it finds something you overlooked, make a mental or written note so you can find these cases on your own next time.
  • Brainstorming new ideas for applications.

Warning

Remember your four As: you MAY use technologies such as GenAI to Augment ✅, Amplify ✅ and Accelerate ✅ your learning; NEVER use technology to Avoid ❌ learning.

Danger

If you DO use GenAI for any of your work, that must be indicated somewhere in your documentation with an AI use disclosure: “This portion of the work was developed with assistance from [tool and version, e.g., Claude Opus 4.5]. I used it to [briefly describe the task: e.g., generate an initial implementation of the sorting module, draft this section of the design document, debug the authentication flow]. I have reviewed, tested, and understand all AI-generated content included here, and I take full responsibility for its correctness and its fit with the rest of the project.”

Text authored by Dr. Johnson (Thank you!)

Resources

Student Rights and Responsibilities

Just as I have certain expectations of you in this course, you may have certain expectations of me. Here is a high-level list of each:

My Responsibilities

  • Provide you with an educational experience superior to that which could be gleaned from a textbook or online source alone.
  • Answer your questions and curiosities in office hours, over Slack, and via email with a turnaround of at most 36 hours.
  • Give you feedback on your submissions and individualized instruction on how to maximize your gain from this class.

Your Responsibilities

  • Be responsible with use of your time, class time, office hours, email, and the Keck Lab TAs. Last minute pleas for help on assignments or exams are the opposite of this.
  • Be respectful of classmates.
  • Don’t cheat or plagiarize on exams or assignments.

Tips for Success in this Class

Here are a few tips for succeeding in this class (and college, in general); they’re not meant to sound patronizing, but rather, are simply pearls of wisdom to hand down from someone who has recently trodden your path!

  • Ask questions: if there is one piece of advice I can impart unto you, it’s to ask questions when you have them. Chances are good that if you have a question, someone else has the same one, you won’t be left behind wondering about something that was covered minutes ago (and which future material might employ), and I promise not to judge you for whatever you ask (well, not too hard at least). At the very least, if you have a question, write it down and then ask it on Slack after class (which can be done anonymously if you so please). The heart of academic inquiry is just that: inquiry!
  • Fear not the specter of error: in college classes, there tends to be a crippling aversion to being wrong, especially publicly! I’m here to tell you that there is no better time to be wrong than in class, particularly in one as interactive as ours. There are a variety of silver-linings to being wrong: you won’t forget what you were wrong about (one fewer thing to cram for later), it’s better to learn from being wrong when it doesn’t matter (i.e., in discussion) than when it does (i.e., on a test or during an interview), and I will respect you for your courage. There is only one circumstance in which you should fear error: when you fail to learn from it (at which point, see tip above for remedy).
  • Indulge your curiosity: and no, that’s not some tagline stolen from a Vegas day-spa (actually, it might be, don’t quote me on that), but the wisdom is sound… in class, we will cover a variety of topics with accompanying exercises that highlight the main take-away messages of the lesson, but that does not mean that your learning should stop there. Indeed, computer science is one of those beautiful disciplines wherein experimentation and exploration are so trivially entertained. Curious about what would happen if you changed the value of a variable? Do it! Curious about what other methods exist for certain data types? Google them! There is no reason why your learning should be constrained to what I (strategically) offer you; we have only limited time in class, and I’ll prioritize the most important topics, but your interests can spread their own wings. Go forth and explore!

University Resources

Here are some LMU links for University Resources that might be of interest:

Graph View

Backlinks