Table of contents:

Library management system

1. Introduction

2. Abstract

3. Purpose

4. Scope of the project

5. Project selection

6. .concepts of dsa use in this project

1. Stacks
2. Queue
3. Linked list
 Topic

Library management system

 Library Management System

Abstract:

The Library Management System (LMS) is designed to efficiently organize and

streamline various tasks and processes within a library. Serving as the core
database for library management, the system provides comprehensive information
about available books, their current status, and facilitates user registration. Users,
including both staff and patrons, can interact with the system to access and manage
library resources seamlessly.

Upon registration, patrons gain the ability to browse the library's catalog, check the
availability of books, and request loans for specific titles. The system empowers
library administrators to oversee and control the entire library ecosystem through a
centralized online interface. Essential features such as book borrowing, staff
management, and other library services are integrated into this project.

Administrators can update the system with information about available books and
manage staff efficiently. Patrons, on the other hand, can explore the library's
collection, reserve books, and access other library services remotely. The LMS
enhances the overall management of library operations, providing a user-friendly
platform for patrons to interact with the library's resources from the comfort of
their homes.

The administrator holds the authority to approve or reject book reservation

requests, ensuring optimal control over the library's resources. With the Library
Management System, both library users and administrators can seamlessly engage
with library activities, thereby enhancing the efficiency and accessibility of library
services.
Introduction:

The Library Management System (LMS) represents a cutting-edge software

solution designed to revolutionize and streamline the operations of libraries. With a
focus on implementing advanced data structures and algorithms, this project aims
to create a robust system that enhances efficiency, scalability, and the rapid
retrieval of accurate information. By providing a sophisticated yet user-friendly
interface, the system caters to the needs of both library patrons and administrators,
facilitating seamless management of tasks such as book reservations, user
information, inventory tracking, and other essential library services.

Similar to a hotel reservation system, the Library Management System enables

users to navigate the library's catalog, check book availability in real-time, and
make reservations conveniently through an online platform. Users can input their
desired check-out dates and browse available books, with the entire booking and
reservation process seamlessly conducted on the website. Furthermore, the system
incorporates features to send notifications, ensuring that users receive timely
confirmation of their book reservations.

In essence, the Library Management System serves as a comprehensive tool to

elevate the efficiency of library operations, offering patrons the convenience of
accessing library resources remotely and administrators a powerful platform to
manage the library's diverse functions with ease. This project sets out to create a
dynamic and responsive system that adapts to the evolving needs of modern
libraries, fostering a more engaging and accessible library experience for users.

Purpose:
The Library Management System (LMS) Software Requirement Specification
(SRS) serves as a comprehensive document outlining the specific needs and
functionalities required for the development of the LMS. This document is pivotal
in providing a detailed understanding of the expected features and operations of the
proposed system. The primary goal is to ensure that the subsequent phases of the
project, including system design, development, and testing, align with the
envisioned requirements.

By offering a clear and concise overview of the system's specifications, the SRS
lays the foundation for the entire project. It acts as a guide for the development
team, enabling them to comprehend the intricacies of the LMS and build software
that meets the end users' expectations. The SRS is a crucial tool for collaboration
between the development team and the stakeholders involved in the library,
ensuring a shared understanding of the system's requirements.

The Library Management System SRS serves a dual purpose, benefiting both the
development team and the end users. For the development team, it provides a
blueprint for building the LMS, guiding them through the various stages of
development. Simultaneously, the end users, which include library staff and
patrons, can utilize the SRS as a benchmark to assess whether the proposed system
aligns with their specific needs and expectations.

This document establishes a framework for ongoing communication and

collaboration, allowing for a dynamic and iterative development process. Any
discrepancies or mismatches between the system's functionality and user
expectations can be identified and addressed through revisions to the SRS,
ensuring that the final Library Management System fulfills the requirements of all
stakeholders involved.
Scope of the Project:

The proposed Library Management System (LMS) aims to revolutionize the day-
to-day operations of the library, providing an automated solution for efficient
management and accessibility of library resources. The system will cater to the
needs of library patrons and staff, streamlining various services and enhancing
overall functionality.

Key Components:

Catalog Management:

The LMS will include a robust catalog management system to organize and
categorize the library's collection, making it easy for users to browse and locate
books.

Reservation System:

A reservation system will be implemented to track book availability, manage

reservations, and streamline the borrowing process for patrons. This will ensure
optimal utilization of library resources.

User Management:

The system will maintain a comprehensive database of user information,

facilitating efficient management of library memberships, tracking borrowing
history, and managing user accounts.

Inventory Control System:

An inventory control system will be integrated to keep track of all library
materials, including books, multimedia, and other resources. This will aid in
inventory management

Access Control:

The LMS will implement access control features to define different user roles,
including administrators, librarians, and patrons. Each role will have specific
permissions, ensuring secure and restricted access to sensitive information
stocking.

Ease of Use:

The system will be designed with a user-friendly interface, ensuring ease of use for
both library staff and patrons. Intuitive navigation and clear functionalities will
contribute to a positive user experience.

Error Recovery:

The LMS will incorporate error recovery mechanisms to handle unexpected

situations gracefully, ensuring system stability and minimizing disruptions in
service.

Information Retrieval Efficiency:

The primary focus of the project is to enhance information retrieval efficiency.

Users will be able to quickly and accurately access information about book
availability, reservations, and other library services.

Overall, the Library Management System aims to address challenges associated

with manual library management, offering a reliable, secure, and efficient solution.
The project's scope encompasses the development of a user-friendly and
technologically advanced system that aligns with the needs of both library staff and
patrons, contributing to an improved library experience for all stakeholders.

