The following course-level learning objectives for an undergraduate Data Structures and Algorithms (DSA) course are written to be specific, observable, and measurable. They are grounded in principles of backward design and constructive alignment and use action verbs consistent with the revised Bloom’s taxonomy (Anderson & Krathwohl, 2001; Biggs & Tang, 2011; Wiggins & McTighe, 2005). Content coverage aligns with the Algorithms and Complexity knowledge area and related foundational topics identified in the ACM/IEEE-CS curricular guidance (ACM/IEEE-CS, 2013). Where appropriate, objectives explicitly integrate technology-enabled practice (e.g., version control, automated assessment, profiling, and visualization), drawing on empirical findings regarding feedback and visualization in computing education (Hundhausen, Douglas, & Stasko, 2002; Keuning, Jeuring, & Heeren, 2018).
By the end of the course, students will be able to:
- Complexity analysis
- Compute tight asymptotic bounds (Big-O, Big-Theta, Big-Omega) for time and space complexity of iterative and recursive algorithms, and justify the bounds using formal reasoning.
- Perform amortized analysis for operations on dynamic data structures (e.g., dynamic arrays, hash tables) using aggregate, accounting, or potential methods.
- Algorithm design and correctness
- Design algorithms using core paradigms (divide-and-conquer, greedy, dynamic programming, backtracking) for novel problem statements, and prove correctness using induction, loop invariants, or exchange arguments.
- Formulate and analyze trade-offs between optimality and efficiency; defend design choices in terms of problem constraints and objective functions.
- Fundamental data structures
- Implement and evaluate core data structures (arrays, linked lists, stacks, queues, hash tables, binary search trees, balanced trees such as AVL or red–black trees, heaps, and graph representations) to meet specified functional and performance requirements.
- Select an appropriate data structure for a given problem scenario and justify the selection by comparing expected time/space complexity, mutability needs, and iteration/access patterns.
- Graph algorithms
- Implement and analyze traversal and path-finding algorithms (BFS, DFS, topological sort, Dijkstra), and minimum spanning tree algorithms (Kruskal, Prim), including correctness arguments and asymptotic analyses.
- Diagnose performance bottlenecks in graph computations by relating algorithmic complexity to input characteristics (e.g., sparsity, degree distribution).
- Empirical evaluation and tooling
- Design and execute rigorous empirical evaluations that include controlled benchmarking, profiling, and statistical analysis of runtime and memory usage; reconcile empirical findings with theoretical predictions.
- Use algorithm visualization tools to explain algorithm behavior and complexity to peers and instructors, accurately interpreting the visualizations to support reasoning about correctness and performance.
- Software engineering practices for DSA
- Apply abstraction, encapsulation, and API design to create reusable implementations of data structures and algorithms; validate behavior with unit tests and property-based tests.
- Employ modern development workflows (version control, code review, and continuous integration) to manage DSA codebases and document changes with clear commit messages and technical notes.
- Randomization and probabilistic reasoning (introductory)
- Analyze expected running time and success probability for basic randomized algorithms and data structures (e.g., randomized quicksort, hashing with chaining or open addressing), and explain how randomness influences performance guarantees.
- Memory and resource considerations
- Evaluate space–time trade-offs and cache-awareness in data structure layout and algorithm design; recommend transformations (e.g., iterative reformulation, in-place variants) to meet resource constraints.
- Communication and collaboration
- Produce clear technical artifacts—well-documented code, complexity analyses, and concise design rationales—that meet specified rubrics; deliver a short oral or video explanation that accurately communicates algorithmic ideas to a technical audience.
- Collaborate effectively on small teams to plan, implement, test, and review algorithmic solutions, demonstrating equitable participation and adherence to academic integrity.
- Metacognition and transfer
- Audit personal problem-solving processes using structured self-assessment checklists; adapt strategy selection (e.g., switching from greedy to dynamic programming) based on diagnostic evidence from failed attempts or performance gaps.
- Transfer learned patterns to unfamiliar contexts by mapping problem structure to known abstractions (e.g., reducing a scheduling problem to interval selection or shortest path).
Notes on assessment and technology integration
- Objectives 1–5 are assessable via a combination of auto-graded coding labs and written proofs, with profiling dashboards and reproducible benchmarking harnesses for empirical analysis (Keuning et al., 2018).
- Objectives 5 and 9 explicitly leverage visualization and peer explanation to strengthen conceptual understanding and communication; the literature indicates that visualization is most effective when learners are actively engaged and required to articulate reasoning (Hundhausen et al., 2002).
- Objectives 6 and 9 embed authentic tooling (e.g., Git-based workflows and CI) to align practice with professional standards while providing frequent, actionable feedback.
References
- ACM/IEEE-CS Joint Task Force on Computing Curricula. (2013). Computer Science Curricula 2013: Curriculum guidelines for undergraduate degree programs in computer science. ACM. https://doi.org/10.1145/2534860
- Anderson, L. W., & Krathwohl, D. R. (Eds.). (2001). A taxonomy for learning, teaching, and assessing: A revision of Bloom’s taxonomy of educational objectives. Longman.
- Biggs, J., & Tang, C. (2011). Teaching for quality learning at university (4th ed.). Open University Press.
- Hundhausen, C. D., Douglas, S. A., & Stasko, J. T. (2002). A meta-study of algorithm visualization effectiveness. Journal of Visual Languages & Computing, 13(3), 259–290. https://doi.org/10.1006/jvlc.2002.0237
- Keuning, P., Jeuring, J., & Heeren, B. (2018). A systematic literature review of automated feedback generation for programming exercises. ACM Computing Surveys, 51(3), Article 40. https://doi.org/10.1145/3182657
- Wiggins, G., & McTighe, J. (2005). Understanding by design (Expanded 2nd ed.). ASCD.
