WGU C949
DATA STRUCTURES
& ALGORITHMS I
Objective Assessment Study Guide
Revised 2026 Alignment
150
2 100%
Original Practice
Timed Mock Exams Detailed Rationales
Questions
Algorithms • Big O • Arrays • Linked Lists • Stacks • Queues
Trees • Hash Tables • Searching • Sorting • Recursion • Python/OOP
WISEMAN STUDY SERIES | 2026 EDITION
,Important Use Notice
This independent resource contains original instructional explanations and original practice questions. It is not affiliated with,
endorsed by, or produced by Western Governors University. It does not reproduce a protected pre-assessment, objective
assessment, course-planning tool, or proprietary question bank. Course requirements can change; students should confirm
current requirements inside their WGU course portal.
How to Use This Guide
Begin with the diagnostic checklist, review weak domains, complete Practice Set A without notes, study every rationale, and
then complete the two timed mock exams. Do not memorize option letters: explain why each answer is correct and trace
every code sample by hand.
Verified Course Scope
The public WGU course description emphasizes dynamic data structures, associated algorithms, abstract data types,
object-oriented design, and efficient maintainable software. Public reports of the January 5, 2026 revision indicate closer
PA/OA alignment, not a wholesale replacement of the core subject matter.
Mastery Checklist
Domain You should be able to...
Algorithm design Identify inputs, outputs, steps, termination, correctness, decomposition and edge cases
Complexity Classify O(1), O(log n), O(n), O(n log n), O(n²), and compare time/space tradeoffs
Linear structures Select and trace arrays, linked lists, stacks and queues
Associative structures Explain hashing, collisions, chaining, probing and load factor
Trees Use BST rules and recognize preorder, inorder and postorder traversals
Searching/sorting Trace linear/binary search and common elementary/divide-and-conquer sorts
Recursion/OOP Identify base cases, stack behavior, classes, objects, encapsulation and ADTs
WGU C949 OA Study Guide | Original Practice Material
,1. Algorithms and Problem Solving
An algorithm is a finite, definite sequence that transforms input into output. Strong designs separate the problem into
subproblems, state preconditions and postconditions, and test ordinary, boundary, invalid, and empty inputs. Correctness
asks whether the method returns the required result; efficiency asks how resource use grows.
2. Big-O and Resource Analysis
Focus on the dominant growth term. Constant indexing is O(1); halving is O(log n); a full pass is O(n); efficient comparison
sorting is O(n log n); two full nested passes are O(n²). Distinguish best, average, and worst cases and recognize that an
implementation can trade additional memory for speed.
Pattern Typical class
Direct access / fixed work O(1)
Repeated halving O(log n)
One full traversal O(n)
Divide, process, merge O(n log n)
Two nested full traversals O(n²)
3. Arrays and Linked Lists
Arrays provide fast indexed access but insertions near the front can require shifts. Linked lists store nodes connected by
references; they support local insertion but do not provide constant-time indexing. Doubly linked lists add backward traversal
at the cost of another reference per node.
4. Stacks and Queues
Stacks are LIFO and support push, pop, and peek. Queues are FIFO and support enqueue, dequeue, and front/peek. Select
structures from required behavior: undo and delimiter matching use stacks; arrival-order processing and breadth-first frontiers
use queues.
5. Hash Tables
A hash function maps a key to a bucket. Collisions are inevitable and may be handled with separate chaining or open
addressing. Performance depends on distribution, capacity, and load factor. Resizing and rehashing maintain expected
average constant-time access.
6. Trees
Trees model hierarchy. A binary search tree maintains smaller keys on the left and larger keys on the right. Inorder traversal
yields sorted order. Balanced height supports logarithmic operations; a skewed tree may degrade to linear time.
7. Searching and Sorting
WGU C949 OA Study Guide | Original Practice Material
, Linear search needs no ordering but is O(n). Binary search needs sorted data and efficient midpoint access and is O(log n).
Know the behavior and tradeoffs of bubble, selection, insertion, merge, and quicksort, including stability and worst-case
behavior.
Algorithm Best Average Worst Stable?
Bubble O(n)* O(n²) O(n²) Yes
Selection O(n²) O(n²) O(n²) Usually no
Insertion O(n) O(n²) O(n²) Yes
Merge O(n log n) O(n log n) O(n log n) Yes
Quick O(n log n) O(n log n) O(n²) Usually no
*O(n) best case assumes an optimized early-exit bubble sort.
8. Recursion, Python, OOP and ADTs
Recursion requires a base case and progress toward it. Active calls occupy stack frames. A class defines object state and
behavior; encapsulation hides representation. An ADT specifies operations independently of implementation, letting client
code remain stable when representation changes.
WGU C949 OA Study Guide | Original Practice Material
DATA STRUCTURES
& ALGORITHMS I
Objective Assessment Study Guide
Revised 2026 Alignment
150
2 100%
Original Practice
Timed Mock Exams Detailed Rationales
Questions
Algorithms • Big O • Arrays • Linked Lists • Stacks • Queues
Trees • Hash Tables • Searching • Sorting • Recursion • Python/OOP
WISEMAN STUDY SERIES | 2026 EDITION
,Important Use Notice
This independent resource contains original instructional explanations and original practice questions. It is not affiliated with,
endorsed by, or produced by Western Governors University. It does not reproduce a protected pre-assessment, objective
assessment, course-planning tool, or proprietary question bank. Course requirements can change; students should confirm
current requirements inside their WGU course portal.
How to Use This Guide
Begin with the diagnostic checklist, review weak domains, complete Practice Set A without notes, study every rationale, and
then complete the two timed mock exams. Do not memorize option letters: explain why each answer is correct and trace
every code sample by hand.
Verified Course Scope
The public WGU course description emphasizes dynamic data structures, associated algorithms, abstract data types,
object-oriented design, and efficient maintainable software. Public reports of the January 5, 2026 revision indicate closer
PA/OA alignment, not a wholesale replacement of the core subject matter.
Mastery Checklist
Domain You should be able to...
Algorithm design Identify inputs, outputs, steps, termination, correctness, decomposition and edge cases
Complexity Classify O(1), O(log n), O(n), O(n log n), O(n²), and compare time/space tradeoffs
Linear structures Select and trace arrays, linked lists, stacks and queues
Associative structures Explain hashing, collisions, chaining, probing and load factor
Trees Use BST rules and recognize preorder, inorder and postorder traversals
Searching/sorting Trace linear/binary search and common elementary/divide-and-conquer sorts
Recursion/OOP Identify base cases, stack behavior, classes, objects, encapsulation and ADTs
WGU C949 OA Study Guide | Original Practice Material
,1. Algorithms and Problem Solving
An algorithm is a finite, definite sequence that transforms input into output. Strong designs separate the problem into
subproblems, state preconditions and postconditions, and test ordinary, boundary, invalid, and empty inputs. Correctness
asks whether the method returns the required result; efficiency asks how resource use grows.
2. Big-O and Resource Analysis
Focus on the dominant growth term. Constant indexing is O(1); halving is O(log n); a full pass is O(n); efficient comparison
sorting is O(n log n); two full nested passes are O(n²). Distinguish best, average, and worst cases and recognize that an
implementation can trade additional memory for speed.
Pattern Typical class
Direct access / fixed work O(1)
Repeated halving O(log n)
One full traversal O(n)
Divide, process, merge O(n log n)
Two nested full traversals O(n²)
3. Arrays and Linked Lists
Arrays provide fast indexed access but insertions near the front can require shifts. Linked lists store nodes connected by
references; they support local insertion but do not provide constant-time indexing. Doubly linked lists add backward traversal
at the cost of another reference per node.
4. Stacks and Queues
Stacks are LIFO and support push, pop, and peek. Queues are FIFO and support enqueue, dequeue, and front/peek. Select
structures from required behavior: undo and delimiter matching use stacks; arrival-order processing and breadth-first frontiers
use queues.
5. Hash Tables
A hash function maps a key to a bucket. Collisions are inevitable and may be handled with separate chaining or open
addressing. Performance depends on distribution, capacity, and load factor. Resizing and rehashing maintain expected
average constant-time access.
6. Trees
Trees model hierarchy. A binary search tree maintains smaller keys on the left and larger keys on the right. Inorder traversal
yields sorted order. Balanced height supports logarithmic operations; a skewed tree may degrade to linear time.
7. Searching and Sorting
WGU C949 OA Study Guide | Original Practice Material
, Linear search needs no ordering but is O(n). Binary search needs sorted data and efficient midpoint access and is O(log n).
Know the behavior and tradeoffs of bubble, selection, insertion, merge, and quicksort, including stability and worst-case
behavior.
Algorithm Best Average Worst Stable?
Bubble O(n)* O(n²) O(n²) Yes
Selection O(n²) O(n²) O(n²) Usually no
Insertion O(n) O(n²) O(n²) Yes
Merge O(n log n) O(n log n) O(n log n) Yes
Quick O(n log n) O(n log n) O(n²) Usually no
*O(n) best case assumes an optimized early-exit bubble sort.
8. Recursion, Python, OOP and ADTs
Recursion requires a base case and progress toward it. Active calls occupy stack frames. A class defines object state and
behavior; encapsulation hides representation. An ADT specifies operations independently of implementation, letting client
code remain stable when representation changes.
WGU C949 OA Study Guide | Original Practice Material
