C949 Data Structures and Algorithms I is a Western Governors University computing course on the building blocks every programmer uses to store and process data.
The course description covers dynamic data structures such as bags, lists, stacks, queues, trees and hash tables, with their associated algorithms. It also treats object-oriented design and abstract data types as design paradigms, and emphasizes problem solving and designing efficient, maintainable software.
C949 feels hard because it is abstract. You need to picture what happens in memory, compare options by efficiency and trace algorithms by hand, often without a compiler to help.
Course at a Glance
| Item | Details |
|---|---|
| University | Western Governors University (WGU) |
| Course code | C949 |
| Level | Undergraduate, competency-based |
| Subject area | Computer science: data structures and algorithms |
| Followed by | C950 Data Structures and Algorithms II |
| Typical work | Tracing algorithms, choosing structures, complexity analysis |
What C949 Covers
| Topic | In plain language |
|---|---|
| Abstract data types | What a structure does (its operations), separate from how it is built |
| Lists and bags | Ordered and unordered collections; arrays versus linked lists |
| Stacks and queues | Last in, first out versus first in, first out |
| Trees | Hierarchies; binary search trees keep data sorted for fast lookup |
| Hash tables | Near-constant-time lookup by key, with collision handling |
| Searching, sorting and Big-O | How running time grows as input grows |
Key Concepts Explained
Big-O Notation
Big-O describes how the work an algorithm does grows with input size n. Linear search is O(n); binary search on sorted data is O(log n); a simple nested-loop sort is O(n squared).
Example: Searching a sorted list of 1,000,000 items. Linear search may check all 1,000,000. Binary search halves the range each step, so it needs at most about 20 comparisons, because 2 to the power 20 is just over a million.
Stacks in Action
A stack supports push, pop and peek. It suits any problem where the most recent item must be handled first, such as undo features or matching brackets.
Example: To check "( [ ] )", push "(" then "[". On "]", pop "[" (a match). On ")", pop "(" (a match). The stack ends empty, so the brackets are balanced. For "( ]", popping "(" on "]" is a mismatch.
Hash Table Collisions
A hash function maps keys to buckets. When two keys land in the same bucket, chaining stores both in a list there, while open addressing probes for the next free slot.
Example: With 10 buckets and hash = key mod 10, keys 15 and 25 both map to bucket 5. Chaining stores them as 15 then 25 in bucket 5; linear probing puts 25 in bucket 6 if it is empty.
Choosing the Right Structure
Much of C949 comes down to one question: given what a program needs to do most often, which structure fits? Start from the operations, not the structure.
| Scenario | Good fit | Why |
|---|---|---|
| Undo history in an editor | Stack | Latest action is undone first |
| Print jobs or help-desk tickets | Queue | First come, first served |
| Look up a user by ID | Hash table | Fast access by key |
| Keep names sorted while adding | Balanced search tree | Ordered and fast to search |
| Frequent inserts in the middle | Linked list | No shifting of elements |
| Fast access by position | Array | Direct indexing |
Abstract Data Types Versus Implementations
A list is an abstract data type: it promises operations like insert, remove and get. An array-based list and a linked list are two implementations with different costs.
Getting item 500 is instant in an array but needs 500 steps along a linked list, while inserting at the front is the reverse. Questions often test whether you can separate the promise from the build.
Typical Work and How to Approach It
| Task type | What it tests | How to approach it |
|---|---|---|
| Trace an algorithm | Step-by-step understanding | Write the state after every step |
| Choose a structure | Matching needs to operations | List the operations used most, then compare costs |
| Complexity questions | Big-O reasoning | Count loops and how input shrinks |
| Short implementations | Applying the concepts | Test edge cases: empty, one item, duplicates |
Confirm the current assessment format on your WGU course page, as versions change.
Where Students Get Stuck
- Memorizing without picturing. Draw nodes and pointers for every linked list and tree operation.
- Tree traversals. Pre-order, in-order and post-order look alike; practice on the same small tree until each is automatic.
- Average versus worst case. A binary search tree is O(log n) when balanced but O(n) if it degenerates into a line.
- Sorting algorithm details. Know how quicksort, merge sort, insertion sort and selection sort behave, not only their Big-O.
Study Tips for C949
- Keep a one-page table of every structure with the cost of insert, delete and search.
- Code each structure once yourself, even in a few lines; it fixes the ideas.
- Use free visualization tools to watch sorts and tree operations run.
- Explain why a structure fits a scenario in one sentence; that is the skill most questions test.
How We Help with C949
Send the topics, practice questions or code you are working on. A computer science tutor prepares explained notes, hand traces, complexity walkthroughs and practice problems with answers, or reviews your own code and reasoning.
GradeEssays is independent of Western Governors University. Our help is for learning: we never take exams, complete proctored assessments or access student accounts. Use our material to study, then complete your own work under WGU's academic integrity rules. Revisions within the scope of your original request are free.
Master C949 Data Structures
Share what you are studying and where you lose marks. A CS tutor prepares explained notes, traces and practice problems.
Start My C949 HelpFree revisions · Full refund if late · Written from scratch for your order
Frequently Asked Questions
Dynamic data structures such as bags, lists, stacks, queues, trees and hash tables, their algorithms, abstract data types and efficient software design.
It is abstract rather than long. Drawing structures and tracing algorithms by hand makes it much more manageable.
A stack removes the most recently added item first (LIFO); a queue removes the oldest item first (FIFO).
It predicts how an algorithm scales, so you can choose a structure that stays fast as data grows.
C950 Data Structures and Algorithms II, which moves on to graphs, advanced hashing, dynamic programming and NP-complete problems.
Yes, with explained notes, traces and practice questions. We do not sit exams or log in to WGU systems for you.