| LO | Bloom level | RAP1 | RAP2 |
|---|---|---|---|
| LO.1 Linear/non-linear data structures | Understand | ✓ | ✓ |
| LO.2 Time/space complexity (Big-O) | Analyze | ✓ | ✓ |
| LO.3 Sorting and searching | Apply | ✓ | ✓ |
| LO.4 Trees and hash tables | Apply | ✓ | ✓ |
| LO.5 Graph algorithms | Apply | ✓ | ✓ |
| LO.6 File organization | Evaluate | — | ✓ |
| LO.7 Structure/algorithm selection | Synthesize | ✓ | ✓ |
| Tool | What for | Output | Condition |
|---|---|---|---|
| GCC/Clang/MSVC + CMake | Build the C app | Executable (not submitted) | Zero errors, Windows + WSL/Linux |
| GoogleTest + gcov/lcov | Unit tests, coverage | HTML coverage report | 100% statement coverage |
| Doxygen | Source documentation | 100% coverage; PDF only, no HTML folder |
| Tool | What for | Output | Condition |
|---|---|---|---|
| JDK 21 + Maven | Build the Java app | Release build | mvn clean verify, zero errors |
| JUnit 5 + JaCoCo | Unit tests, coverage | HTML coverage report | 100% statement coverage |
| Javadoc/Doxygen | Source documentation | 100% coverage; PDF only | |
| Git + GitHub | Version control | Private repository | Meaningful commits, proper .gitignore |
| GitHub Actions (optional) | Continuous integration | CI status | If enabled, must be green before merging |
ucoruh) and your teammate as collaborators| Check | Template | Repository name |
|---|---|---|
| Midterm (C) | cpp-cmake-ctest-template |
cen207-project-name-surname-c |
| Final (Java) | eclipse-java-maven-template |
cen207-project-name-surname-java |
Both templates already provide building, unit testing, documentation
generation, coverage measurement and packaging — you build on them.
A private repository on GitHub Free has no GitHub Pages site. You show everything on your computer:
7-build-all-windows.bat (Linux/WSL: 7-build-all-linux.sh) builds, tests and makes every report9-open-site-windows.bat (Linux: 9-open-site-linux.sh) opens the full site on http://localhost: every report (tests, code coverage, documentation coverage, Windows and Linux) and the API docsrelease/ holds every output: app/exe, library, reports, API docs, site.zip, source, ASSETS.md, SHA256SUMS.txt10-release-windows.bat (Linux: 10-release-linux.sh) makes the GitHub Release; releases work on private repositoriesWhat you open and show, in this order:
9-open-site-..., on http://localhost).release/ folder listing.lib — data structures and algorithms live hereapp — console menus and user interaction; uses libtest — unit tests; uses libBefore you start: make sure your environment is ready — see the
Prerequisites page/deck.
Each code lists the week it is taught and the LO it measures. You
implement the basic operations of every structure (insert, delete, search,
list…) yourself.
Ready-made library structures (e.g. Java's java.util collections) do
not count towards these requirements.
| Code | Requirement | Week | LO |
|---|---|---|---|
| V1 | Linked list: doubly + XOR/circular; insert, delete, search, traverse both ways | 2 | LO.1 |
| V2 | Sparse matrix: store only filled cells; read, write, walk rows/columns | 2 | LO.1 |
| V3 | Stack and queue: array or linked-list based | 3 | LO.1 |
| Code | Requirement | Week | LO |
|---|---|---|---|
| V4 | Tree and heap: binary tree + 3 traversals; heap-based priority queue; heap sort | 4 | LO.1, LO.4 |
| V5 | Graph and traversal: adjacency list/matrix; BFS and DFS | 5 | LO.1, LO.5 |
| V6 | Search and hashing: binary search; hash table + collision resolution | 6 | LO.3, LO.4 |
| Code | Requirement | Week | LO |
|---|---|---|---|
| F1 | Port to Java: V1–V6 with generics; all features in one menu | 9–14 | LO.1, LO.7 |
| F2 | Graph algorithms: ≥2 of MST/shortest-path/topo-sort/SCC/cycle/max-flow | 9 | LO.5 |
| F3 | Sorting: ≥3 algorithms, timed comparison across data sizes | 10 | LO.2, LO.3 |
| Code | Requirement | Week | LO |
|---|---|---|---|
| F4 | BST and AVL: balancing rotations; insert, delete, search, range query | 11 | LO.4 |
| F5 | String algorithms: KMP/Boyer–Moore search + edit distance/LCS | 12 | LO.1, LO.3 |
| F6 | Trie and disjoint sets: prefix tree + union-find | 9, 12 | LO.4 |
| Code | Requirement | Week | LO |
|---|---|---|---|
| F7 | File organization: sequential + direct-access file; collision resolution in the file | 13 | LO.6 |
| F8 | B+ tree index: secondary-key index over file records | 14 | LO.4, LO.6 |
| F9 | Growing files: extendible hashing or external merge sort | 14 | LO.3, LO.6 |
.bin/.dat) — records survive a restart.gitignore;.exe, .o, .class, .jar); Java repo produces a release| Deliverable | Midterm | Final |
|---|---|---|
| Source code archive (no compiled files) | ✓ | ✓ |
Report (.docx): design, complexity, measurements, coverage screenshots |
✓ | ✓ (updated) |
| Doxygen/Javadoc output — PDF only | ✓ | ✓ |
| Test coverage report (HTML, inside the archive) | ✓ | ✓ |
| Presentation (≤10 slides) | — | ✓ |
| Video (≤4 min per member) | — | ✓ |
| Live demo and questions (~10 min per team) | week 7 | week 15 |
cen207-midterm-name-surname.zip
└── cen207-project-name-surname-c/
├── lib/ # V1–V6
├── app/ # console menus, uses lib
├── test/ # GoogleTest, uses lib
├── CMakeLists.txt
├── report/cen207-midterm-name-surname.docx
├── docs/cen207-midterm-name-surname-doxygen.pdf
├── coverage/ # gcov/lcov HTML
├── .gitignore
└── README.md
cen207-final-name-surname.zip
└── cen207-project-name-surname-java/
├── src/main/java/... # F1 port of V1–V6, plus F2–F9
├── src/test/java/... # JUnit 5
├── pom.xml
├── report/, docs/, coverage/
├── presentation/cen207-final-name-surname.pptx
├── video/ # added before zipping, not committed
├── .gitignore
└── README.md
Name every file with the course code, the checkpoint, and your
name-surname:
cen207-midterm-name-surname.zip · cen207-final-name-surname.zip ·
cen207-midterm-name-surname.docx
Repository names follow the pattern from the tools/setup section.
main is protected — all work happens on feature branchesfeature/hash-table, fix/avl-rotation)mainConventional Commits: feat(lib): implement AVL rotation ·
fix(app): correct menu navigation · test(hash): add collision unit tests
Pull requests: open from your branch to main; your teammate reviews
what changed and how it was tested, then approves before merging
midterm-v1.0, final-v1.0 for what you submit| Level | Meaning |
|---|---|
| 5 — Excellent | Everything works, tested, documented; explained step by step in the demo |
| 4 — Good | Minor gaps or edge-case bugs; complete and tested overall |
| 3 — Adequate | Basic operations work; clear gaps in tests/docs/measurements |
| 2 — Poor | Compiles, but most operations wrong or missing; weak explanation |
| 1 — No evidence | Not submitted or not working |
Points = (level ÷ 5) × criterion points.
| # | Criterion | Scope | Points |
|---|---|---|---|
| 1 | Linear structures | V1 lists, V2 sparse matrix, V3 stack/queue | 20 |
| 2 | Tree and heap | V4 traversals, heap, heap sort | 15 |
| 3 | Graph and traversal | V5 representation, BFS/DFS | 15 |
| 4 | Search and hashing | V6 binary search, hashing, collisions | 10 |
| 5 | Complexity analysis | Big-O + measurement table | 10 |
| 6 | Problem analysis, structure choice | "Why this structure?" in the report | 10 |
| 7 | Software engineering | CMake, tests 100%, docs 100%, GitHub | 20 |
| # | Criterion | Scope | Points |
|---|---|---|---|
| 1 | Port + integrated app | F1 generics, one menu, binary files | 10 |
| 2 | Graph algorithms | F2, two algorithms | 10 |
| 3 | Sorting | F3, three algorithms, comparison | 10 |
| 4 | Balanced trees | F4 BST/AVL, rotations, range query | 15 |
| 5 | Strings and structures | F5 search/alignment, F6 trie/union-find | 15 |
| 6 | File organisation | F7 files, F8 B+ index, F9 hashing/sort | 20 |
| 7 | Engineering + presentation | Maven, tests 100%, docs, video, demo | 20 |
.gitignore correct?lib/app/test and their dependenciesstruct, malloc/free, file I/O, debugger call stackWork alone instead of a team? Yes — at most 5, working alone
is allowed. Teams are fixed at the end of week 3.
Two teams want the same topic? First to write it in the Teams table gets it.
Change topic after approval? No — it is fixed together with the project plan.
Coverage below 100%? Not accepted (see acceptance conditions) — reach
100% before the deadline.
Do library collections (e.g. java.util) count? No — implement the
basic operations yourself.
Compiled files in the repo/archive? No — remove with .gitignore;
their presence is grounds for rejection.
| Range | Theme |
|---|---|
| 001–025 | Transport, maps and routing |
| 026–050 | Games and puzzles |
| 051–075 | Text, language and search |
| 076–100 | Science, health and bioinformatics |
| 101–125 | Networks and computer systems |
| 126–150 | Logistics, manufacturing and commerce |
| 151–175 | Media, social networks and culture |
| 176–200 | City, environment, disasters and agriculture |
A console app merging a city's metro/tram/funicular lines into one
network; suggests the fastest or fewest-transfer route (~12 lines, 250 stations).
The full appendix — all eight groups, all 200 topic boxes — is on the
project guide page, right after this deck's content.
Browse it, pick one, and write it in the team-and-topic table.
Course website: ucoruh.github.io/ce205-data-structures
Next: browse the full topic list on the project guide page
Speaker note: This deck mirrors the project guide page section by section — treat it as the quick-reference version.
Speaker note: The C and Java versions are not two separate projects — the Java version extends the same application.
Speaker note: These four facts are the ones every question in this deck eventually traces back to.
Speaker note: "Mandatory for every topic" is the key phrase — the topic changes the story, not the requirement list.
Speaker note: Six milestones; the full weekly schedule lives in the syllabus.
Speaker note: The full weekly schedule is in the syllabus — this is only the project's own milestones inside it.
Speaker note: Same formulas as the syllabus, now paired with which LOs each checkpoint actually measures.
Speaker note: RAP1/RAP2 are the two checkpoints this whole deck is about.
Speaker note: LO.6 (file organization) only appears in RAP2 — it is taught in weeks 13–14, after the midterm checkpoint.
Speaker note: The same toolchain from the Prerequisites deck, now with exact templates and repository names.
Speaker note: "PDF only, no HTML folder" is a real acceptance condition — an HTML Doxygen output in the archive is a rejection risk.
Speaker note: The Java repository additionally needs to produce a release — that is checked at demo time.
Speaker note: A public repository during the term is itself an acceptance-condition problem, independent of code quality.
Speaker note: Both templates live under github.com/ucoruh — use "Use this template" there.
Speaker note: Each template's README and its docs/guide/ page "Showing your project without GitHub Pages" have the details.
Speaker note: Almost every rubric criterion maps to code that should live specifically in lib, not scattered into app.
Speaker note: 200 topics, eight groups, one rule: first team to write it down gets it.
Speaker note: This deck shows one representative topic near the end — the full 200 are only on the page, by design.
Speaker note: Step 3 is the one students forget — approval is tied to the plan, not to writing your name in the table.
Speaker note: The requirement itself — which structure, which operation — never changes, only which feature in the app demonstrates it.
Speaker note: V1–V6 for the midterm (C), F1–F9 for the final (Java) — implemented by you, not from a library.
Speaker note: This is checked at the demo — walking through your OWN insert/delete code, not a call to a library method.
Speaker note: These three are due in the first three content weeks — start the project plan around them, not around the whole list.
Speaker note: V6 is the last midterm requirement, taught the week right before the midterm demo — plan the buffer accordingly.
Speaker note: F1 is the port of everything already built in C — it is not new functionality, but it is real work.
Speaker note: F6 is taught in two separate weeks (trie in 9, disjoint sets alongside strings in 12) — plan it in two passes.
Speaker note: F7–F9 are the last three requirements, taught in the two weeks right before the final demo — the tightest part of the schedule.
Speaker note: "Persistent" is tested literally at the demo: add a record, close the program, reopen it, show the record is still there.
Speaker note: These four rules are the same four checked in "Acceptance conditions" later in this deck — they are not optional polish.
Speaker note: One archive, uploaded once per checkpoint, with the repository link on the report cover.
Speaker note: The presentation and video are final-only — the midterm checkpoint is code, report and a live demo, nothing pre-recorded.
Speaker note: This is a GitHub repo clone, gitignore-filtered — it extracts and builds on its own.
Speaker note: video/ is explicitly NOT committed to GitHub — it is added to the zip archive only, right before submission.
Speaker note: Inconsistent naming is a small but avoidable source of confusion when grading dozens of submissions.
Speaker note: This is graded, not just recommended — "Software engineering" is a rubric criterion worth 20 points on each checkpoint.
Speaker note: A demo question directly asks "how were branches used, how were merges/conflicts resolved" — this is not a formality.
Speaker note: Meaningful commits from BOTH members is an explicit acceptance condition — one member's name on every commit is a red flag.
Speaker note: The version tag is what "the state you submit for grading" means precisely — tag it, do not just submit whatever main happens to be.
Speaker note: Two rubrics, 100 points each, seven criteria apiece — every criterion on a 1–5 achievement scale.
Speaker note: The formula matters: a level-3 criterion earns 60% of its points, not zero — partial credit is real and scales linearly.
Speaker note: Criteria 1–4 (65 points) are the four V-code groups; 5–7 (35 points) are analysis and engineering, not code alone.
Speaker note: File organisation alone is worth 20 of 100 points on the final — the same weight as engineering and presentation combined.
Speaker note: These are not rubric points lost — a submission failing any one of these is not accepted at all.
Speaker note: This is a hard gate, checked before the rubric is even applied — fix these first, then worry about the score.
Speaker note: The demo is roughly 10 minutes per team — these are the categories of questions, not a fixed script.
Speaker note: "Both members" is checked literally — a repo with commits from only one teammate is itself a finding.
Speaker note: "Line by line" is literal — being able to point at the code and narrate it is what is being assessed here.
Speaker note: This is the literal "persistence" test from the rules slide, performed live in front of the instructor.
Speaker note: This section is why "shared understanding" is graded, not just tested for — the demo checks it directly.
Speaker note: Code review and the demo check exactly the honesty the ethics codes describe — this is not an abstract clause.
Speaker note: "Not graded" is stronger than "loses points" — an unexplainable section simply does not count toward the score.
Speaker note: A few of the most common ones — the full list is on the project guide page.
Speaker note: All three answers trace back to the same rule: the team-and-topic table is first-come, first-served, then locked.
Speaker note: These three all point back to the same "Acceptance conditions" slide earlier in this deck — it is worth re-reading.
Speaker note: 200 topics, eight groups of 25 — this deck shows the map and one worked example, not all 200.
Speaker note: All data is synthetic and every application is network-free — that rule from §5.3 holds across all eight groups.
Speaker note: The next two slides show exactly one topic box, in full, as a worked example of this pattern.
Speaker note: This is topic 001 of 200, shown in full so the pattern is clear before you browse the rest on the page.
Speaker note: Every one of V1–V6 and F1–F9 appears exactly once — that is the rule every one of the 200 topic boxes follows.
Speaker note: Putting only one topic in the deck is deliberate — 200 topic boxes belong on the page, not on 200 slides.
Speaker note: The syllabus, prerequisites and this guide are the three pages every student should have open in week 1.