Data Structures & Algorithms

Course Description

Data Structures & Algorithms is where students stop asking only "does this work?" and start asking "how well does this work, and why?" The course covers the core data structures used throughout the rest of the curriculum — stacks, queues, trees, hash tables, graphs — alongside the analytical tools to reason about their time and space costs. Every structure is motivated by a problem it solves better than the alternatives.

Learning Outcomes

Select an appropriate data structure for a given problem and justify the choice.
Analyze the time and space complexity of an algorithm using asymptotic notation.
Implement core data structures from scratch and reason about their invariants.
Trace and explain classic algorithms over lists, trees, and graphs.
Compare alternative solutions to the same problem on efficiency grounds.
Apply complexity analysis to critique code written by someone else.

Weekly Topics

Introduces Big-O notation as a tool for comparing algorithms independent of hardware, using small examples students can trace by hand before trusting the notation.

Builds the simplest linear structures from first principles and examines the operations each one makes cheap or expensive by design.

Contrasts array-based and pointer-based storage, using a shared set of operations to make the trade-offs concrete rather than abstract.

Returns to recursion with an efficiency lens, analyzing call stacks and identifying when recursive elegance costs more than it's worth.

Introduces hierarchical structures and the search-tree invariant that makes lookup, insertion, and deletion efficient when it holds.

Explains why an unbalanced tree degrades toward a linked list, and surveys how balancing strategies keep operations efficient in the worst case.

Consolidates linear and tree-based structures with a practice set mirroring the mid-semester assessment's format.

Covers hashing, collision handling, and why a well-designed hash table achieves near-constant-time lookup in practice.

Introduces heaps as the structure behind efficient priority-based processing, with a scheduling example running throughout.

Compares adjacency lists and matrices as ways of storing graphs, and connects the choice to the algorithms covered next.

Implements breadth-first and depth-first traversal and uses both to solve reachability and connectivity problems.

Compares several sorting strategies on efficiency, stability, and practical performance rather than treating sorting as a solved, uniform problem.

Reviews the full structure-by-structure arc of the course against the final exam's format.

Assessment

Assignments — 20%

Practical Work — 25%

Mid-Semester — 20%

Final Examination — 35%

Prerequisite Map

Related Courses

Core200 Level

CSC202

Algorithms Analysis & Design

Algorithms Analysis & Design moves from the data-structure-centered view of CSC201 into general strategies for designing efficient algorithms: divide and conquer, greedy methods, dynamic programming, and the tools to argue about correctness and lower bounds.

Hannah Lindqvist 4 cr

Core300 Level

CSC301

Software Engineering Principles

Software Engineering Principles scales up everything students have learned about writing individual programs into the practice of building software as a team, over time, under changing requirements. Students work in project groups across the semester, experiencing requirements drift, code review, and the cost of a design decision made too quickly.

Advanced Algorithms pushes past the general-purpose techniques of CSC202 into specialized methods: approximation algorithms, randomized algorithms, and a deeper treatment of computational hardness. The course is proof-heavy and assumes real comfort with the CSC201/CSC202 sequence.

Hannah Lindqvist 3 cr