WGU C949: Data Structures and Algorithms I

What C949 Really Is, and Why It Sits at the Center of Your Degree

Data Structures and Algorithms I is the course where programming stops being about making something run and starts being about making it run well. WGU's official description centers it on dynamic data structures — bags, lists, stacks, queues, trees, and hash tables — along with the algorithms that operate on them, the idea of abstract data types, and the object-oriented design habits that keep software maintainable. It carries 4 competency units in the School of Technology and appears in the Computer Science, Software Engineering, and Data Analytics bachelor's programs, which tells you how much later coursework leans on it.

Direct answer: Pass C949 by learning each data structure as a package of three things — how it stores data, which operations it supports, and what those operations cost in Big-O terms — then drilling that until you can recall it cold. Trace short code snippets by hand until you can predict output without running anything, take the pre-assessment early, and study only the areas it flags weak.

Most students arriving here have finished an introductory programming course and can write a loop and a function without panic. That is enough. What C949 adds is a vocabulary and a way of reasoning: why appending to a linked list behaves differently from appending to an array, why a hash table can find an item almost instantly while a plain list has to walk through everything, why one sort collapses on certain input while another sails through. Course materials commonly present examples in Python, but the concepts are language-neutral, and the assessment cares about your understanding rather than your fluency in one syntax.

It matters beyond the transcript. Data structures and algorithms are the shared language of technical interviews and of every performance conversation you will have on a development team. If you are pacing a technology term, this pairs reasonably with a lighter course such as D197 Version Control, and it builds on the formal reasoning you met in C959 Discrete Mathematics I.

What the Objective Assessment Covers

C949 is assessed by a single objective assessment. There is no performance task to submit, so all of your preparation funnels into one proctored exam. WGU's published competencies point at three broad territories, and the topic list below follows them.

• Algorithms — use, logic, and structure. Reading and reasoning about algorithms, following what one does step by step, and recognizing standard patterns.
• Searching. Linear versus binary search, the precondition binary search depends on, and how each behaves as data grows.
• Sorting. The classic comparison sorts and their trade-offs — the simple quadratic ones you can write from memory, and the divide-and-conquer ones that scale.
• Linear data structures. Arrays and lists, linked lists and their variations, stacks, and queues — plus the operations each makes cheap or expensive.
• Trees. Tree terminology, binary trees and binary search trees, traversal orders, and what balance has to do with performance.
• Hash tables. Hashing, collisions, and the common strategies for resolving them.
• Big-O and complexity analysis. Determining time and space complexity of code, and choosing a structure or algorithm to hit a performance target.
• Abstract data types and object-oriented design. Separating the interface of a structure from its implementation, and why that separation supports maintainable software.

Expect a mix of conceptual questions and questions that show you a short block of code or a piece of pseudocode and ask what it does, what it returns, or what its complexity is. You are not asked to author a program from scratch. Both halves are learnable; they just need different practice. Confirm the current format and any time limit in your official course of study, since assessment details are revised from time to time.

How Hard Is It, and How Long Should You Budget?

Many students report that C949 lands in the middle of the technology curriculum: harder than a survey course, gentler than the upper-level programming courses that follow. The typical account is a few weeks of focused study, with people who already have programming experience moving faster and people meeting linked lists and Big-O for the first time needing longer. Treat any single number you see online with suspicion — completion time here tracks prior exposure more than almost any other course.

The real difficulty is not that the material is obscure. It is that the material is cumulative and abstract at the same time. Skimming a chapter on hash tables produces a comfortable feeling of understanding that evaporates the moment a question asks you to compare collision-handling strategies. That gap between recognition and recall is what catches people, and the plan below is built to close it.

A Study Plan Shaped Around This Material