Project Selection:

The Library Management System (LMS) project has been selected in response to
the critical need for a centralized and technologically advanced solution in the
realm of library services. The challenges faced by libraries in efficiently managing
resources, facilitating user interactions, and adapting to the evolving demands of
modern users have prompted the selection of this project. The LMS project
addresses several key aspects of library management, encompassing catalog
organization, user interactions, inventory control, and overall operational
efficiency.

Key Considerations:

Resource Organization:

With a rapidly growing collection of books, multimedia, and other resources,

libraries face the challenge of efficiently organizing and categorizing their
catalogs. The LMS project aims to provide a centralized and automated system for
catalog management, ensuring that users can easily navigate and access the diverse
range of materials available.

User Experience:

Recognizing the changing expectations of library patrons, the LMS project

focuses on enhancing the user experience. The system will incorporate features
such as online catalog access, reservation capabilities, and personalized user
accounts to meet the evolving needs of modern library users.
Efficient Operations:

Manual library management processes often result in inefficiencies, leading to

challenges in tracking inventory, managing reservations, and providing timely
services. The LMS project intends to streamline these operations by automating
various tasks, including book reservations, inventory control, and user
management.

Adaptability to Technological Trends:

In the face of technological advancements, libraries need to adapt to modern

trends to stay relevant. The LMS project aims to integrate cutting-edge
technologies to enhance the overall functionality of the library, providing a
platform that aligns with contemporary expectations.

Resource Utilization:

Libraries, like hotels, are repositories of valuable resources. The LMS project aims
to optimize resource utilization by implementing efficient cataloging systems,
enabling effective inventory management, and enhancing the accessibility of
resources for patrons.

Operational Efficiency:

By automating activities such as book reservations, check-outs, and user

interactions, the LMS project aims to improve operational efficiency.

The selection of the Library Management System project is driven by the

overarching goal of modernizing library operations, providing a user-friendly
interface, and adapting to the evolving landscape of library services. This project is
envisioned as a transformative solution that will contribute to the efficiency,
accessibility, and relevance of the library in the digital age.
 7. Concepts of dsa use in this project:

Stacks:

What sre stack data structures:

A stack is a linear data structure in which the insertion of a new

element and removal of an existing element takes place at the same
end represented as the top of the stack.

To implement the stack, it is required to maintain the pointer to the top of the
stack, which is the last element to be inserted because we can access the
elements only on the top of the stack.

LIFO( Last In First Out ):

This strategy states that the element that is inserted last will come out
first. You can take a pile of plates kept on top of each other as a real-
life example. The plate which we put last is on the top and since we
remove the plate that is at the top, we can say that the plate that was
put last comes out first.

Basic Operations on Stack

In order to make manipulations in a stack, there are certain operations provided to
us.

• push() to insert an element into the stack

• pop() to remove an element from the stack
• top() Returns the top element of the stack.
• isEmpty() returns true if stack is empty else false.
• size() returns the size of stack.
 Stack

Push:
Adds an item to the stack. If the stack is full, then it is said to be an Overflow
condition.

Algorithm for push:

begin

if stack is full

return
endif

else

increment top

stack[top] assign value

end else

end procedure

Pop:
Removes an item from the stack. The items are popped in the reversed order in
which they are pushed. If the stack is empty, then it is said to be
an Underflow condition.

Algorithm for pop:

begin

if stack is empty

return

endif

else

store value of stack[top]

decrement top

return value

end else

end procedure

Top:
Returns the top element of the stack.
 Algorithm for Top:

begin

return stack[top]

end procedure

isEmpty:
Returns true if the stack is empty, else false.

Algorithm for isEmpty:

begin

if top < 1

return true

else

return false

end procedure

Understanding stack practically:

There are many real-life examples of a stack. Consider the simple

example of plates stacked over one another in a canteen. The plate
which is at the top is the first one to be removed, i.e. the plate which
has been placed at the bottommost position remains in the stack for
the longest period of time. So, it can be simply seen to follow the
LIFO/FILO order.

Complexity Analysis:
• Time Complexity
 Operations Complexity

push() O(1)

pop() O(1)

isEmpty() O(1)

size() O(1)

Types of Stacks:
• Fixed Size Stack: As the name suggests, a fixed size stack has a fixed size and
cannot grow or shrink dynamically. If the stack is full and an attempt is made to
add an element to it, an overflow error occurs. If the stack is empty and an
attempt is made to remove an element from it, an underflow error occurs.
• Dynamic Size Stack: A dynamic size stack can grow or shrink dynamically.
When the stack is full, it automatically increases its size to accommodate the
new element, and when the stack is empty, it decreases its size. This type of
stack is implemented using a linked list, as it allows for easy resizing of the
stack.
In addition to these two main types, there are several other variations of Stacks,
including:

1. Infix to Postfix Stack: This type of stack is used to convert infix expressions

to postfix expressions.
2. Expression Evaluation Stack: This type of stack is used to evaluate postfix

expressions.
3. Recursion Stack: This type of stack is used to keep track of function calls in a

computer program and to return control to the correct function when a function
returns.
4. Memory Management Stack: This type of stack is used to store the values of

the program counter and the values of the registers in a computer program,
allowing the program to return to the previous state when a function returns.
5. Balanced Parenthesis Stack: This type of stack is used to check the balance of

parentheses in an expression.
6. Undo-Redo Stack: This type of stack is used in computer programs to allow

users to undo and redo actions.

