WGU C950: Data Structures and Algorithms II

Why C950 Is the Course Where Theory Turns Into Working Code

WGU C950, Data Structures and Algorithms II, is the second half of WGU's data structures sequence in the School of Technology, and it is the point where the abstractions you memorized finally have to run. WGU's own course description says it explores the analysis and implementation of high-performance data structures and supporting algorithms, including graphs, hashing, self-adjusting data structures, set representations, and dynamic programming, and that it introduces NP-complete problems along with Python techniques for memory management and data compression. It sits behind two prerequisites — Data Structures and Algorithms I and Discrete Math II — and appears in WGU's Bachelor of Science in Computer Science.

Direct answer: C950 is not a multiple-choice test. You pass by submitting a working Python program plus a written analysis that a WGU evaluator scores against a rubric. Build and test the program first with real data, then write the analysis so that every rubric line is answered explicitly, in order, using your own code as the evidence.

Students usually arrive straight out of Data Structures and Algorithms I, many of them nervous because the course has a reputation. That reputation is about scope, not the difficulty of any single idea. The assessment is one sustained software project — the WGUPS Routing Program — in which a fictional parcel service in Salt Lake City needs its daily local deliveries planned. You are handed package data with individual deadlines and special handling constraints, a distance table between addresses, a small fleet of trucks, and fewer drivers than trucks. Your job is to write code that gets every package delivered on time while keeping total mileage under the ceiling the task names.

It matters because this is the first course in the sequence that asks you to defend engineering decisions in writing. You implement a hash table yourself rather than reaching for a built-in dictionary, choose a routing heuristic, and justify both in big-O terms. Build it, measure it, explain it — that is what a technical interview and a real code review look like.

What the WGUPS Routing Program Assessment Covers

C950 is assessed entirely by performance assessment. At the time of writing the work is delivered in two parts: a planning and design document in which you name and justify your algorithm and data structure before writing production code, and then the implemented program submitted with a written analysis. WGU revises task numbering and scenario figures periodically, so treat your current course page as the authority. Across both parts, the graded material centers on:

• A hand-built hash table with your own insertion and lookup functions, returning a package's full record by ID — delivery address, city, ZIP, deadline, weight, and delivery status including the delivery time.
• A self-adjusting routing heuristic — most students choose a greedy nearest-neighbor approach — with a written justification of why you picked it over alternatives.
• Space and time complexity analysis in big-O notation for your lookup, your insertion, and your overall routing algorithm, plus a discussion of how each scales if the package count grows.
• Constraint handling: packages with delayed availability, packages locked to a specific truck, packages that must ship together, and at least one package whose address is corrected partway through the delivery day.
• A working user interface that reports total mileage and lets a user query the delivery status of any package, or all packages, at an arbitrary point in time.
• Code quality and documentation: in-line comments, an identifying header comment, meaningful variable names, and an explanation of what you would do differently on a second pass.

Students have described the scenario consistently for years — roughly forty packages, three trucks, two drivers, a mileage ceiling in the low hundreds — but those are exactly the details WGU adjusts between assessment versions, so read them off your own task instructions, not off any study guide, this one included.

The underlying theory is the graph and hashing material from the course reading. If your graph vocabulary is shaky, a refresher through C960 Discrete Mathematics II notes pays for itself, since that prerequisite is where much of the formal groundwork on graphs and complexity lives.

How Hard C950 Really Is, and What to Budget

Many students report that C950 is among the more demanding courses in the computer science program — not because any single concept is exotic, but because it is the first time they have to hold an entire program in their head for weeks. Students who arrive comfortable in Python frequently report finishing in two to four weeks of steady effort. Students still fighting the language itself commonly describe six to eight weeks, and often say the real bottleneck was Python fluency rather than algorithms.

A useful self-test: if reading and writing Python classes, dictionaries, loops, and file I/O feels routine, plan for a focused sprint. If it does not, spend your first week rebuilding that base — the material in D335 Introduction to Programming in Python covers exactly the syntax you will lean on — before you touch the routing problem. Trying to learn Python and graph traversal simultaneously is the single most reliable way to stall.

Also budget for evaluation turnaround. Performance assessments are graded by a human, returns for a single missed rubric line are common, and each round trip costs days. Front-loading rubric compliance is cheaper than resubmitting.

