Advanced Algorithm Lab (MTCS152) – Complete Practical Syllabus, Experiments & Topics

November 18, 2026
MTCS152: Advanced Algorithm Lab

 

The Department of Computer Science & Engineering offers Advanced Algorithm Lab (MTCS152) as part of the academic curriculum. This practical subject focuses on implementing advanced algorithms and problem-solving techniques using Java programming.

Through hands-on laboratory experiments, students gain practical knowledge of searching and sorting algorithms, hashing, graph algorithms, tree traversal, shortest path algorithms, minimum spanning trees, and pattern matching techniques.

Subject Details

  • Department: Computer Science & Engineering
  • Subject Name: Advanced Algorithm Lab
  • Subject Code: MTCS152
  • Semester: I
  • Faculty: Mr. Rahul Dubey

Complete Practical Syllabus of Advanced Algorithm Lab (MTCS152)

The practical syllabus consists of nine experiments covering different areas of algorithm design and implementation. Each experiment helps students understand the working principles of algorithms through Java programming.

Practical 1: Implementation of Searching Algorithms

This practical focuses on implementing searching methods using both recursive and non-recursive functions in Java.

Topics Covered:

  • Linear Search
  • Binary Search
  • Recursive Functions
  • Non-Recursive Functions

Students learn how to search for specific elements in a dataset using different searching techniques.

Practical 2: Implementation of Dictionary (ADT) Using Hashing

This practical introduces the implementation of a Dictionary Abstract Data Type (ADT) using hashing techniques.

Topics Covered:

  • Dictionary Abstract Data Type (ADT)
  • Hashing
  • Implementation of Dictionary Functions

Students learn how hashing techniques are used to organize and retrieve information through dictionary operations.

Practical 3: Implementation of Dijkstra’s Algorithm

This practical focuses on implementing Dijkstra’s algorithm to find the single-source shortest path in a graph.

Topics Covered:

  • Dijkstra’s Algorithm
  • Single Source Shortest Path
  • Graph-Based Problem Solving

Students understand how to calculate the shortest paths from a given source vertex to other vertices in a graph.

Practical 4: Implementation of Binary Tree Traversal

This practical covers different binary tree traversal techniques using recursive and non-recursive functions.

Topics Covered:

  • Preorder Traversal
  • Inorder Traversal
  • Postorder Traversal
  • Recursive Functions
  • Non-Recursive Functions

Students learn how to traverse a binary tree using different traversal methods and implement them through Java programs.

Practical 5: Implementation of BFS and DFS Algorithms

This practical introduces graph traversal techniques used to explore vertices and understand graph structures.

Topics Covered:

  • Breadth First Search (BFS)
  • Depth First Search (DFS)
  • Graph Traversal

Students learn to implement BFS and DFS algorithms for a given graph using Java programming.

Practical 6: Implementation of Sorting Algorithms

This practical focuses on implementing different sorting techniques using Java programming.

Topics Covered:

  1. Bubble Sort
  2. Insertion Sort
  3. Quick Sort
  4. Merge Sort
  5. Heap Sort
  6. Radix Sort
  7. Binary Tree Sort

Students learn how different sorting algorithms arrange data and understand their implementation through practical programming exercises.

Practical 7: Implementation of B-Tree Operations

This practical focuses on implementing important operations performed on B-Tree data structures.

Topics Covered:

  • Insertion into a B-Tree
  • Searching in a B-Tree

Students understand how B-Trees organize information and perform insertion and searching operations.

Practical 8: Implementation of Kruskal’s Algorithm

This practical introduces Kruskal’s algorithm, which is used to generate a minimum cost spanning tree.

Topics Covered:

  • Kruskal’s Algorithm
  • Minimum Cost Spanning Tree
  • Graph-Based Optimization

Students learn how to implement Kruskal’s algorithm using Java programming to generate a minimum cost spanning tree.

Practical 9: Implementation of KMP Algorithm

This practical focuses on string pattern matching using the Knuth-Morris-Pratt (KMP) algorithm.

Topics Covered:

  • Knuth-Morris-Pratt (KMP) Algorithm
  • Pattern Matching
  • String Searching

Students learn how to implement the KMP algorithm to identify a specific pattern within a given text.

Importance of Advanced Algorithm Lab

Advanced Algorithm Lab helps students develop practical programming skills and understand how different algorithms are implemented to solve computational problems.

Key Learning Outcomes:

  • Understanding recursive and non-recursive programming techniques.
  • Developing Java programming skills.
  • Implementing searching and sorting algorithms.
  • Understanding hashing and dictionary operations.
  • Learning graph traversal techniques.
  • Implementing shortest path algorithms.
  • Understanding binary tree and B-Tree operations.
  • Learning minimum spanning tree generation.
  • Implementing string pattern matching algorithms.

Skills Students Can Develop

After completing the practical experiments, students can strengthen their knowledge of:

  • Java Programming
  • Data Structures and Algorithms
  • Searching and Sorting Techniques
  • Hashing and Dictionary ADT
  • Graph Algorithms
  • Binary Tree Traversal
  • B-Tree Operations
  • Dijkstra’s Algorithm
  • Kruskal’s Algorithm
  • KMP Pattern Matching

Download Complete Advanced Algorithm Lab Syllabus PDF

Students can download the complete Advanced Algorithm Lab (MTCS152) syllabus PDF to access all nine practical experiments and their prescribed programming requirements.

The syllabus PDF is attached here for easy access, laboratory preparation, practical examinations, and future reference.

Conclusion

Advanced Algorithm Lab (MTCS152) provides students with practical experience in implementing important algorithms and data structures using Java programming. The nine experiments cover searching, sorting, hashing, graph traversal, shortest path calculations, tree operations, minimum spanning trees, and pattern matching.

By completing these practical exercises, students can improve their programming abilities, strengthen logical thinking, and develop problem-solving skills that are essential for advanced computer science applications.