Applications of the stack:
• Infix to Postfix /Prefix conversion
• Redo-undo features at many places like editors, photoshop.
• Forward and backward features in web browsers
• Used in many algorithms like Tower of Hanoi, tree traversals, stock span
problems, and histogram problems.
• Backtracking is one of the algorithm designing techniques. Some examples of
backtracking are the Knight-Tour problem, N-Queen problem, find your way
through a maze, and game-like chess or checkers in all these problems we dive
into someway if that way is not efficient we come back to the previous state
and go into some another path. To get back from a current state we need to
store the previous state for that purpose we need a stack.
• In Graph Algorithms like Topological Sorting and Strongly Connected
Components
• In Memory management, any modern computer uses a stack as the primary
management for a running purpose. Each program that is running in a computer
system has its own memory allocations
• String reversal is also another application of stack. Here one by one each
character gets inserted into the stack. So the first character of the string is on
the bottom of the stack and the last element of a string is on the top of the stack.
 After Performing the pop operations on the stack we get a string in reverse
order.
• Stack also helps in implementing function call in computers. The last called
function is always completed first.
• Stacks are also used to implement the undo/redo operation in text editor.
Implementation of Stack:
A stack can be implemented using an array or a linked list. In an array-based
implementation, the push operation is implemented by incrementing the index of
the top element and storing the new element at that index. The pop operation is
implemented by decrementing the index of the top element and returning the
value stored at that index. In a linked list-based implementation, the push
operation is implemented by creating a new node with the new element and
setting the next pointer of the current top node to the new node. The pop
operation is implemented by setting the next pointer of the current top node to the
next node and returning the value of the current top node.

Stacks are commonly used in computer science for a variety of applications,

including the evaluation of expressions, function calls, and memory management.
In the evaluation of expressions, a stack can be used to store operands and
operators as they are processed. In function calls, a stack can be used to keep
track of the order in which functions are called and to return control to the correct
function when a function returns. In memory management, a stack can be used to
store the values of the program counter and the values of the registers in a
computer program, allowing the program to return to the previous state when a
function returns.

In conclusion, a Stack is a linear data structure that operates on the LIFO

principle and can be implemented using an array or a linked list. The basic
 operations that can be performed on a stack include push, pop, and peek, and
stacks are commonly used in computer science for a variety of applications,
including the evaluation of expressions, function calls, and memory
management.There are two ways to implement a stack –

• Using array
• Using linked list

Implementing Stack using Arrays:

C++ program to implement basic stack

operations */

#include <iostream>

using namespace std;

#define MAX 1000

class Stack {
int top;

public:
int a[MAX]; // Maximum size of Stack

Stack() { top = -1; }

bool push(int x);
int pop();
 int peek();
bool isEmpty();
};

bool Stack::push(int x)
{
if (top >= (MAX - 1)) {
cout << "Stack Overflow";
return false;
}
else {
a[++top] = x;
cout << x << " pushed into stack\n";
return true;
}
}

int Stack::pop()
{
if (top < 0) {
cout << "Stack Underflow";
return 0;
}
else {
int x = a[top--];
return x;
}
}
int Stack::peek()
{
if (top < 0) {
cout << "Stack is Empty";
return 0;
}
else {
int x = a[top];
return x;
}
}

bool Stack::isEmpty()
{
return (top < 0);
}

// Driver program to test above functions

int main()
{
class Stack s;
s.push(10);
s.push(20);
s.push(30);
cout << s.pop() << " Popped from stack\n";
 //print top element of stack after popping
cout << "Top element is : " << s.peek() << endl;

//print all elements in stack :

cout <<"Elements present in stack : ";
while(!s.isEmpty())
{
// print top element in stack
cout << s.peek() <<" ";
// remove top element in stack
s.pop();
}

return 0;
}
Advantages of array implementation:
• Easy to implement.
• Memory is saved as pointers are not involved.
Disadvantages of array implementation:
• It is not dynamic i.e., it doesn’t grow and shrink depending on needs at
runtime. [But in case of dynamic sized arrays like vector in C++, list in Python,
ArrayList in Java, stacks can grow and shrink with array implementation as well].
• The total size of the stack must be defined beforehand.
Implementing Stack using Linked List:

// C++ program for linked list implementation of stack

#include <iostream>
using namespace std;

// A structure to represent a stack

class StackNode {
public:
int data;
StackNode* next;
};

StackNode* newNode(int data)

{
StackNode* stackNode = new StackNode();
stackNode->data = data;
stackNode->next = NULL;
return stackNode;
}

int isEmpty(StackNode* root)

{
return !root;
}

void push(StackNode** root, int data)

{
StackNode* stackNode = newNode(data);
stackNode->next = *root;
 *root = stackNode;
cout << data << " pushed to stack\n";
}

int pop(StackNode** root)

{
if (isEmpty(*root))
return INT_MIN;
StackNode* temp = *root;
*root = (*root)->next;
int popped = temp->data;
free(temp);

return popped;
}

int peek(StackNode* root)

{
if (isEmpty(root))
return INT_MIN;
return root->data;
}

// Driver code
int main()
{
StackNode* root = NULL;
 push(&root, 10);
push(&root, 20);
push(&root, 30);

cout << pop(&root) << " popped from stack\n";

cout << "Top element is " << peek(root) << endl;

cout <<"Elements present in stack : ";

//print all elements in stack :
while(!isEmpty(root))
{
// print top element in stack
cout << peek(root) <<" ";
// remove top element in stack
pop(&root);
}

return 0;
}
Advantages of Linked List implementation:
• The linked list implementation of a stack can grow and shrink according to the
needs at runtime.
• It is used in many virtual machines like JVM.
Disadvantages of Linked List implementation:
• Requires extra memory due to the involvement of pointers.
• Random accessing is not possible in stack.
•