A Four-Phase Plan for Building and Defending Your Program

Phase one: read the rubric as a specification. Before writing a line of code, copy every rubric requirement into a checklist document. Each one becomes a heading in your final write-up. Evaluators score against that list, so structuring your submission to mirror it removes almost all ambiguity about whether you addressed something.

Phase two: rebuild the theory by recall, not rereading. Close the book and write from memory how a hash table resolves collisions with chaining, and how nearest-neighbor picks the next stop. Then check yourself. Better still, implement a tiny standalone hash table with five keys and deliberately force a collision. If you can explain the resulting behavior out loud, you can write the complexity analysis later without guessing.

Phase three: build in vertical slices. Load and parse the package and distance data first, and verify it prints correctly. Then the hash table with lookup. Then a single truck delivering a hard-coded list. Then the heuristic. Then time-based status queries. Each slice should run before you start the next. Commit after every slice — if version control is unfamiliar, D197 Version Control covers the workflow, and having a working commit to fall back on is worth an afternoon of setup.

Phase four: space the writing. Draft the algorithm justification and complexity analysis a day or two after the code works, not the same night. The distance forces you to explain the design rather than transcribe it, and reviewers can tell the difference.

Where C950 Submissions Usually Get Sent Back

• Using Python's built-in dictionary as the hash table. You are expected to write that structure yourself, including your own insert and lookup. Elsewhere in the program the standard library and the usual built-in types are generally fine — it is the hash table specifically that has to be yours. Confirm the exact wording in your task instructions; this is the line submissions most often trip over.
• Analyzing the code instead of the algorithm. Complexity discussion must be in big-O terms and must cover growth as data scales, not just a description of what the function does.
• Hard-coding the corrected address. The address change should be handled by logic keyed to a time, not by silently editing the data file.
• Skipping the self-critique. The rubric asks what you would do differently and how other data structures compare. A one-line answer reads as unfinished.
• Copying a published solution. Public repositories of C950 solutions exist, and evaluators know them. Submitting borrowed code is an academic integrity violation with consequences far worse than a slow week. Write your own.
• Ignoring the mileage ceiling until the end. Print running mileage from your very first working route so you always know where you stand.

C950 Submission Readiness Checklist

• Can you explain, without notes, why you chose your routing heuristic over at least two named alternatives?
• Can you state the big-O complexity of your insertion, your lookup, and your full routing loop — and justify each?
• Does your program deliver every package within its deadline on a clean run?
• Does total mileage come in under the ceiling your task specifies, and does your program print that total?
• Can a user query any package's status at any arbitrary time and get a correct answer?
• Are the delayed, truck-locked, grouped, and wrong-address packages each handled by logic you can point to in code?
• Does your hash table use your own implementation rather than a built-in dictionary?
• Does every rubric line map to a specific, labeled section of your written analysis?
• Does your file include the required identifying header comment and readable in-line comments throughout?

C950 FAQ

Is C950 an OA or a PA?

C950 is assessed by performance assessment only. There is no proctored objective assessment — you submit code and a written analysis, which a WGU evaluator scores against a rubric.

How hard is C950 compared to Data Structures and Algorithms I?

Many students describe it as a step up, mainly because it replaces quiz-style recall with a multi-week build. The concepts follow directly from the first course; the demand is sustained project work rather than harder individual ideas.

How long does C950 usually take?

Reported timelines vary widely with Python experience. Students already fluent in Python often report a few weeks of focused work, while those still learning the language commonly report closer to two months.

Do I have to write the program in Python?

WGU's course description frames the course around Python techniques, and the course materials and assessment support are built for Python. Confirm accepted languages in your current task instructions before choosing anything else.

Can I use a Python dictionary instead of building a hash table?

No. The assessment expects you to implement the hash table yourself, including your own insertion and lookup functions. This is one of the most frequent reasons submissions come back for revision.

What happens if my submission is returned?

You get evaluator comments identifying which rubric items were not met, and you revise and resubmit. It is a normal part of performance assessments, not a failure — fix precisely what was flagged, and do not rewrite passing sections.

Next Steps

Treat C950 as a software project with a deadline rather than an exam to cram for, and it becomes a course you will be proud to show people. Build in slices, commit often, and let the rubric write your outline. When you are ready to plan the rest of your term, browse the full library of WGU course study guides.