Data Structures and Algorithms in C (DSA)

📘 Chapter 44: Building Mini Projects Using DSA (Menu-driven)

You've mastered the theoretical foundations of Data Structures and Algorithms, tackled interview problems, and recognized competitive coding patterns. Now, it's time to bridge the gap between theory and practice. This chapter focuses on applying your DSA knowledge to build small, functional, **menu-driven mini-projects**.

Building these projects will:

• Solidify your understanding of how different DSAs are used in real-world scenarios.
• Improve your coding proficiency and problem-solving skills in a practical context.
• Give you tangible projects to showcase your abilities.
• Enhance your ability to design and structure larger programs.

⚙️ Project 1: Simple Contact Management System

A basic system to store, retrieve, update, and delete contact information.

• Core Functionality:
  • Add new contact (Name, Phone, Email).
  • Search contact by Name or Phone.
  • Update contact details.
  • Delete contact.
  • Display all contacts.
• DSA Concepts Applied:
  • Hash Map (or Dictionary/`unordered_map`): Ideal for fast lookups (search by name/phone) and storage. Keys could be contact names (unique), values could be `Contact` objects.
  • Linked List / Dynamic Array (`std::vector`): To store contacts if a hash map is not used for primary storage, or to manage contacts with non-unique names/phones. Iterating through all contacts for display.
  • String Manipulation: For parsing input, searching.
• Menu Structure:

  --- Contact Management System ---
  1. Add New Contact
  2. Search Contact
  3. Update Contact
  4. Delete Contact
  5. Display All Contacts
  6. Exit
  Enter your choice:
        

• Implementation Notes:
  • Define a `Contact` struct/class to hold name, phone, email.
  • Use a global `std::unordered_map` where keys are names for quick access, or `std::vector` if you prefer linear scan for simplicity initially.
  • Handle user input for menu choices and contact details.
  • Implement error handling for invalid inputs or non-existent contacts.

🗺️ Project 2: Simple Pathfinding Visualizer (Grid-based)

A text-based (or simple GUI) program to find the shortest path between two points on a grid, avoiding obstacles.

• Core Functionality:
  • Define a grid (e.g., 10x10) with start, end, and obstacle cells.
  • Find the shortest path from start to end.
  • Display the grid and the found path.
• DSA Concepts Applied:
  • BFS (Breadth-First Search): The go-to algorithm for finding the shortest path in an unweighted graph (which a grid can be modeled as).
  • Queue: Essential for BFS to manage nodes to visit.
  • 2D Array / Matrix: To represent the grid, marking cells as empty, obstacle, start, end, or part of the path.
  • Visited Array/Set: To keep track of visited cells to prevent cycles and redundant computations.
• Menu Structure:

  --- Grid Pathfinding ---
  1. Set Grid Dimensions
  2. Set Start/End Points
  3. Add Obstacles
  4. Find Shortest Path
  5. Display Grid
  6. Exit
  Enter your choice:
        

• Implementation Notes:
  • Represent the grid as `char grid[ROWS][COLS]` or `std::vector>`.
  • Implement a `Node` struct/class to store `(row, col, distance, parent_node_coords)` for path reconstruction.
  • BFS: Start from the source, add neighbors to queue, update distances, mark visited.
  • Path Reconstruction: Trace back from the destination using parent pointers.
  • Display: Print the grid with different characters for path, obstacles, start, end.

📚 Project 3: Simple Library Management System (Books)

Manage a collection of books, supporting adding, searching, and borrowing/returning.

• Core Functionality:
  • Add new book (Title, Author, ISBN, Quantity).
  • Search book by Title, Author, or ISBN.
  • Borrow/Return book (update quantity).
  • Display all books.
  • (Optional) Display available books.
• DSA Concepts Applied:
  • Hash Map (`unordered_map`): Excellent for quick lookups by ISBN (unique identifier). Can also use for Title/Author, but might need to handle multiple books by same author/title (e.g., `unordered_map>`).
  • Binary Search Tree (or `std::map`): If you want to store books sorted by title or author for efficient range queries or sorted display.
  • Array/Vector: To store all books, perhaps for iterating and displaying.
  • Struct/Class: `Book` struct/class to hold book details.
• Menu Structure:

  --- Library Management System ---
  1. Add Book
  2. Search Book
  3. Borrow Book
  4. Return Book
  5. Display All Books
  6. Exit
  Enter your choice:
        

• Implementation Notes:
  • Define a `Book` struct/class with `title`, `author`, `isbn`, `total_quantity`, `available_quantity`.
  • Consider using `std::map` for ISBN-based lookup if you want sorted keys, or `std::unordered_map` for faster average case.
  • For searching by title/author, you might need to iterate through your collection if not using multiple maps.
  • Ensure quantity updates are handled correctly for borrow/return.

💡 General Tips for Building Menu-driven Projects

• Modular Design: Break your code into functions (e.g., `addContact()`, `searchContact()`, `displayMenu()`).
• Clear User Interface: Provide clear prompts for input and informative output messages.
• Input Validation: Always validate user input (e.g., ensure numeric input is actually a number, choices are within range).
• Loop for Menu: Use a `while` loop to keep the menu running until the user chooses to exit.
• `switch` or `if-else if`: Use a `switch` statement (or `if-else if` ladder) to handle different menu choices.
• Error Handling: Gracefully handle cases like "contact not found," "book out of stock," etc.
• Persistence (Optional but Recommended): For a more robust project, consider saving data to a file (text file, CSV, JSON) so it persists between program runs. This will introduce file I/O.

📌 Why Build These Projects? (UdaanPath Context)

These mini-projects, though simple, mirror components found in larger systems:

• Contact Management: Similar to managing user profiles, instructor details, or administrative contacts within UdaanPath's backend. Fast search is critical.
• Pathfinding: Could be adapted for recommending optimal learning paths through a course curriculum (e.g., shortest path through prerequisites), or even internal routing for data packets in a distributed system.
• Library Management: Directly applicable to managing UdaanPath's course catalog, resource library, or even student enrollments. Efficient searching and updating of course availability are key.

✅ Summary: From Theory to Application

• Building mini-projects helps solidify DSA knowledge and develops practical coding skills.
• Menu-driven interfaces provide a structured way to interact with your DSA implementations.
• Key DSAs like Hash Maps, Linked Lists, Arrays, BFS, and Trees are directly applicable.
• Focus on modularity, clear UI, input validation, and error handling.
• These projects are simplified versions of real-world system components, offering valuable hands-on experience.

📤 Coming Next: Final Quiz + Problem Sheet (100+ questions)

You've come a long way! Our penultimate chapter is dedicated to a comprehensive assessment of your DSA journey. We'll provide a Final Quiz and a Problem Sheet with over 100 questions, covering all topics from basic data structures to advanced algorithms and competitive patterns, allowing you to thoroughly test your knowledge and identify areas for further practice.