Skip to content

CS 103: Data Structures & Algorithm Design
Course Code CS 103
Course Name Data Structures & Algorithm Design
Department Computer Science
Semester Offered Even (Term 2 - India)
Tuition Hours 30 hours
Course Level Foundational to Intermediate
Pre-requisite CS 101: Introduction to Computational Thinking
Co-requisite -
Course Objective Writing code that works is easy. Writing code that scales, survives constraints, and performs under pressure is a different game.

This course introduces students to the core data structures and algorithmic techniques that power efficient systems. The focus is not on passing coding interviews, but on understanding why some solutions break at scale while others hold up.

Students will learn how to organize data, design efficient procedures, and reason about time and space complexity. These ideas become critical when building AI systems that operate on real-world data with real constraints, especially in environments where compute, memory, and infrastructure are limited.

By the end of the course, students will be able to design systems that are not just correct, but efficient enough to be deployed in production.
Course Philosophy This course emphasizes
  • Efficiency as a design constraint, not an afterthought
  • Understanding trade-offs over memorizing patterns
  • Building systems that work under real-world limits
Students will learn to think about performance from the start. Every data structure and algorithm is taught in the context of when it should be used and when it will fail.
Course Learning Outcomes Upon successful completion of this course, students will be able to:
  • Analyze time and space complexity of algorithms using clear reasoning.
  • Choose appropriate data structures for different problem settings.
  • Implement core data structures such as arrays, linked lists, stacks, queues, trees, graphs, and hash tables.
  • Design efficient algorithms for searching, sorting, and optimization problems.
  • Handle large-scale data problems with performance constraints in mind.
  • Recognize trade-offs between speed, memory, and simplicity in system design.
  • Apply algorithmic thinking to real-world systems, especially in AI pipelines and backend systems.
Course Author Sagar Udasi
MSc Statistics and Data Science with Computational Finance from The University of Edinburgh.
Contact: sagar.l.udasi@gmail.com
Course Organiser TBD
Details will be updated before course commencement.
No. Lecture Title Concepts Covered Lecture Objective
01 Why Your Code Breaks At Scale Limits of naive solutions, introduction to complexity Show why efficiency matters when systems meet real users and data.
02 Time Is Not Free Time complexity, Big O intuition Teach students to measure performance and predict scalability.
03 Memory Is A Constraint Too Space complexity, trade-offs Build awareness of memory usage in real systems.
04 Arrays: The Simplest Yet Most Powerful Tool Arrays, indexing, operations Foundation for most systems and data processing tasks.
05 When Arrays Are Not Enough Linked lists, dynamic memory Introduce flexibility vs performance trade-offs.
06 Stacks & Queues: Controlling Flow LIFO, FIFO, real-world use cases Apply structures to system design and workflows.
07 Hash Tables Feel Like Magic Hashing, collisions, dictionaries Teach constant-time operations and their practical limits.
08 Trees: Organizing Hierarchy Binary trees, traversal Essential for structured data and decision systems.
09 Search Trees That Stay Fast BST, balancing intuition Maintain performance in dynamic datasets.
10 Heaps & Priority Queues Heaps, scheduling problems Useful for optimization and real-time systems.
11 Sorting Isn’t Just Sorting Sorting algorithms, trade-offs Teach when different sorting methods matter.
12 Graphs: Modeling The Real World Graph representation, traversal Represent networks, relationships, and dependencies.
13 Finding Paths In Chaos BFS, DFS, shortest paths Apply graph algorithms to real systems like routing and recommendations.
14 Greedy Works… Until It Doesn’t Greedy algorithms, limitations Teach when simple strategies fail.
15 Breaking Problems Into Subproblems Dynamic programming intuition Solve complex optimization problems efficiently.
16 Recursion: Thinking In Reverse Recursive thinking, stack behavior Build deeper understanding of problem decomposition.
17 Designing Algorithms From Scratch Problem-solving strategies Move from implementation to design thinking.
18 Systems Under Constraints Real-world constraints, optimization Apply learning to limited compute environments.
19 Case Study: Scaling An AI Pipeline Applying DS&A to ML systems Directly connect to Term 2 enterprise AI projects.
20 Demo Day: Efficient Or It Fails Presentations, performance review Students showcase systems that must meet efficiency benchmarks.
Component Weightage
Weekly Problem Sets (6 total) 30%
Algorithm Design Assignment 20%
Final Project: Scalable System Component 30%
Viva + Code Efficiency Review 20%
Type Resource Provider
Lecture Algorithms, Part I & II Princeton (Robert Sedgewick)
Lecture MIT 6.006 Introduction to Algorithms MIT OCW
Reading Grokking Algorithms Aditya Bhargava
Reading Introduction to Algorithms Cormen, Leiserson, Rivest, Stein
Practice LeetCode LeetCode
Practice Codeforces Codeforces