1. Take the pre-assessment early, not at the end. Sitting it before you feel ready is uncomfortable and enormously useful: it converts a vague syllabus into a ranked list of what you personally need to fix.
2. Work the course materials actively. If your materials include interactive exercises, attempt first and check after. A wrong answer you then diagnose teaches more than a worked example you read.
3. Build a one-page comparison table and rebuild it from memory. Rows: array, linked list, stack, queue, binary search tree, hash table. Columns: how it stores data, access, search, insert, delete, typical use. Draw it blank once a day; your recall gaps become specific and obvious.
4. Trace code by hand before you run it. Take a short snippet, predict the output on paper, then execute it. Every mismatch is a precise misconception you can correct. This is the best possible preparation for code-reading questions.
5. Implement, don't just read. Write a linked list with insert and delete, a stack and a queue, and one sorting algorithm from scratch. Production quality is not the point — the point is that pointer manipulation and loop boundaries stop being mysterious.
6. Practice Big-O out loud. For any snippet, ask how many times each loop runs relative to n and whether loops are nested. Say the answer as a sentence before you write the notation.
7. Space your reviews. Revisit week one's structures during week three. Flashcards work well for terminology and complexity classes because the answers are short and unambiguous.
8. Use official channels for help. Your course instructor and WGU cohort sessions are free, targeted, and legitimate. The WGU Computer Science program page shows how the course fits the wider plan.

Where Students Trip in C949

• Memorizing complexity classes without understanding them. Knowing binary search is logarithmic is not enough if you cannot explain that it depends on sorted input.
• Confusing a data structure with its implementation. A stack is a behavior — last in, first out. It can be built on an array or a linked list, and questions probe exactly that distinction.
• Treating hash tables as magic. Skipping collisions leaves you helpless when asked what happens if two keys hash to the same slot.
• Rushing tree traversals. In-order, pre-order, and post-order blur together unless you practice them repeatedly on an actual drawn tree.
• Grinding generic coding puzzles instead of course content. Outside practice problems are a useful supplement, not a substitute. Anchor to the course materials first.
• Relying on third-party "answer" sites. Scraped question banks violate academic integrity, are frequently wrong, and leave you unable to reason when a question is phrased differently.
• Scheduling the exam the moment the pre-assessment passes. Give yourself a couple of days to shore up the weak areas it exposed.

Readiness Checklist

• Can you sketch a linked list on paper and walk through inserting a node in the middle, naming every pointer that changes?
• Can you state average and worst-case time complexity for search, insert, and delete on an array, a linked list, a binary search tree, and a hash table?
• Can you explain why binary search requires sorted data, and what goes wrong if it does not have it?
• Can you describe at least two sorting algorithms in words — how each works and when you would prefer it?
• Can you produce in-order, pre-order, and post-order traversals of a small binary tree without looking anything up?
• Can you explain what a hash collision is and describe more than one way to handle it?
• Given an unfamiliar snippet with nested loops, can you determine its Big-O and justify your answer?
• Can you explain the difference between an abstract data type and a concrete implementation, with an example?
• Have you passed the pre-assessment and then specifically reviewed every area it flagged?

FAQ

Is C949 an OA or a PA?

C949 is assessed by an objective assessment only. There is no performance task or submitted project, so your entire preparation aims at one proctored exam.

How many competency units is C949 worth?

Four competency units. It appears in the Computer Science, Software Engineering, and Data Analytics bachelor's programs within WGU's School of Technology.

Do I need to be good at programming to pass?

You need to be comfortable reading code — following loops, conditionals, and function calls — more than you need to be a strong writer of it. Writing small implementations yourself is a study technique here, not a graded requirement.

What programming language does the course use?

Course materials commonly present examples in Python, though you may also encounter pseudocode. The concepts are language-independent, so if you learned to program elsewhere, focus on the ideas and pick up enough syntax to read snippets confidently.

How long does C949 usually take?

Many students report finishing in a few weeks of consistent study, with prior programming exposure being the biggest factor. Set your pace by how quickly your pre-assessment results improve rather than by someone else's timeline.

What should I study if my pre-assessment score is low?

Rebuild the weakest competency area from the ground up rather than reviewing everything evenly — for most people that means complexity analysis and trees. Re-attempt the pre-assessment afterward so you can see whether the gap actually closed.

Keep Going

Once C949 is behind you, the reasoning you built here carries directly into D422 Discrete Math: Algorithms and Cryptography and into the applied programming courses further along your plan. Browse more School of Technology guides on the technology hub, or see the full course guide index.

This site is an independent study resource and is not affiliated with or endorsed by Western Governors University. Always confirm course requirements in your official WGU course of study.