Data structures & algorithms
Enhanced Course Manager Program
I transformed a C++ command-line course planner into an internal Angular workspace for computer science advisors. The enhancement combines fast course lookup, visual prerequisite pathways, graph validation, and reviewable plan updates in one practical workflow.
- Angular
- TypeScript
- Hash Maps
- Directed Graphs
- Depth-First Search
- CSV & Excel
An advisor-focused view of the curriculum
The interface turns the underlying course index and prerequisite graph into information an advisor can search, inspect, and act on.
Enhancement story
From an academic artifact to a usable advising tool
The original CS 300 program loaded a static CSV file into an unbalanced binary search tree. The enhanced application re-evaluates that design around the advisor's real access patterns: finding one course, moving through relationships, and safely reviewing curriculum changes.
Core design choice
Match each structure to one job
Hash maps optimize lookup and comparison, adjacency lists model relationships, sets remove duplicates, and arrays provide sorted presentation. The design avoids forcing one structure to solve every problem.
Application capabilities
Algorithms that support the advising workflow
Instant course lookup
Indexes normalized course numbers in a hash map so advisors can retrieve course details without scanning the full plan.
Bidirectional pathways
Uses forward and reverse adjacency lists to show a course’s direct prerequisites and the courses it unlocks.
Graph validation
Runs depth-first search to detect circular relationships and verifies prerequisite references before updates are applied.
Versioned comparison
Compares the current and imported plans with hash maps, then labels each record before creating a new version.
Architecture
A structure for each access pattern
Course index
Hash map
Maps each normalized course number to its record for average constant-time lookup.
Prerequisite model
Directed graph
Forward and reverse adjacency lists support navigation in both directions without repeated full-plan scans.
Relationship cleanup
Set
Removes duplicate prerequisite entries before graph validation and indexing.
Sorted presentation
Array
Produces a searchable, alphanumerically ordered catalog without making the display order the primary storage model.
Safe plan updates
Compare first, then create a new version
CSV and Excel imports are normalized and validated before they change the selected plan. Two hash maps compare existing and incoming records in O(n + m) time. Missing courses are retained as inactive instead of being silently deleted, and advisors review every classification before applying an update.
Application gallery
Searching, navigating, importing, and comparing
Course relationship overview
One lookup reveals direct prerequisites, dependent courses, plan health, and a visual pathway for the selected course.
Searchable course catalog
The indexed catalog presents course numbers, titles, prerequisites, credits, and active status in alphanumeric order.
Guided plan import
Advisors can upload CSV or Excel data with clear format guidance before any changes affect the current plan.
Review-before-apply comparison
The preview classifies records as added, modified, unchanged, missing, or invalid before a new plan version is created.
Data integrity
Validate before building the runtime indexes
- Normalize course numbers, headers, and prerequisite separators
- Remove duplicate prerequisite entries with sets
- Reject missing references and circular dependencies
- Rebuild indexes after an approved plan version changes
Production boundary
A prototype with a clear backend path
The prototype stores named plan versions through a dedicated browser persistence service and contains no student records. Production use would replace that service with an authenticated HTTPS API, server-side validation, authorization, audit logging, and secure file-upload controls.
Project outcome
An academic project redesigned around practical value
This enhancement demonstrates how I evaluate runtime and memory trade-offs, model relationships with graphs, validate imperfect input, and turn data-structure decisions into a clear workflow for real users.