WGU C949 FINAL VERIFIED EXAM DATA STRUCTURES AND ALGORITHMS | HIGHER EDUCATION CS
2026/2027 ACADEMIC YEAR | VERIFIED Q&A | ADVANCED DATA STRUCTURES & ALGORITHMS LEARNERS
WGU C949
DATA STRUCTURES
ALGORITHMS 2026/2027
WGU C949 Data Structures and Algorithms Final
Higher Education Computer Science Curriculum
2026/2027 Academic Year | Verified Q&A for Advanced Data Structures
and Algorithms Learners | Final Verified Exam
150Q VERIFIED NEWEST EXAM RATIONALES
FINAL EXAM 2026/2027 ADV LEARNERS
INCLUDES:
• Arrays, Linked Lists, Stacks, Queues, Trees, Graphs, Hash Tables
• Big O, Sorting, Searching, Recursion, Dynamic Programming, Complexity
• 150 Verified Questions + Answers + Detailed Rationales | C949 Final
• Professional Study Guide | Borders + Page Numbers | 2026/2027 Edition
WGU C949 Data Structures and Algorithms | Not affiliated with WGU
Confidential Study Guide - Educational Purposes Only | 2026/2027 Edition
,Fundamental Data Structures Arrays Linked Lists Stacks Queues
Description: Fundamental data structures arrays contiguous memory same type O(1) random access index O(n) insertion deletion shifting, dynamic arrays ArrayList
resizing, linked lists non-contiguous nodes data next pointer singly linked one direction doubly linked prev next circular, operations insertion deletion O(1) at head if pointer
O(n) search O(n) access, stacks LIFO Last In First Out ADT Abstract Data Type operations push add top pop remove top peek top isEmpty, implementations array linked
list, applications function call stack undo, queues FIFO First In First Out enqueue add rear dequeue remove front, implementations array circular buffer linked list, variants
deque double-ended queue priority queue, Big O notation asymptotic analysis time complexity space complexity worst case average best case O(1) constant time hash
lookup stack push pop, O(log n) logarithmic binary search balanced BST, O(n) linear linear search traversal, O(n log n) linearithmic efficient sorts merge quick heap, O(n^2)
quadratic bubble selection insertion nested loops, O(2^n) exponential recursive Fibonacci without memoization O(n!) factorial permutations.
Trees Graphs Hash Tables Complexity
Description: Trees hierarchical non-linear data structure root parent child leaf sibling depth height, binary tree each node max 2 children left right, types full complete perfect
balanced, Binary Search Tree BST property left subtree keys < node < right subtree keys O(h) operations O(log n) balanced O(n) skewed, traversal inorder LNR left root
right yields sorted order BST, preorder NLR root left right copy tree, postorder LRN left right root delete tree, level order BFS queue, self-balancing AVL Red-Black, heaps
complete binary tree min heap parent <= children min at root max heap parent >= children max at root, priority queue heap implementation O(log n) insert extract, heapsort,
hash tables hash map dictionary key value O(1) average O(n) worst, hash function maps key to index, collision resolution chaining linked list buckets at same index, open
addressing probing linear quadratic double hashing, load factor n/m rehashing resizing, graphs G=(V,E) vertices nodes edges, types directed undirected weighted
unweighted cyclic acyclic DAG, representations adjacency matrix 2D array O(V^2) space O(1) edge lookup, adjacency list array of lists O(V+E) space efficient sparse, BFS
Breadth First Search queue level by level O(V+E) shortest path unweighted, DFS Depth First Search stack recursion O(V+E) topological sort cycle detection, Dijkstra
shortest path weighted positive, Bellman-Ford negative weights, Floyd-Warshall all pairs.
Sorting Searching Recursion Dynamic Programming Advanced Algorithms
Description: Sorting algorithms comparison sorts bubble O(n^2) stable swap adjacent, selection O(n^2) unstable min index swap, insertion O(n^2) stable shifts, merge sort
divide and conquer O(n log n) stable recursion merges, quick sort partition pivot O(n log n) average O(n^2) worst unstable in-place, heap sort heapify O(n log n) unstable,
counting radix bucket non-comparison O(n+k), searching linear O(n) unsorted sequential, binary O(log n) sorted divide half requires random access, interpolation improved
binary uniform distribution, hash O(1) average, recursion function calls itself base case termination recursive case reduces problem call stack risk stack overflow, dynamic
programming optimization overlapping subproblems optimal substructure memoization top-down caching recursion + cache tabulation bottom-up iteration table, examples
Fibonacci DP O(n), knapsack 0/1 DP, Longest Common Subsequence LCS, advanced analysis amortized complexity, NP completeness P NP NP-hard, WGU C949
zyBooks Python data structures algorithms implementation.
Page 2 - WGU C949 150Q 2026/2027
,Question 1: Q1: Arrays vs Linked Lists - time complexity and use cases?
A. Arrays O(1) access index contiguous memory, O(n) insert delete, Linked Lists O(n) access O(1) insert delete at head, singly doubly linked
B. Arrays O(n) access
C. Linked Lists O(1) access
D. No difference arrays linked lists
CORRECT ANSWER: A. Arrays O(1) access index contiguous memory, O(n) insert delete, Linked Lists O(n) access O(1) insert delete at head,
singly doubly linked
RATIONALE:
Rationale: Arrays O(1) access index contiguous memory, O(n) insert delete, Linked Lists O(n) access O(1) insert delete at head, singly doubly linked. Per WGU C949
Data Structures and Algorithms curriculum, zyBooks and CLRS Introduction to Algorithms, covering advanced data structures and algorithms concepts for higher
education computer science curriculum 2026/2027.
Question 2: Q2: Stacks and Queues - LIFO FIFO implementations?
A. Queue LIFO
B. Stack FIFO
C. Stack LIFO Last In First Out push pop top, Queue FIFO First In First Out enqueue dequeue, implementations array linked list
D. No LIFO FIFO stacks queues
CORRECT ANSWER: C. Stack LIFO Last In First Out push pop top, Queue FIFO First In First Out enqueue dequeue, implementations array
linked list
RATIONALE:
Rationale: Stack LIFO Last In First Out push pop top, Queue FIFO First In First Out enqueue dequeue, implementations array linked list. Per WGU C949 Data Structures
and Algorithms curriculum, zyBooks and CLRS Introduction to Algorithms, covering advanced data structures and algorithms concepts for higher education computer
science curriculum 2026/2027.
Question 3: Q3: Big O notation - time and space complexity analysis?
A. No Big O notation
B. Big O only O(1)
C. Only O(n) exists Big O
D. Big O O(1) constant O(log n) logarithmic O(n) linear O(n log n) linearithmic O(n^2) quadratic O(2^n) exponential O(n!) factorial
CORRECT ANSWER: D. Big O O(1) constant O(log n) logarithmic O(n) linear O(n log n) linearithmic O(n^2) quadratic O(2^n) exponential O(n!)
factorial
RATIONALE:
Rationale: Big O O(1) constant O(log n) logarithmic O(n) linear O(n log n) linearithmic O(n^2) quadratic O(2^n) exponential O(n!) factorial. Per WGU C949 Data Structures
and Algorithms curriculum, zyBooks and CLRS Introduction to Algorithms, covering advanced data structures and algorithms concepts for higher education computer
science curriculum 2026/2027.
Question 4: Q4: Trees - binary tree BST traversal types?
A. Only inorder traversal trees
B. Tree hierarchical, binary tree each node max 2 children, BST Binary Search Tree left < parent < right, traversal inorder LNR sorted, preorder NLR,
postorder LRN, level order BFS
C. No BST trees
D. Only preorder trees
CORRECT ANSWER: B. Tree hierarchical, binary tree each node max 2 children, BST Binary Search Tree left < parent < right, traversal inorder
LNR sorted, preorder NLR, postorder LRN, level order BFS
RATIONALE:
Rationale: Tree hierarchical, binary tree each node max 2 children, BST Binary Search Tree left < parent < right, traversal inorder LNR sorted, preorder NLR, postorder
LRN, level order BFS. Per WGU C949 Data Structures and Algorithms curriculum, zyBooks and CLRS Introduction to Algorithms, covering advanced data structures and
algorithms concepts for higher education computer science curriculum 2026/2027.
Question 5: Q5: Heaps and priority queues - min heap max heap?
A. Heap complete binary tree min heap parent <= children min at root, max heap parent >= children max at root, priority queue implemented heap O(log
n) insert extract
B. Heap not binary tree
C. No min heap exists
D. Only max heap exists
CORRECT ANSWER: A. Heap complete binary tree min heap parent <= children min at root, max heap parent >= children max at root, priority
queue implemented heap O(log n) insert extract
RATIONALE:
Rationale: Heap complete binary tree min heap parent <= children min at root, max heap parent >= children max at root, priority queue implemented heap O(log n) insert
extract. Per WGU C949 Data Structures and Algorithms curriculum, zyBooks and CLRS Introduction to Algorithms, covering advanced data structures and algorithms
concepts for higher education computer science curriculum 2026/2027.
Question 6: Q6: Hash tables - collision resolution chaining open addressing?
A. Only chaining hash tables
B. No collision hash tables
C. Hash table O(1) average lookup hash function, collision resolution chaining linked list at bucket, open addressing linear probing quadratic double
hashing, load factor
D. No hash tables
CORRECT ANSWER: C. Hash table O(1) average lookup hash function, collision resolution chaining linked list at bucket, open addressing
linear probing quadratic double hashing, load factor
RATIONALE:
Page 3 - WGU C949 150Q 2026/2027
, Rationale: Hash table O(1) average lookup hash function, collision resolution chaining linked list at bucket, open addressing linear probing quadratic double hashing, load
factor. Per WGU C949 Data Structures and Algorithms curriculum, zyBooks and CLRS Introduction to Algorithms, covering advanced data structures and algorithms
concepts for higher education computer science curriculum 2026/2027.
Question 7: Q7: Sorting algorithms - comparison of time complexities?
A. Only bubble sort exists
B. All sorting O(n)
C. No time complexities sorting
D. Sorting bubble O(n^2) selection O(n^2) insertion O(n^2) merge O(n log n) quick O(n log n) avg O(n^2) worst heap O(n log n), stable vs unstable
CORRECT ANSWER: D. Sorting bubble O(n^2) selection O(n^2) insertion O(n^2) merge O(n log n) quick O(n log n) avg O(n^2) worst heap O(n
log n), stable vs unstable
RATIONALE:
Rationale: Sorting bubble O(n^2) selection O(n^2) insertion O(n^2) merge O(n log n) quick O(n log n) avg O(n^2) worst heap O(n log n), stable vs unstable. Per WGU
C949 Data Structures and Algorithms curriculum, zyBooks and CLRS Introduction to Algorithms, covering advanced data structures and algorithms concepts for higher
education computer science curriculum 2026/2027.
Question 8: Q8: Searching algorithms - binary search requirements?
A. Binary search unsorted array
B. Searching linear search O(n) unsorted, binary search O(log n) requires sorted array divide and conquer, hash search O(1) avg
C. Linear search O(1)
D. No searching algorithms
CORRECT ANSWER: B. Searching linear search O(n) unsorted, binary search O(log n) requires sorted array divide and conquer, hash search
O(1) avg
RATIONALE:
Rationale: Searching linear search O(n) unsorted, binary search O(log n) requires sorted array divide and conquer, hash search O(1) avg. Per WGU C949 Data
Structures and Algorithms curriculum, zyBooks and CLRS Introduction to Algorithms, covering advanced data structures and algorithms concepts for higher education
computer science curriculum 2026/2027.
Question 9: Q9: Graphs - representations BFS DFS?
A. Graph nodes vertices edges, representations adjacency matrix O(V^2) adjacency list O(V+E), BFS Breadth First Search queue level order, DFS Depth
First Search stack recursion
B. No representations graphs
C. Only BFS graphs
D. Only DFS graphs
CORRECT ANSWER: A. Graph nodes vertices edges, representations adjacency matrix O(V^2) adjacency list O(V+E), BFS Breadth First
Search queue level order, DFS Depth First Search stack recursion
RATIONALE:
Rationale: Graph nodes vertices edges, representations adjacency matrix O(V^2) adjacency list O(V+E), BFS Breadth First Search queue level order, DFS Depth First
Search stack recursion. Per WGU C949 Data Structures and Algorithms curriculum, zyBooks and CLRS Introduction to Algorithms, covering advanced data structures
and algorithms concepts for higher education computer science curriculum 2026/2027.
Question 10: Q10: Dynamic programming and recursion - memoization?
A. Only memoization recursion
B. No recursion dynamic programming
C. Recursion function calls itself base case, dynamic programming optimization overlapping subproblems memoization top-down caching tabulation
bottom-up, examples Fibonacci knapsack LCS
D. No dynamic programming
CORRECT ANSWER: C. Recursion function calls itself base case, dynamic programming optimization overlapping subproblems memoization
top-down caching tabulation bottom-up, examples Fibonacci knapsack LCS
RATIONALE:
Rationale: Recursion function calls itself base case, dynamic programming optimization overlapping subproblems memoization top-down caching tabulation bottom-up,
examples Fibonacci knapsack LCS. Per WGU C949 Data Structures and Algorithms curriculum, zyBooks and CLRS Introduction to Algorithms, covering advanced data
structures and algorithms concepts for higher education computer science curriculum 2026/2027.
Page 4 - WGU C949 150Q 2026/2027
2026/2027 ACADEMIC YEAR | VERIFIED Q&A | ADVANCED DATA STRUCTURES & ALGORITHMS LEARNERS
WGU C949
DATA STRUCTURES
ALGORITHMS 2026/2027
WGU C949 Data Structures and Algorithms Final
Higher Education Computer Science Curriculum
2026/2027 Academic Year | Verified Q&A for Advanced Data Structures
and Algorithms Learners | Final Verified Exam
150Q VERIFIED NEWEST EXAM RATIONALES
FINAL EXAM 2026/2027 ADV LEARNERS
INCLUDES:
• Arrays, Linked Lists, Stacks, Queues, Trees, Graphs, Hash Tables
• Big O, Sorting, Searching, Recursion, Dynamic Programming, Complexity
• 150 Verified Questions + Answers + Detailed Rationales | C949 Final
• Professional Study Guide | Borders + Page Numbers | 2026/2027 Edition
WGU C949 Data Structures and Algorithms | Not affiliated with WGU
Confidential Study Guide - Educational Purposes Only | 2026/2027 Edition
,Fundamental Data Structures Arrays Linked Lists Stacks Queues
Description: Fundamental data structures arrays contiguous memory same type O(1) random access index O(n) insertion deletion shifting, dynamic arrays ArrayList
resizing, linked lists non-contiguous nodes data next pointer singly linked one direction doubly linked prev next circular, operations insertion deletion O(1) at head if pointer
O(n) search O(n) access, stacks LIFO Last In First Out ADT Abstract Data Type operations push add top pop remove top peek top isEmpty, implementations array linked
list, applications function call stack undo, queues FIFO First In First Out enqueue add rear dequeue remove front, implementations array circular buffer linked list, variants
deque double-ended queue priority queue, Big O notation asymptotic analysis time complexity space complexity worst case average best case O(1) constant time hash
lookup stack push pop, O(log n) logarithmic binary search balanced BST, O(n) linear linear search traversal, O(n log n) linearithmic efficient sorts merge quick heap, O(n^2)
quadratic bubble selection insertion nested loops, O(2^n) exponential recursive Fibonacci without memoization O(n!) factorial permutations.
Trees Graphs Hash Tables Complexity
Description: Trees hierarchical non-linear data structure root parent child leaf sibling depth height, binary tree each node max 2 children left right, types full complete perfect
balanced, Binary Search Tree BST property left subtree keys < node < right subtree keys O(h) operations O(log n) balanced O(n) skewed, traversal inorder LNR left root
right yields sorted order BST, preorder NLR root left right copy tree, postorder LRN left right root delete tree, level order BFS queue, self-balancing AVL Red-Black, heaps
complete binary tree min heap parent <= children min at root max heap parent >= children max at root, priority queue heap implementation O(log n) insert extract, heapsort,
hash tables hash map dictionary key value O(1) average O(n) worst, hash function maps key to index, collision resolution chaining linked list buckets at same index, open
addressing probing linear quadratic double hashing, load factor n/m rehashing resizing, graphs G=(V,E) vertices nodes edges, types directed undirected weighted
unweighted cyclic acyclic DAG, representations adjacency matrix 2D array O(V^2) space O(1) edge lookup, adjacency list array of lists O(V+E) space efficient sparse, BFS
Breadth First Search queue level by level O(V+E) shortest path unweighted, DFS Depth First Search stack recursion O(V+E) topological sort cycle detection, Dijkstra
shortest path weighted positive, Bellman-Ford negative weights, Floyd-Warshall all pairs.
Sorting Searching Recursion Dynamic Programming Advanced Algorithms
Description: Sorting algorithms comparison sorts bubble O(n^2) stable swap adjacent, selection O(n^2) unstable min index swap, insertion O(n^2) stable shifts, merge sort
divide and conquer O(n log n) stable recursion merges, quick sort partition pivot O(n log n) average O(n^2) worst unstable in-place, heap sort heapify O(n log n) unstable,
counting radix bucket non-comparison O(n+k), searching linear O(n) unsorted sequential, binary O(log n) sorted divide half requires random access, interpolation improved
binary uniform distribution, hash O(1) average, recursion function calls itself base case termination recursive case reduces problem call stack risk stack overflow, dynamic
programming optimization overlapping subproblems optimal substructure memoization top-down caching recursion + cache tabulation bottom-up iteration table, examples
Fibonacci DP O(n), knapsack 0/1 DP, Longest Common Subsequence LCS, advanced analysis amortized complexity, NP completeness P NP NP-hard, WGU C949
zyBooks Python data structures algorithms implementation.
Page 2 - WGU C949 150Q 2026/2027
,Question 1: Q1: Arrays vs Linked Lists - time complexity and use cases?
A. Arrays O(1) access index contiguous memory, O(n) insert delete, Linked Lists O(n) access O(1) insert delete at head, singly doubly linked
B. Arrays O(n) access
C. Linked Lists O(1) access
D. No difference arrays linked lists
CORRECT ANSWER: A. Arrays O(1) access index contiguous memory, O(n) insert delete, Linked Lists O(n) access O(1) insert delete at head,
singly doubly linked
RATIONALE:
Rationale: Arrays O(1) access index contiguous memory, O(n) insert delete, Linked Lists O(n) access O(1) insert delete at head, singly doubly linked. Per WGU C949
Data Structures and Algorithms curriculum, zyBooks and CLRS Introduction to Algorithms, covering advanced data structures and algorithms concepts for higher
education computer science curriculum 2026/2027.
Question 2: Q2: Stacks and Queues - LIFO FIFO implementations?
A. Queue LIFO
B. Stack FIFO
C. Stack LIFO Last In First Out push pop top, Queue FIFO First In First Out enqueue dequeue, implementations array linked list
D. No LIFO FIFO stacks queues
CORRECT ANSWER: C. Stack LIFO Last In First Out push pop top, Queue FIFO First In First Out enqueue dequeue, implementations array
linked list
RATIONALE:
Rationale: Stack LIFO Last In First Out push pop top, Queue FIFO First In First Out enqueue dequeue, implementations array linked list. Per WGU C949 Data Structures
and Algorithms curriculum, zyBooks and CLRS Introduction to Algorithms, covering advanced data structures and algorithms concepts for higher education computer
science curriculum 2026/2027.
Question 3: Q3: Big O notation - time and space complexity analysis?
A. No Big O notation
B. Big O only O(1)
C. Only O(n) exists Big O
D. Big O O(1) constant O(log n) logarithmic O(n) linear O(n log n) linearithmic O(n^2) quadratic O(2^n) exponential O(n!) factorial
CORRECT ANSWER: D. Big O O(1) constant O(log n) logarithmic O(n) linear O(n log n) linearithmic O(n^2) quadratic O(2^n) exponential O(n!)
factorial
RATIONALE:
Rationale: Big O O(1) constant O(log n) logarithmic O(n) linear O(n log n) linearithmic O(n^2) quadratic O(2^n) exponential O(n!) factorial. Per WGU C949 Data Structures
and Algorithms curriculum, zyBooks and CLRS Introduction to Algorithms, covering advanced data structures and algorithms concepts for higher education computer
science curriculum 2026/2027.
Question 4: Q4: Trees - binary tree BST traversal types?
A. Only inorder traversal trees
B. Tree hierarchical, binary tree each node max 2 children, BST Binary Search Tree left < parent < right, traversal inorder LNR sorted, preorder NLR,
postorder LRN, level order BFS
C. No BST trees
D. Only preorder trees
CORRECT ANSWER: B. Tree hierarchical, binary tree each node max 2 children, BST Binary Search Tree left < parent < right, traversal inorder
LNR sorted, preorder NLR, postorder LRN, level order BFS
RATIONALE:
Rationale: Tree hierarchical, binary tree each node max 2 children, BST Binary Search Tree left < parent < right, traversal inorder LNR sorted, preorder NLR, postorder
LRN, level order BFS. Per WGU C949 Data Structures and Algorithms curriculum, zyBooks and CLRS Introduction to Algorithms, covering advanced data structures and
algorithms concepts for higher education computer science curriculum 2026/2027.
Question 5: Q5: Heaps and priority queues - min heap max heap?
A. Heap complete binary tree min heap parent <= children min at root, max heap parent >= children max at root, priority queue implemented heap O(log
n) insert extract
B. Heap not binary tree
C. No min heap exists
D. Only max heap exists
CORRECT ANSWER: A. Heap complete binary tree min heap parent <= children min at root, max heap parent >= children max at root, priority
queue implemented heap O(log n) insert extract
RATIONALE:
Rationale: Heap complete binary tree min heap parent <= children min at root, max heap parent >= children max at root, priority queue implemented heap O(log n) insert
extract. Per WGU C949 Data Structures and Algorithms curriculum, zyBooks and CLRS Introduction to Algorithms, covering advanced data structures and algorithms
concepts for higher education computer science curriculum 2026/2027.
Question 6: Q6: Hash tables - collision resolution chaining open addressing?
A. Only chaining hash tables
B. No collision hash tables
C. Hash table O(1) average lookup hash function, collision resolution chaining linked list at bucket, open addressing linear probing quadratic double
hashing, load factor
D. No hash tables
CORRECT ANSWER: C. Hash table O(1) average lookup hash function, collision resolution chaining linked list at bucket, open addressing
linear probing quadratic double hashing, load factor
RATIONALE:
Page 3 - WGU C949 150Q 2026/2027
, Rationale: Hash table O(1) average lookup hash function, collision resolution chaining linked list at bucket, open addressing linear probing quadratic double hashing, load
factor. Per WGU C949 Data Structures and Algorithms curriculum, zyBooks and CLRS Introduction to Algorithms, covering advanced data structures and algorithms
concepts for higher education computer science curriculum 2026/2027.
Question 7: Q7: Sorting algorithms - comparison of time complexities?
A. Only bubble sort exists
B. All sorting O(n)
C. No time complexities sorting
D. Sorting bubble O(n^2) selection O(n^2) insertion O(n^2) merge O(n log n) quick O(n log n) avg O(n^2) worst heap O(n log n), stable vs unstable
CORRECT ANSWER: D. Sorting bubble O(n^2) selection O(n^2) insertion O(n^2) merge O(n log n) quick O(n log n) avg O(n^2) worst heap O(n
log n), stable vs unstable
RATIONALE:
Rationale: Sorting bubble O(n^2) selection O(n^2) insertion O(n^2) merge O(n log n) quick O(n log n) avg O(n^2) worst heap O(n log n), stable vs unstable. Per WGU
C949 Data Structures and Algorithms curriculum, zyBooks and CLRS Introduction to Algorithms, covering advanced data structures and algorithms concepts for higher
education computer science curriculum 2026/2027.
Question 8: Q8: Searching algorithms - binary search requirements?
A. Binary search unsorted array
B. Searching linear search O(n) unsorted, binary search O(log n) requires sorted array divide and conquer, hash search O(1) avg
C. Linear search O(1)
D. No searching algorithms
CORRECT ANSWER: B. Searching linear search O(n) unsorted, binary search O(log n) requires sorted array divide and conquer, hash search
O(1) avg
RATIONALE:
Rationale: Searching linear search O(n) unsorted, binary search O(log n) requires sorted array divide and conquer, hash search O(1) avg. Per WGU C949 Data
Structures and Algorithms curriculum, zyBooks and CLRS Introduction to Algorithms, covering advanced data structures and algorithms concepts for higher education
computer science curriculum 2026/2027.
Question 9: Q9: Graphs - representations BFS DFS?
A. Graph nodes vertices edges, representations adjacency matrix O(V^2) adjacency list O(V+E), BFS Breadth First Search queue level order, DFS Depth
First Search stack recursion
B. No representations graphs
C. Only BFS graphs
D. Only DFS graphs
CORRECT ANSWER: A. Graph nodes vertices edges, representations adjacency matrix O(V^2) adjacency list O(V+E), BFS Breadth First
Search queue level order, DFS Depth First Search stack recursion
RATIONALE:
Rationale: Graph nodes vertices edges, representations adjacency matrix O(V^2) adjacency list O(V+E), BFS Breadth First Search queue level order, DFS Depth First
Search stack recursion. Per WGU C949 Data Structures and Algorithms curriculum, zyBooks and CLRS Introduction to Algorithms, covering advanced data structures
and algorithms concepts for higher education computer science curriculum 2026/2027.
Question 10: Q10: Dynamic programming and recursion - memoization?
A. Only memoization recursion
B. No recursion dynamic programming
C. Recursion function calls itself base case, dynamic programming optimization overlapping subproblems memoization top-down caching tabulation
bottom-up, examples Fibonacci knapsack LCS
D. No dynamic programming
CORRECT ANSWER: C. Recursion function calls itself base case, dynamic programming optimization overlapping subproblems memoization
top-down caching tabulation bottom-up, examples Fibonacci knapsack LCS
RATIONALE:
Rationale: Recursion function calls itself base case, dynamic programming optimization overlapping subproblems memoization top-down caching tabulation bottom-up,
examples Fibonacci knapsack LCS. Per WGU C949 Data Structures and Algorithms curriculum, zyBooks and CLRS Introduction to Algorithms, covering advanced data
structures and algorithms concepts for higher education computer science curriculum 2026/2027.
Page 4 - WGU C949 150Q 2026/2027