Applications, Advantages and Disadvantages of Stack:

Stack is a simple linear data structure used for storing data. Stack follows
the LIFO(Last In First Out) strategy that states that the element that is inserted last
will come out first. You can take a pile of plates kept on top of each other as a real-
life example. The plate which we put last is on the top and since we remove the
plate that is at the top, we can say that the plate that was put last comes out first. It
can be implemented through an array or linked lists. Some of its main operations
are: push(), pop(), top(), isEmpty(), size(), etc. In order to make manipulations
in a stack, there are certain operations provided to us. When we want to insert an
element into the stack the operation is known as the push operation whereas when
we want to remove an element from the stack the operation is known as the pop
operation. If we try to pop from an empty stack then it is known as underflow and
if we try to push an element in a stack that is already full, then it is known as
overflow.

Primary Stack Operations:

• void push(int data): When this operation is performed, an element is inserted into
the stack.
• int pop(): When this operation is performed, an element is removed from the
top of the stack and is returned.
Auxiliary Stack Operations:

• int top(): This operation will return the last inserted element that is at the top
without removing it.
• int size(): This operation will return the size of the stack i.e. the total number of
elements present in the stack.
• int isEmpty(): This operation indicates whether the stack is empty or not.
• int isFull(): This operation indicates whether the stack is full or not.
Types of Stacks:

• Register Stack: This type of stack is also a memory element present in the
memory unit and can handle a small amount of data only. The height of the
register stack is always limited as the size of the register stack is very small
compared to the memory.
• Memory Stack: This type of stack can handle a large amount of memory data.
The height of the memory stack is flexible as it occupies a large amount of
memory data.
What is meant by Top of the Stack?

• When a new element is added to the stack, it is placed on top of the existing
elements. Similarly, when an element is removed from the stack, the topmost
element is removed first. The top of the stack is always the element that is
currently accessible for viewing or manipulation.
• The pointer through which the elements are accessed, inserted, and deleted in the
stack is called the top of the stack. It is the pointer to the topmost element of the
stack.

STACK:

Application of Stack Data Structure:

• Function calls and recursion: When a function is called, the current state of the
program is pushed onto the stack. When the function returns, the state is popped
from the stack to resume the previous function’s execution.
• Undo/Redo operations: The undo-redo feature in various applications uses
stacks to keep track of the previous actions. Each time an action is performed, it
is pushed onto the stack. To undo the action, the top element of the stack is
popped, and the reverse operation is performed.
• Expression evaluation: Stack data structure is used to evaluate expressions in
infix, postfix, and prefix notations. Operators and operands are pushed onto the
stack, and operations are performed based on the stack’s top elements.
• Browser history: Web browsers use stacks to keep track of the web pages you
visit. Each time you visit a new page, the URL is pushed onto the stack, and
when you hit the back button, the previous URL is popped from the stack.
• Balanced Parentheses: Stack data structure is used to check if parentheses are
balanced or not. An opening parenthesis is pushed onto the stack, and a closing
parenthesis is popped from the stack. If the stack is empty at the end of the
expression, the parentheses are balanced.
• Backtracking Algorithms: The backtracking algorithm uses stacks to keep
track of the states of the problem-solving process. The current state is pushed
onto the stack, and when the algorithm backtracks, the previous state is popped
from the stack.
Application of Stack in real life:

• CD/DVD stand.
• Stack of books in a book shop.
• Call center systems.
• Undo and Redo mechanism in text editors.
• The history of a web browser is stored in the form of a stack.
• Call logs, E-mails, and Google photos in any gallery are also stored in form of a
stack.
• YouTube downloads and Notifications are also shown in LIFO format(the latest
appears first ).
• Allocation of memory by an operating system while executing a process.
Advantages of Stack:

• Easy implementation: Stack data structure is easy to implement using arrays or

linked lists, and its operations are simple to understand and implement.
• Efficient memory utilization: Stack uses a contiguous block of memory,
making it more efficient in memory utilization as compared to other data
structures.
• Fast access time: Stack data structure provides fast access time for adding and
removing elements as the elements are added and removed from the top of the
stack.
• Helps in function calls: Stack data structure is used to store function calls and
their states, which helps in the efficient implementation of recursive function
calls.
• Supports backtracking: Stack data structure supports backtracking algorithms,
which are used in problem-solving to explore all possible solutions by storing
the previous states.
• Used in Compiler Design: Stack data structure is used in compiler design for
parsing and syntax analysis of programming languages.
• Enables undo/redo operations: Stack data structure is used to enable undo and
redo operations in various applications like text editors, graphic design tools, and
software development environments.
 Disadvantages of Stack:

• Limited capacity: Stack data structure has a limited capacity as it can only hold
a fixed number of elements. If the stack becomes full, adding new elements may
result in stack overflow, leading to the loss of data.
• No random access: Stack data structure does not allow for random access to its
elements, and it only allows for adding and removing elements from the top of
the stack. To access an element in the middle of the stack, all the elements above
it must be removed.
• Memory management: Stack data structure uses a contiguous block of memory,
which can result in memory fragmentation if elements are added and removed
frequently.
• Not suitable for certain applications: Stack data structure is not suitable for
applications that require accessing elements in the middle of the stack, like
searching or sorting algorithms.
• Stack overflow and underflow: Stack data structure can result in stack overflow
if too many elements are pushed onto the stack, and it can result in stack
underflow if too many elements are popped from the stack.
• Recursive function calls limitations: While stack data structure supports
recursive function calls, too many recursive function calls can lead to stack
overflow, resulting in the termination of the program.
2. Queue:

