Data Structures and Algorithms
24ERP304 · S3 · 4 credits
5 modules · Practice & PYQs ready
Have an exam tomorrow?
Get a high-yield attack plan focused on maximum marks per minute. Zero fluff, strict PYQ priority, active recall, and trap avoidance.
Strategy: High-yield concepts + PYQs + weak areas
Why:4 high-weightage exam questions · Formula-heavy module · Many definitions to memorize · Has worked numerical examples
Why:3 high-weightage exam questions · Formula-heavy module · Many definitions to memorize · Has worked numerical examples
Why:4 high-weightage exam questions · Many definitions to memorize · Has worked numerical examples
Why:3 high-weightage exam questions · Formula-heavy module · Many definitions to memorize · Has worked numerical examples
Why:3 high-weightage exam questions · Formula-heavy module · Many definitions to memorize · Has worked numerical examples · Foundation module
Browse by moduleexpand
M1Basic Concepts of Data Structures
Define Big-O, Big-Omega and Big-Theta notation with examples.
Differentiate Abstract Data Type and Data Structure.
Find the time complexity of a given code snippet (nested loops / recursion).
Differentiate best, worst and average case complexity with an example (e.g. linear search).
State and apply the Master Theorem on a given recurrence relation.
M2Arrays and Linked List
Convert a given infix expression to postfix using the stack-based algorithm (show the stack at each step).
Evaluate a given postfix expression using a stack (show step-by-step trace).
Differentiate array and linked list as data structures (memory, access time, insertion/deletion cost).
Write an algorithm to insert/delete a node at a given position in a singly linked list.
Differentiate singly, doubly and circular linked lists.
Explain how a circular queue overcomes the limitation of a linear queue.
M3Trees and Graphs
Write the algorithm for preorder/inorder/postorder traversal of a binary tree.
Construct a BST by inserting a given sequence of numbers, then show its inorder traversal.
Trace BFS and DFS on a given graph starting from a specified vertex.
Differentiate adjacency matrix and adjacency list representations of a graph.
Explain deletion in a BST for the three cases (leaf, one child, two children).
State real-world applications of graph traversal algorithms.
M4Sorting and Searching
Trace merge sort / quick sort / heap sort on a given array, showing every intermediate step.
Compare the time and space complexity of heap sort, merge sort and quick sort.
Write and analyze the binary search algorithm, deriving its time complexity.
Explain why quick sort's worst case is O(n²) and how a good pivot choice avoids it.
Explain the need for and working of external memory sorting.
Differentiate linear search and binary search, including their preconditions.
M5Hashing Table and Tries
Given a set of keys and a hash function, build the hash table resolving collisions using chaining.
Given a set of keys, build the hash table using linear probing / quadratic probing / double hashing.
Differentiate chaining and open addressing as collision-resolution techniques.
Explain load factor and its effect on hash table performance.
Explain the structure and use of a Trie with an example set of words.
Explain how hashing is used to find duplicates / compute set intersection efficiently.
Exam-focused notes are optional context — Continue Learning above works even without them.
What this module covers
≈ 10h of curated content available across this subject.