Data Structures

Hands-on implementation of core data structures and algorithms — linear and circular arrays, singly and doubly linked lists, stacks, queues, recursion, hashing, trees, and heaps.

Instructor: Istiaq Ahmed Fahad

Term: Fall 2026

Location: Department of Computer Science and Engineering, BRAC University

Course Overview

CSE220: Data Structures (Lab) focuses on the practical, hands-on implementation and algorithmic analysis of fundamental data structures. Students build data structures from the ground up, gaining intuition on memory organization, reference manipulation, and asymptotic runtime and space complexity trade-offs.

Key lab topics include:

  • Array-Based Structures: Linear arrays, in-place rotation, circular array indexing and modulo arithmetic.
  • Linked Structures: Singly linked lists, doubly linked lists, dummy-headed circular lists, and node pointer manipulation.
  • Linear Abstract Data Types: Stack and queue implementations and their applications (expression parsing, parenthesis validation).
  • Recursion & Analysis: Designing recursive functions, recursive call stack analysis, and divide-and-conquer.
  • Hashing & Non-Linear Structures: Hash functions, collision resolution, binary search trees, tree traversals, and heaps.

Course Information

Textbooks & References

  1. Algorithms in Java — Robert Sedgewick and Kevin Wayne (Addison-Wesley, 4th Edition, 2011).
  2. Introduction to Algorithms — Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, Clifford Stein (MIT Press, 3rd Edition, 2009).

Prerequisites

  • CSE111 (Programming Language II) — Object-oriented programming fundamentals.

Schedule

Topic Materials
Lab 1 — Linear Arrays & Circular Arrays

Implementation of 1D arrays, array rotation, element shifting, resizing, and circular array operations (forward and backward traversal, circular indexing arithmetic).
Lab 2 — Singly Linked Lists (Fundamentals)

Designing node structures, creating linked lists, node insertion at beginning/end/index, list traversal, and display operations.
Lab 3 — Singly Linked Lists (Advanced Operations)

Searching, element removal, reversing linked lists in-place, and detecting loops or cycles.
Lab 4 — Doubly Linked Lists & Dummy-Headed Circular Lists

Bidirectional node links, dummy head/tail advantages, circular doubly linked list insertion, deletion, and rotation.
Lab 5 — Stacks & Applications

Building stack Abstract Data Type (ADT) using arrays and linked lists (push, pop, peek), and practical applications to parentheses balancing checking.
Lab 6 — Queues & Circular Queues

Implementing queue ADT using circular arrays and linked lists (enqueue, dequeue), handling wrap-around arithmetic, and queue simulation problems.
Lab 7 — Recursion & Recursive Problem Solving

Recursive design patterns, base case formulation, call stack visualization, recursive array manipulation, and divide-and-conquer examples.
Lab 8 — Searching & Sorting Algorithms

Linear and binary search, comparison sorts (Bubble Sort, Selection Sort, Insertion Sort), and asymptotic complexity analysis.
Lab 9 — Key-Indexing & Hash Tables

Direct address tables, hash function design, collision resolution techniques (chaining vs open addressing), and hash table implementations.
Lab 10 — Trees & Binary Search Trees (BST)

Binary tree representations, recursive tree traversals (pre-order, in-order, post-order, level-order), BST insertion, search, and deletion.
Lab 11 — Priority Queues, Heaps & Graph Introduction

Binary heap representation (Min-Heap / Max-Heap), heapify up/down operations, priority queues, and introduction to graph representations (adjacency matrix and list).