What is queue data structure:

A queue is a linear data structure that is open at both ends and the
operations are performed in First In First Out (FIFO) order.
 We define a queue to be a list in which all additions to the list are
made at one end, and all deletions from the list are made at the other
end. The element which is first pushed into the order, the delete
operation is first performed on that.

FIFO Principle of Queue:

• A Queue is like a line waiting to purchase tickets, where the first person in line
is the first person served. (i.e. First come first serve).
• Position of the entry in a queue ready to be served, that is, the first entry that
will be removed from the queue, is called the front of the
queue(sometimes, head of the queue), similarly, the position of the last entry in
the queue, that is, the one most recently added, is called the rear (or the tail) of
the queue.

FIFO property of queue

Characteristics of Queue:
• Queue can handle multiple data.
• We can access both ends.
• They are fast and flexible.
Queue Representation:
 1. Array Representation of Queue:

Like stacks, Queues can also be represented in an array: In this representation, the
Queue is implemented using the array. Variables used in this case are

• Queue: the name of the array storing queue elements.

• Front: the index where the first element is stored in the array representing the
queue.
• Rear: the index where the last element is stored in an array representing the
queue.
•

Array representation of queue:

// Creating an empty queue

// A structure to represent a queue

#include<iostream>
Using namespace std;
struct Queue {
int front, rear, size;
unsigned capacity;
int* array;
};
// function to create a queue of given capacity
// It initializes size of queue as 0
struct Queue* createQueue(unsigned capacity)
{
struct Queue* queue
= (struct Queue*)malloc(sizeof(struct Queue));
 queue->capacity = capacity;
queue->front = queue->size = 0;
queue->rear = capacity - 1;
queue->array
= (int*)malloc(queue->capacity * sizeof(int));
return queue;
}

2. Linked List Representation of Queue:

A queue can also be represented using following entities:

• Linked-lists,
• Pointers, and
• Structures.
Types of Queue:
There are different types of queues:

1. Input Restricted Queue: This is a simple queue. In this type of queue, the

input can be taken from only one end but deletion can be done from any of the
ends.
2. Output Restricted Queue: This is also a simple queue. In this type of queue,

the input can be taken from both ends but deletion can be done from only one
end.
3. Circular Queue: This is a special type of queue where the last position is

connected back to the first position. Here also the operations are performed in
FIFO order. To know more refer this.
4. Double-Ended Queue (Dequeue): In a double-ended queue the insertion and

deletion operations, both can be performed from both ends. To know more
refer this.
5. Priority Queue: A priority queue is a special queue where the elements are

accessed based on the priority assigned to them. To know more refer this.
To learn more about different types of queues, read the article on “Types of
Queues“.

Basic Operations for Queue in Data Structure:

Some of the basic operations for Queue in Data Structure are:

1. Enqueue() – Adds (or stores) an element to the end of the queue..

2. Dequeue() – Removal of elements from the queue.

3. Peek() or front()- Acquires the data element available at the front node of the

queue without deleting it.

4. rear() – This operation returns the element at the rear end without removing it.

5. isFull() – Validates if the queue is full.

6. isNull() – Checks if the queue is empty.

There are a few supporting operations (auxiliary operations):

1. Enqueue():

Enqueue() operation in Queue adds (or stores) an element to the end of the
queue.
The following steps should be taken to enqueue (insert) data into a queue:

• Step 1: Check if the queue is full.

• Step 2: If the queue is full, return overflow error and exit.
• Step 3: If the queue is not full, increment the rear pointer to point to the next
empty space.
• Step 4: Add the data element to the queue location, where the rear is pointing.
• Step 5: return success.

2. Dequeue():
Removes (or access) the first element from the queue.
The following steps are taken to perform the dequeue operation:

• Step 1: Check if the queue is empty.

• Step 2: If the queue is empty, return the underflow error and exit.
• Step 3: If the queue is not empty, access the data where the front is pointing.
• Step 4: Increment the front pointer to point to the next available data element.
• Step 5: The Return success.

Implementation of dequeue:

3. front():

This operation returns the element at the front end without removing it.

4. rear():

This operation returns the element at the rear end without removing it.

5. isEmpty():

This operation returns a boolean value that indicates whether the queue is empty
or not.

6. isFull():
 This operation returns a boolean value that indicates whether the queue is full or
not.

Implementation of Queue:
Queue can be implemented using following data structures:

• Implementation of Queue using Structure in C/C++

• Implementation of Queue using Arrays
• Implementation of Queue using Linked List
Time complexity: All the operations have O(1) time complexity.
Auxiliary Space: O(N)

Applications of Queue:
Application of queue is common. In a computer system, there may be queues of
tasks waiting for the printer, for access to disk storage, or even in a time-sharing
system, for use of the CPU. Within a single program, there may be multiple
requests to be kept in a queue, or one task may create other tasks, which must be
done in turn by keeping them in a queue.

• It has a single resource and multiple consumers.

• It synchronizes between slow and fast devices.
• In a network, a queue is used in devices such as a router/switch and mail queue.
• Variations: dequeue, priority queue and double-ended priority queue.
Linked list:
What is linked list data structure:

A Linked List is a linear data structure which looks like a chain of

