Home > Information Technology > Data Structures and Algorithms

CD3291 Data Structures and Algorithms Previous Year Question Papers - Anna University

Access Anna University Data Structures and Algorithms (CD3291) previous year question papers on LearnSkart for smarter semester exam preparation. This Anna University PYQ page offers year-wise Anna University exam papers aligned with Regulation 2021, so students can understand recurring questions, important units, and expected marking schemes. You can view every CD3291 Data Structures and Algorithms question paper online and use free PDF download options for focused revision before internal and semester exams.

2024

  • 2024 - CD3291-Data-Structures-and-Algorithms-Apr-May-2024-Question-Paper-Download.pdf
  • 2024 - CSE-ND-2024-CD 3291-Data Structures and Algorithms-46502443-20250604161745 (2).pdf

2023

  • 2023 - CD3291-Data-Structures-and-Algorithms-Apr-May-2023-Question-Paper-Download.pdf
  • 2023 - CD3291-Data-Structures-and-Algorithms-Nov-Dec-2023-Question-Paper-Download.pdf

2022

  • 2022 - CD3291-Data-Structures-and-Algorithms-Nov-Dec-2022-Question-Paper-Download.pdf

Important Questions - CD3291 Data Structures and Algorithms

UNIT I: Abstract Data Types & Algorithm Analysis

Part A (2 Marks)

  • What is an Abstract Data Type (ADT)?
  • Differentiate between Shallow and Deep copying in Python.
  • Define Recursion and state its importance.
  • List the three types of Asymptotic Notations.

Part B (13/16 Marks)

  • Asymptotic Notations: Explain Big-Oh, Omega, and Theta notations with suitable examples.
  • Object-Oriented Programming: Discuss the concepts of Inheritance (Single, Multiple, Hybrid) with Python example programs.
  • Algorithm Analysis: Explain the Divide and Conquer technique and solve the Towers of Hanoi problem using recursion.

UNIT II: Linear Structures

Part A (2 Marks)

  • What are the advantages of Linked Lists over Arrays?
  • Define DEQUE (Double Ended Queue).
  • List any four applications of a Stack.

Part B (13/16 Marks)

  • Linked Lists: Detailed explanation and implementation of Singly, Doubly, and Circular Linked Lists.
  • Stack & Queue ADT: Write the array-based and linked list-based implementations for Stack and Queue operations.
  • Applications: Discuss the role of stacks in expression evaluation (Infix to Postfix conversion) and polynomial manipulation.

UNIT III: Sorting and Searching

Part A (2 Marks)

  • Differentiate between Internal and External sorting.
  • What is Hashing and why is it used?
  • Compare the time complexities of Linear and Binary search.

Part B (13/16 Marks)

  • Sorting Algorithms: Detailed study and Python implementation of Quick Sort, Merge Sort, and Insertion Sort.
  • Hashing Techniques: Explain various hash functions and collision handling techniques (Linear Probing, Quadratic Probing, and Separate Chaining).
  • Rehashing: When and why do we perform rehashing? Illustrate with an example.

UNIT IV: Tree Structures

Part A (2 Marks)

  • Define a Binary Search Tree (BST).
  • What is the Balance Factor in an AVL tree?
  • Construct an Expression Tree for the expression A+(B-C)*D.

Part B (13/16 Marks)

  • Tree Traversals: Explain In-order, Pre-order, and Post-order traversal techniques with examples.
  • AVL Trees: Explain AVL rotations (LL, RR, LR, RL) with suitable examples to maintain balance during insertion.
  • Binary Search Tree: Write the procedures for insertion and deletion of nodes in a BST.
  • Heaps: Explain the insert and delete operations of a Min/Max Heap and the Heap Sort algorithm.

UNIT V: Graph Structures

Part A (2 Marks)

  • Define Topological Sort.
  • What is the difference between BFS and DFS?
  • Define Minimum Spanning Tree (MST).

Part B (13/16 Marks)

  • Graph Traversals: Detailed explanation of Breadth-First Search (BFS) and Depth-First Search (DFS).
  • Shortest Path: State and explain Dijkstra's algorithm with a numerical example.
  • Minimum Spanning Tree: Compare Prim's and Kruskal's algorithms for finding the MST of a graph.

Most Repeated / High-Weight Questions

Asymptotic analysis and complexity calculations, linked list operations and applications, sorting algorithms with implementations, tree traversals and AVL rotations, graph traversals and shortest path algorithms.

Additional Resources

View Syllabus View Notes

How to Use These Question Papers

Frequently Asked Questions about CD3291 Data Structures and Algorithms

Which topics are most tested in CD3291 exams?

Asymptotic complexity analysis (Unit I), linked list and stack/queue implementations (Unit II), sorting algorithms with complexity comparisons (Unit III), tree traversals and AVL rotations (Unit IV), and graph algorithms like BFS/DFS and Dijkstra (Unit V) are equally weighted. Focus on implementation and tracing algorithms manually.

How should I approach complexity analysis in CD3291?

Understand Big-Oh (upper bound, worst case), Omega (lower bound, best case), Theta (tight bound, average case). Practice complexity calculations for loops, recursive functions, and nested structures. Master recurrence relation solving. These complexity problems appear with 13-16 marks regularly.

What is the best strategy for linked list and stack/queue questions?

Write complete Python implementations for singly, doubly, and circular linked lists with insert/delete/search operations. Implement stacks and queues using both arrays and linked lists. Practice expression evaluation (infix to postfix conversion) and polynomial operations using linked lists.

How can I master sorting algorithms in CD3291?

Understand Quick Sort (average O(n log n), partitioning), Merge Sort (guaranteed O(n log n), merging), Insertion Sort (O(n²), simple). Practice manual tracing with sample arrays. Compare time/space complexities. Know when each algorithm is optimal. Implement in Python with step-by-step execution traces.

What should I prioritize in tree structure questions?

Master tree traversal techniques: In-order (left-root-right), Pre-order (root-left-right), Post-order (left-right-root). Practice with manual tracing. Understand AVL tree balance factor calculation. Master LL, RR, LR, RL rotations with example trees. These tree problems appear with 13-16 marks combining traversals and rotations.

How should I approach graph algorithm questions in CD3291?

Master graph representation (adjacency matrix, adjacency list). Understand BFS (queue-based, level-order) and DFS (stack-based, depth-first) traversals. Trace Dijkstra's algorithm with step-by-step distance calculations. Compare Prim's (MST starting from node) and Kruskal's (MST using edge sorting) algorithms.