nodes, where each node is a different element. Unlike Arrays, Linked
List elements are not stored at a contiguous location.
 It is basically chains of nodes, each node contains information such as data and
a pointer to the next node in the chain. In the linked list there is a head pointer,
which points to the first element of the linked list, and if the list is empty then it
simply points to null or nothing.

Why linked list data structure needed?

Here are a few advantages of a linked list that is listed below, it will help you
understand why it is necessary to know.

• Dynamic Data structure: The size of memory can be allocated or de-allocated

at run time based on the operation insertion or deletion.
• Ease of Insertion/Deletion: The insertion and deletion of elements are simpler
than arrays since no elements need to be shifted after insertion and deletion,
Just the address needed to be updated.
• Efficient Memory Utilization: As we know Linked List is a dynamic data
structure the size increases or decreases as per the requirement so this avoids
the wastage of memory.
• Implementation: Various advanced data structures can be implemented using
a linked list like a stack, queue, graph, hash maps, etc.

Types of linked lists:

There are mainly three types of linked lists:

1. Single-linked list

2. Double linked list

3. Circular linked list

1. Singly-linked list
Traversal of items can be done in the forward direction only due to the linking of
every node to its next node.
 Commonly used operations on Singly Linked List:

The following operations are performed on a Single Linked List

• Insertion: The insertion operation can be performed in three ways. They are as
follows…
• Inserting At the Beginning of the list
• Inserting At End of the list
• Inserting At Specific location in the list
• Deletion: The deletion operation can be performed in three ways. They are as
follows…
• Deleting from the Beginning of the list
• Deleting from the End of the list
• Deleting a Specific Node
• Search: It is a process of determining and retrieving a specific node either from
the front, the end or anywhere in the list.
• Display: This process displays the elements of a Single-linked list.
// A Single linked list node
class Node {
public:
int data;
Node* next;
};

2. Doubly linked list:

Traversal of items can be done in both forward and backward directions as every
node contains an additional prev pointer that points to the previous node.
/* Node of a doubly linked list */
 class Node {
public:
int data;
Node* next; // Pointer to next node in DLL
Node* prev; // Pointer to previous node in DLL
};

Commonly used operations on Double-Linked List:

In a double-linked list, we perform the following operations…

• Insertion: The insertion operation can be performed in three ways as follows:

• Inserting At the Beginning of the list
• Inserting after a given node.
• Inserting at the end.
• Inserting before a given node
• Deletion: The deletion operation can be performed in three ways as follows…
• Deleting from the Beginning of the list
• Deleting from the End of the list
• Deleting a Specific Node
• Display: This process displays the elements of a double-linked list.
3. Circular linked lists
A circular linked list is a type of linked list in which the first and the last nodes
are also connected to each other to form a circle, there is no NULL at the end.

Commonly used operations on Circular Linked List:

The following operations are performed on a Circular Linked List

• Insertion: The insertion operation can be performed in three ways:

• Insertion in an empty list
• Insertion at the beginning of the list
• Insertion at the end of the list
• Insertion in between the nodes
• Deletion: The deletion operation can be performed in three ways:
• Deleting from the Beginning of the list
• Deleting from the End of the list
• Deleting a Specific Node
• Display: This process displays the elements of a Circular linked list.

Linked List vs. Array in Time Complexity

Operation Linked list Array

Random Access O(N) O(1)

Insertion and deletion at beginning O(1) O(N)

Insertion and deletion at end O(N) O(1)

Insertion and deletion at a random position O(N) O(N)

Advantages of Linked Lists:

• Dynamic nature: Linked lists are used for dynamic memory allocation.
• Memory efficient: Memory consumption of a linked list is efficient as its size
can grow or shrink dynamically according to our requirements, which means
effective memory utilization hence, no memory wastage.
• Ease of Insertion and Deletion: Insertion and deletion of nodes are easily
implemented in a linked list at any position.
• Implementation: For the implementation of stacks and queues and for the
representation of trees and graphs.
• The linked list can be expanded in constant time.
Disadvantages of Linked Lists:
• Memory usage: The use of pointers is more in linked lists hence, complex and
requires more memory.
• Accessing a node: Random access is not possible due to dynamic memory
allocation.
• Search operation costly: Searching for an element is costly and requires O(n)
time complexity.
• Traversing in reverse order: Traversing is more time-consuming and reverse
traversing is not possible in singly linked lists.
Applications of Linked List:
Here are some of the applications of a linked list:

• Linear data structures such as stack, queue, and non-linear data structures such
as hash maps, and graphs can be implemented using linked lists.
• Dynamic memory allocation: We use a linked list of free blocks.
• Implementation of graphs: Adjacency list representation of graphs is the most
popular in that it uses linked lists to store adjacent vertices.
• In web browsers and editors, doubly linked lists can be used to build a forwards
and backward navigation button.
• A circular doubly linked list can also be used for implementing data structures
like Fibonacci heaps.
Applications of Linked Lists in real world:
• The list of songs in the music player is linked to the previous and next songs.
• In a web browser, previous and next web page URLs are linked through the
previous and next buttons.
• In the image viewer, the previous and next images are linked with the help of
the previous and next buttons.
• Switching between two applications is carried out by using “alt+tab” in
windows and “cmd+tab” in mac book. It requires the functionality of a circular
linked list.
• In mobile phones, we save the contacts of people. The newly entered contact
details will be placed at the correct alphabetical order.
• This can be achieved by a linked list to set contact at the correct alphabetical
position.
• The modifications that we made in the documents are actually created as nodes
in doubly linked list. We can simply use the undo option by pressing Ctrl+Z to
modify the contents. It is done by the functionality of a linked list.

#include <iostream> // Library for input and

output operations

#include <vector> // Library for using vectors

#include <string> // Library for using strings

#include <list> // Library for using linked lists

#include <stack> // Library for using stacks

#include <queue> // Library for using queues

using namespace std;

// Class representing a Book

class Book {

private:

string Title; // Title of the book

string Author; // Author of the book

bool Available; // Availability status of the

book

public:
 // Here we will use Constructor to initialize the

book with a title, author, and availability status

Book(string Title, string Author) : Title(Title),

Author(Author), Available(true) {}

// The getter method is use to retrieve the title

of the book

string getTitle() const {

return Title;

// This getter method is use to access the

author of the book

string getAuthor() const {

 return Author;

// this getter method is use to access the

information to check the availability status of

the book

bool getAvailability() const {

return Available;

// This function is showing the method of

borrowing a book

void borrowBook() {

if (Available) {
 Available = false;

cout << "Book \"" << Title << "\" borrowed

successfully.\n";

} else {

cout << "Sorry, the book \"" << Title << "\"

is not available.\n";

// Method to simulate returning a book

void returnBook() {

Available = true;

cout << "Book \"" << Title << "\" returned

successfully.\n";
 }

};

// Class representing a Member

class Member {

private:

string name; // Name of the member

int memberId; // Member ID

public:

// The Constructor is use to initialize the

member with a Name and ID

Member(string name, int memberId) :

name(name), memberId(memberId) {}
 // Getter method to retrieve the name of the

member

string getName() const {

return name;

// We will use the Getter method to access the

ID of the member

int getMemberId() const {

return memberId;

};
// Class representing a Library

class Library {

private:

list<Book> bookList; // List of books in the

library

vector<Member> members; // Vector of

members in the library

stack<Book> borrowedBooks; // Stack to keep

track of borrowed books

queue<Book> returnedBooks; // Queue to

keep track of returned books

public:

// this Method will add a book to the library

 void addBook(const Book& book) {

bookList.push_back(book);

cout << "Book \"" << book.getTitle() << "\"

added to the library.\n";

//This Method will add a member to the library

void addMember(const Member& member) {

members.push_back(member);

cout << "Member \"" << member.getName()

<< "\" added to the library.\n";

}
 // Method to display the list of books in the

library

void displayBooks() const {

cout << "Library Books:\n";

for (const auto& book : bookList) {

cout << "Title: " << book.getTitle() << ",

Author: " << book.getAuthor()

<< ", Availability: " <<

(book.getAvailability() ? "Available" : "Not

Available") << "\n";

}
 // Method to display the list of members in the

library

void displayMembers() const {

cout << "Library Members:\n";

for (const auto& member : members) {

cout << "Member ID: " <<

member.getMemberId() << ", Name: " <<

member.getName() << "\n";

// This Method will implement borrowing a

book by a member
 void borrowBook(int memberId, const string&

bookTitle) {

for (auto& book : bookList) {

if (book.getTitle() == bookTitle) {

for (const auto& member : members) {

if (member.getMemberId() ==

memberId) {

book.borrowBook();

borrowedBooks.push(book);

return;

cout << "Member with ID " << memberId

<< " not found.\n";

 return;

cout << "Book \"" << bookTitle << "\" not

found.\n";

//This Method to returning a book to the

library

void returnBook(const string& bookTitle) {

for (auto& book : bookList) {

if (book.getTitle() == bookTitle) {

book.returnBook();

returnedBooks.push(book);
 return;

cout << "Book \"" << bookTitle << "\" not

found.\n";

// This Method will display the list of borrowed

books

void displayBorrowedBooks() const {

stack<Book> tempStack = borrowedBooks;

cout << "Borrowed Books:\n";

while (!tempStack.empty()) {
 cout << "Title: " <<

tempStack.top().getTitle() << ", Author: " <<

tempStack.top().getAuthor() << "\n";

tempStack.pop();

// Method to display the list of returned books

void displayReturnedBooks() const {

queue<Book> tempQueue = returnedBooks;

cout << "Returned Books:\n";

while (!tempQueue.empty()) {
 cout << "Title: " <<

tempQueue.front().getTitle() << ", Author: " <<

tempQueue.front().getAuthor() << "\n";

tempQueue.pop();

};

// This Function will print the menu options for

the library management system

void printMenu() {

cout << "\nOptions:\n";

cout << "1. Add Book\n";

cout << "2. Add Member\n";

 cout << "3. Display Books\n";

cout << "4. Display Members\n";

cout << "5. Borrow a Book\n";

cout << "6. Return a Book\n";

cout << "7. Display Borrowed Books\n";

cout << "8. Display Returned Books\n";

cout << "9. Exit\n";

// Here is Main function, in which we will call our

functins

int main() {

Library library; // Creating a a Library object

 // here we are adding some sample books to

the library

library.addBook(Book("The Reluctant

Fundamentalist", " Mohsin Hamid"));

library.addBook(Book("A Case of Exploding

Mangoes", "Mohammed Hanif"));

library.addBook(Book("I Am Malala: The Girl

Who Stood Up for Education and Was Shot by

the Taliban", "Malala Yousafzai"));

library.addBook(Book("In Other Rooms", "by

Daniyal Mueenuddin"));

library.addBook(Book("My Feudal Lord", "

Tehmina Durrani"));
 library.addBook(Book("To Kill a Mockingbird",

"Harper Lee"));

library.addBook(Book("Kartography", "Kamila

Shamsie"));

library.addBook(Book("The Crow

Eaters","Bapsi Sidhwa"));

library.addBook(Book("The Catcher in the

Rye", "J.D. Salinger"));

library.addBook(Book("To Kill a Mockingbird",

"Harper Lee"));

library.addBook(Book("1984", "George

Orwell"));

// Adding sample members to the library

 library.addMember(Member("John Doe", 1));

library.addMember(Member("Jane Smith", 2));

library.addMember(Member("Emily Johnson",

3));

library.addMember(Member("Raj Patel", 4));

library.addMember(Member("Sarah

Thompson", 5));

library.addMember(Member("Ahmad khan",

6));

library.addMember(Member("Alkia jane", 7));

library.addMember(Member("Fatima Ali", 8));

library.addMember(Member("Alexander jone",

9));
 library.addMember(Member("Ayesha memon",

10));

library.addMember(Member("Daniel mitchell",

11));

library.addMember(Member("Eman ift", 12));

library.addMember(Member("Alvi aime", 13));

library.addMember(Member("tayaba sadd",

14));

library.addMember(Member("hira hocane",

15));

library.addMember(Member("urwa farha", 16));

int choice;

do {
 printMenu(); // we will display menu options

and can add more menu options

cout << "Enter your choice: ";

cin >> choice;

switch (choice) {

case 1: {

string title, author;

cout << "Enter book title: ";

cin.ignore();

getline(cin, title);

cout << "Enter author: ";

getline(cin, author);
 library.addBook(Book(title, author)); //

we can add a new book to the library by this

break;

case 2: {

string name;

int memberId;

cout << "Enter member name: ";

cin.ignore();

getline(cin, name);

cout << "Enter member ID: ";

cin >> memberId;

 library.addMember(Member(name,

memberId)); //we can add a new member to the

library by its datamembers like name and id

break;

case 3:

library.displayBooks(); // this function

will display the list of books in the library

break;

case 4:

library.displayMembers(); // this

function will display the list of members in the

library

break;
 case 5: {

int memberId;

string bookTitle;

cout << "Enter member ID: ";

cin >> memberId;

cout << "Enter book title: ";

cin.ignore();

getline(cin, bookTitle);

library.borrowBook(memberId,

bookTitle); // This will Simulate borrowing a book

break;

case 6: {

string bookTitle;
 cout << "Enter book title: ";

cin.ignore();

getline(cin, bookTitle);

library.returnBook(bookTitle); // This

method shows returning a book

break;

case 7:

library.displayBorrowedBooks();

// here we will display the list of borrowed books

break;

case 8:

library.displayReturnedBooks(); // here

we will display the list of returned books

 break;

case 9:

cout << "Exiting program.\n"; //

now exit the program

break;

case 10: //this is a additional option if we

want to add more sample books

library.addBook(Book("New Book

Title", "New Author"));

break;

default:

cout << "Invalid choice. Please try

again.\n"; //thus will display an error message for

invalid choices
 }

} while (choice != 9); // this will Continue the

loop until the user chooses to exit

return 0;
1. Classes and Object-Oriented Programming (OOP):

Usage: The code is organized using three classes: Book, Member, and Library.

Explanation: Object-oriented principles are applied for encapsulation, providing

a clear structure for representing books, members, and the library.

2. Data Structures:

Vector (std::vector):

Usage: vector<Member> is employed to store the list of members in the library.

 Explanation: Vectors provide dynamic arrays that can grow in size, offering an

efficient way to manage a variable number of members.

List (std::list):

Usage: list<Book> is used to store the list of books in the library.

Explanation: Linked lists are utilized to allow efficient addition and removal of

books, supporting dynamic updates without the need for extensive memory

reallocation.

Stack (std::stack):

Usage: stack<Book> is used to keep track of borrowed books.

Explanation: A stack is suitable for tracking borrowed books as it follows the

Last In, First Out (LIFO) principle, reflecting the borrowing and returning

sequence.

Queue (std::queue):

Usage: queue<Book> is utilized to manage returned books.

 Explanation: A queue is chosen to maintain the order of returned books, adhering

to the First In, First Out (FIFO) principle.

3. Linked Lists:

Usage: Linked lists are implicitly used in the std::list<Book> container.

Explanation: Linked lists facilitate dynamic updates to the book list, ensuring

efficient memory usage and flexibility in managing books.

4. Search Algorithms:

Usage: Iterative search loops are employed in borrowBook and returnBook

methods.

Explanation: A linear search algorithm is implemented to find a specific book or

member based on the provided title or ID, enabling borrowing and returning

functionalities.

5. Dynamic Memory Allocation:

Usage: Memory is dynamically allocated for storing objects like books and

members when adding them to the library.

Explanation: Dynamic memory allocation allows the program to handle a

variable number of books and members without pre-allocating fixed-size arrays.

6. Input/Output Operations:

Usage: <iostream> is used for input and output operations.

 Explanation: Input is taken to capture user choices, and output is used to display

information about books, members, and the borrowing/returning process.

7. Error Handling:

Usage: A default case in the switch statement handles invalid user choices.

Explanation: This ensures that the program responds appropriately to unexpected

user input, providing a user-friendly experience.

Summary:

This Library Management System code demonstrates the practical implementation

of various DSA concepts, including vector, list, stack, queue, linked list, dynamic

memory allocation, and search algorithms. These concepts contribute to the

efficiency, flexibility, and organization of the library system, making it a robust

solution for managing books, members, and borrowing/returning operations.