1.Outline the concept of a singly linked list and its fundamental operations.

Compare its efficiency with that of an array-based list for dynamic data handling
(or)Explain the basic structure of a singly linked list and list the fundamental
operations it supports
A singly linked list is a data structure used to store a sequence of elements, where each element
points to the next element in the sequence. It consists of nodes, each containing two parts:
1. Data: The value or data stored in the node.
2. Next: A reference (or pointer) to the next node in the list.
The list starts with a head node (the first node), and ends with a node whose next reference is
null (indicating the end of the list). There’s no direct way to access nodes other than by
traversing the list from the head.
Fundamental Operations
1. Insertion:
o At the head: Add a new node before the current head and update the head
reference.
o At the tail: Traverse the list to the end and add the new node.
o At a specific position: Traverse to the desired position and adjust pointers to
insert the new node.
2. Deletion:
o From the head: Update the head reference to the next node.
o From the tail: Traverse to the second-to-last node and set its next to null.
o At a specific position: Traverse to the position before the node to be deleted,
adjust pointers to bypass the node being deleted.
3. Traversal: Iterate through the list starting from the head to access or print the data in
each node.
4. Search: Traverse the list to find a node containing a specific value.
5. Update: Traverse to the node that needs updating and change its data value.
Efficiency Comparison with Array-Based List
Array-Based List
 Structure: Arrays are contiguous blocks of memory. Elements are indexed and can be
accessed directly.
 Size: Fixed size or dynamically resized (e.g., using a dynamic array or array list).
Efficiency Comparison
1. Insertion and Deletion:
o Singly Linked List:
 At Head: O(1) – Insertions or deletions at the head are very efficient.
 At Tail: O(n) – Requires traversal of the entire list unless a tail pointer is
maintained.
 At Specific Position: O(n) – Requires traversal to the position.
o Array-Based List:
 At End: O(1) – Efficient if resizing is not needed; otherwise, amortized
O(1) due to dynamic resizing.
  At Specific Position: O(n) – Requires shifting elements if insertion or
deletion is not at the end.
2. Access:
o Singly Linked List: O(n) – Must traverse the list from the head to reach a
specific position.
o Array-Based List: O(1) – Direct access via index.
3. Memory Usage:
o Singly Linked List: O(n) extra space for pointers; no wasted space, but overhead
due to pointer storage.
o Array-Based List: May have wasted space if the array is not fully utilized;
resizing can also incur overhead.
4. Resizing:
o Singly Linked List: No resizing needed; dynamically adjusts with each insertion
or deletion.
o Array-Based List: May require resizing and copying elements to a new array
when capacity is exceeded.
2.Explain how the insertion of a node in a doubly linked list affects the
adjacent nodes in both directions.Provide a step-by-step example. or
Illustrate how the deletion of a node from a doubly linked list affects the
previous and next pointers of adjacent nodes. Provide an example to illustrate

Doubly Linked List

A doubly linked list is a type of linked list in which each node consists of 3 components:
 *prev - address of the previous node
 data - data item
 *next - address of next node
Representation of Doubly Linked List
Let's see how we can represent a doubly linked list on an algorithm/code.
Suppose we have a doubly linked list:

Ne
wly created doubly linked list

Here, the single node is represented as

struct node {
int data;
struct node *next;
struct node *prev;
}

Each struct node has a data item, a pointer to the previous struct node, and a
pointer to the next struct node.

Now we will create a simple doubly linked list with three items to understand
how this works.

/* Initialize nodes */
struct node *head;
struct node *one = NULL;
struct node *two = NULL;
struct node *three = NULL;

/* Allocate memory */
one = malloc(sizeof(struct node));
two = malloc(sizeof(struct node));
three = malloc(sizeof(struct node));
 /* Assign data values */
one->data = 1;
two->data = 2;
three->data = 3;

/* Connect nodes */
one->next = two;
one->prev = NULL;

two->next = three;
two->prev = one;

three->next = NULL;
three->prev = two;

/* Save address of first node in head */

head = one;

In the above code, one , two , and three are the nodes with data items 1, 2,
and 3 respectively.
 For node one: next stores the address of two and prev stores null (there is
no node before it)
 For node two: next stores the address of three and prev stores the address
of one

 For node three: next stores null (there is no node after it) and prev stores
the address of two .

Note: In the case of the head node, prev points to null , and in the case of the
tail pointer, next points to null. Here, one is a head node and three is a tail
node.
 Insertion on a Doubly Linked List
Pushing a node to a doubly-linked list is similar to pushing a node to a linked
list, but extra work is required to handle the pointer to the previous node.

We can insert elements at 3 different positions of a doubly-linked list:

1. Insertion at the beginning

2. Insertion in-between nodes
3. Insertion at the End
Suppose we have a double-linked list with elements 1, 2, and 3.

Ori
ginal doubly linked list

1. Insertion at the Beginning

Let's add a node with value 6 at the beginning of the doubly linked list we
made above.
1. Create a new node
 allocate memory for newNode

 assign the data to newNode .

 New node

2. Set prev and next pointers of new node

 point next of newNode to the first node of the doubly linked list
 point prev to null

Re
organize the pointers (changes are denoted by purple arrows)

3. Make new node as head node

 Point prev of the first node to newNode (now the previous head is the second
node)
 Point head to newNode

Reo
rganize the pointers

Code for Insertion at the Beginning

 // insert node at the front
void insertFront(struct Node** head, int data) {

// allocate memory for newNode

struct Node* newNode = new Node;

// assign data to newNode

newNode->data = data;

// point next of newNode to the first node of the doubly linked list
newNode->next = (*head);

// point prev to NULL

newNode->prev = NULL;

// point previous of the first node (now first node is the second
node) to newNode
if ((*head) != NULL)
(*head)->prev = newNode;

// head points to newNode

(*head) = newNode;
}

2. Insertion in between two nodes

Let's add a node with value 6 after node with value 1 in the doubly linked list.

1. Create a new node

 allocate memory for newNode

 assign the data to newNode .

 New node

2. Set the next pointer of new node and previous node

 assign the value of next from previous node to the next of newNode

 assign the address of newNode to the next of previous node

Re
organize the pointers

3. Set the prev pointer of new node and the next node
 assign the value of prev of next node to the prev of newNode

 assign the address of newNode to the prev of next node

Re
organize the pointers
The final doubly linked list is after this insertion is:

Fin
al list

Code for Insertion in between two Nodes

// insert a node after a specific node

void insertAfter(struct Node* prev_node, int data) {

// check if previous node is NULL

if (prev_node == NULL) {
cout << "previous node cannot be NULL";
return;
}

// allocate memory for newNode

struct Node* newNode = new Node;

// assign data to newNode

newNode->data = data;

// set next of newNode to next of prev node

newNode->next = prev_node->next;

// set next of prev node to newNode

prev_node->next = newNode;

// set prev of newNode to the previous node

newNode->prev = prev_node;

// set prev of newNode's next to newNode

if (newNode->next != NULL)
newNode->next->prev = newNode;
}
3. Insertion at the End
Let's add a node with value 6 at the end of the doubly linked list.

1. Create a new node

New node

2. Set prev and next pointers of new node and the previous node
If the linked list is empty, make the newNode as the head node. Otherwise,
traverse to the end of the doubly linked list and

Reorganize the
pointers

The final doubly linked list looks like this.

 Th
e final list

Code for Insertion at the End

// insert a newNode at the end of the list

void insertEnd(struct Node** head, int data) {
// allocate memory for node
struct Node* newNode = new Node;

// assign data to newNode

newNode->data = data;

// assign NULL to next of newNode

newNode->next = NULL;

// store the head node temporarily (for later use)

struct Node* temp = *head;

// if the linked list is empty, make the newNode as head node

if (*head == NULL) {
newNode->prev = NULL;
*head = newNode;
return;
}

// if the linked list is not empty, traverse to the end of the linked
list
while (temp->next != NULL)
temp = temp->next;

// now, the last node of the linked list is temp

// point the next of the last node (temp) to newNode.

temp->next = newNode;
 // assign prev of newNode to temp
newNode->prev = temp;
}

Deletion from a Doubly Linked List

Similar to insertion, we can also delete a node from 3 different positions of a
doubly linked list.
Suppose we have a double-linked list with elements 1, 2, and 3.

Ori
ginal doubly linked list

1. Delete the First Node of Doubly Linked List

If the node to be deleted (i.e. del_node ) is at the beginning
Reset value node after the del_node (i.e. node two)
 Reo
rganize the pointers

Finally, free the memory of del_node . And, the linked will look like this

Final list

Code for Deletion of the First Node

if (*head == del_node)
*head = del_node->next;

if (del_node->prev != NULL)
del_node->prev->next = del_node->next;

free(del);

2. Deletion of the Inner Node

If del_node is an inner node (second node), we must have to reset the value
of next and prev of the nodes before and after the del_node .

For the node before the del_node (i.e. first node)

Assign the value of next of del_node to the next of the first node.
For the node after the del_node (i.e. third node)
Assign the value of prev of del_node to the prev of the third node.

Re
organize the pointers

Finally, we will free the memory of del_node . And, the final doubly linked list
looks like this.

Fina
l list

Code for Deletion of the Inner Node

if (del_node->next != NULL)
del_node->next->prev = del_node->prev;

if (del_node->prev != NULL)
del_node->prev->next = del_node->next;

3. Delete the Last Node of Doubly Linked List

In this case, we are deleting the last node with value 3 of the doubly linked list.
Here, we can simply delete the del_node and make the next of node
before del_node point to NULL .
 Reor
ganize the pointers

The final doubly linked list looks like this.

Final list

Code for Deletion of the Last Node

if (del_node->prev != NULL)
del_node->prev->next = del_node->next;

Here, del_node ->next is NULL so del_node->prev->next = NULL .

3.Interpret elementary data types and abstract data types

Elementary Data Types and Abstract Data Types in C Programming
Elementary Data Types
Elementary data types are the basic types of data provided by C that serve as the building blocks
for data manipulation and storage. They represent single values and are typically built into the
language.
1. Integer Types:
o int: Represents integer values. Size varies by system (e.g., 4 bytes on many
systems).
o short: Represents smaller integer values (e.g., 2 bytes).
o long: Represents larger integer values (e.g., 4 or 8 bytes).
o long long: Represents even larger integer values (e.g., 8 bytes).
2. Character Type:
 o char: Represents a single character. Typically 1 byte. Can be signed or
unsigned.
3. Floating-Point Types:
o float: Represents single-precision floating-point numbers (e.g., 4 bytes).
o double: Represents double-precision floating-point numbers (e.g., 8 bytes).
o long double: Represents extended-precision floating-point numbers (size
varies).
4. Void Type:
o void: Represents the absence of value or type. Used for functions that do not
return a value or pointers to unspecified data types.
Abstract Data Types (ADTs)
Abstract Data Types are conceptual models that define data structures in terms of their behavior
rather than their implementation. ADTs specify what operations can be performed on data and
what properties the operations must satisfy.
1. List:
o Description: A collection of elements arranged in a sequence. Elements can be added,
removed, and accessed by position.
o Operations: add(), remove(), get(), size()
o Example: A list of integers [1, 2, 3, 4]
2. Stack:
o Description: A collection that follows the Last In, First Out (LIFO) principle. Only the top
element can be accessed directly.
o Operations: push(), pop(), peek()
o Example: A stack of books where you add/remove books from the top.
3. Queue:
o Description: A collection that follows the First In, First Out (FIFO) principle. Elements are
added at the end and removed from the front.
o Operations: enqueue(), dequeue(), front()
o Example: A queue at a ticket counter where people are served in the order they arrive.
4. Tree:
o Description: A hierarchical structure consisting of nodes, where each node has zero or
more children.
o Operations: insert(), delete(), traverse()
o Example: A family tree or a directory structure.
5. Graph:
o Description: A collection of nodes (vertices) connected by edges. Useful for representing
networks.
o Operations: addVertex(), addEdge(), findPath()
o Example: A social network or a map of cities connected by roads.

4.Summarize the role of queues in job scheduling and data buffering

Role of Queues in Job Scheduling and Data Buffering
1. Queues in Job Scheduling
Definition: A queue is a linear data structure that follows the First In, First Out (FIFO) principle.
It processes elements in the order they arrive, ensuring that the first element added is the first one
to be removed.
Role in Job Scheduling:
 Job Scheduling: In job scheduling, a queue helps manage the sequence in which tasks or
jobs are executed by the system. Jobs are enqueued (added) to the scheduling queue and
then dequeued (executed) in the order they arrive.
Key Aspects:
o Fairness: Ensures that jobs are processed in the order of arrival, providing
fairness and preventing starvation of jobs.
o Efficiency: Allows efficient management of job execution, reducing the
complexity of job handling. The FIFO nature helps in maintaining an orderly
process flow.
o Preemptive Scheduling: In some systems, queues are used in preemptive
scheduling where a job can be interrupted and later resumed. Jobs are placed in
different queues based on their priority and execution state.
Examples:
o Operating Systems: Many operating systems use queues to manage processes or
threads. The ready queue holds processes that are waiting to be executed by the
CPU.
o Printers: Print jobs are placed in a queue and printed in the order they were
received.
2. Queues in Data Buffering
Definition: Data buffering involves temporarily storing data in a queue before it is processed or
transmitted. This helps manage varying rates of data production and consumption.
Role in Data Buffering:
 Data Buffering: Queues act as buffers to handle differences in processing speeds
between producing and consuming entities. They smooth out the flow of data, allowing
for more efficient processing and transmission.
Key Aspects:
o Smooth Data Flow: Queues help prevent data loss and overflow by temporarily
holding data when the consumer is slower than the producer.
o Asynchronous Processing: Allows for asynchronous processing of data.
Producers can continue generating data without waiting for consumers to process
it immediately.
o Load Balancing: Manages varying loads by balancing the rate of data production
and consumption, reducing the likelihood of bottlenecks.
Examples:
o I/O Buffers: In computer systems, queues are used in buffering input/output
operations. For instance, data read from a disk is buffered in a queue before being
processed by the application.
o Network Buffers: Data packets sent over a network are often buffered in queues
to handle network latency and variability in data transmission speeds.
 5. Explain the fundamental operations associated with array implementation
Arrays are a fundamental data structure used to store a collection of elements. In most
programming languages, arrays are implemented as contiguous blocks of memory, which makes
accessing elements by index efficient. Here's a detailed explanation of various operations that
can be performed on arrays, including their complexity and implications.
1. Accessing an Element
Operation: Retrieve an element at a specific index.
Description:
 Arrays provide constant-time access to elements because the memory address of each
element can be computed directly using the base address and the index.
 For an array arr with base address B and element size S, the address of arr[i] is B + i
* S.
Complexity: O(1)
Example:
int value = arr[5]; // Accesses the element at index 5
2. Updating an Element
Operation: Modify the value of an element at a specific index.
Description:
 Updating an element also involves direct access using the index, so it is similarly
efficient.
 The operation overwrites the existing value at the specified index.
Complexity: O(1)
Example:
arr[5] = 10; // Updates the element at index 5 to 10
3. Insertion
Operation: Insert an element at a specific position.
Description:
 For Sorted Arrays: Inserting an element involves finding the correct position (which
might require O(n) time if using linear search) and then shifting elements to make space
for the new element.
 For Unsorted Arrays: Inserting at a specific position involves shifting elements to the
right to create space for the new element.
Complexity:
 Sorted Array: O(n) due to the need to shift elements and find the position.
 Unsorted Array: O(n) for shifting elements, plus O(1) for the insertion itself.
Example:
// Insert an element into an unsorted array
int i;
for (i = size - 1; i >= position; i--) {
arr[i + 1] = arr[i]; // Shift elements to the right
}
arr[position] = newValue; // Insert the new value
size++; // Update the size
4. Deletion
Operation: Remove an element from a specific position.
Description:
 For Unsorted Arrays: To delete an element, replace it with the last element and reduce
the size. This is often used to avoid shifting elements.
 For Sorted Arrays: Deleting an element involves finding it and then shifting elements to
fill the gap.
Complexity:
 Unsorted Array: O(1) if replacing with the last element, plus O(1) for the deletion itself.
 Sorted Array: O(n) due to shifting elements to fill the gap.
Example:
// Delete an element from an unsorted array
arr[position] = arr[size - 1]; // Replace with the last element
size--; // Update the size

6.Illustrate various applications of stacks in real-world systems.

Stacks are a fundamental data structure that operate on a Last In, First Out (LIFO) principle. This
means the last element added is the first one to be removed. Stacks are utilized in a variety of
real-world systems and applications due to their specific characteristics. Here are some key
applications:
1. Function Call Management in Programming Languages
Description: In most programming languages, function calls are managed using a stack. When a
function is called, a new frame containing local variables, arguments, and the return address is
pushed onto the call stack. When the function completes, its frame is popped from the stack, and
control is returned to the calling function.
Examples:
 Recursion: Functions that call themselves (e.g., in algorithms like depth-first search) use
the stack to keep track of function calls and return points.
2. Undo Mechanisms in Applications
Description: Many software applications, such as text editors and graphic design tools, use
stacks to implement undo and redo functionalities. Actions performed by the user are pushed
onto an undo stack. When the user selects undo, the most recent action is popped from the undo
stack and reversed. Redo functionality often uses a separate redo stack.
 .
Examples:
 Text Editors: Undoing typing or formatting changes.
 Graphic Design Software: Reverting drawing or editing actions.
3. Expression Evaluation and Syntax Parsing
Description: Stacks are used in evaluating arithmetic expressions and parsing syntax in
compilers. For example, evaluating expressions written in postfix notation (Reverse Polish
Notation) involves using a stack to handle operators and operands.
Examples:
 Arithmetic Expression Evaluation: Evaluating expressions like "3 4 + 2 *" using a
stack.
 Compilers: Parsing expressions and ensuring correct operator precedence.
4. Backtracking Algorithms
Description: Backtracking algorithms, such as those used in maze solving, constraint
satisfaction problems, and puzzle solving, rely on stacks to keep track of decisions and explore
alternative paths. The stack stores the current state and decision points, allowing the algorithm to
backtrack when a dead end is encountered.
Examples:
 Maze Solvers: Stacks are used to explore different paths and backtrack when necessary.
 Puzzle Solvers: Solving puzzles like the N-Queens problem by exploring possible
configurations and backtracking.
5. Browser History Management
Description: Web browsers use stacks to manage navigation history. Each visited webpage is
pushed onto a stack. When the user clicks the back button, the current page is popped from the
stack, and the browser navigates to the previous page.
Examples:
 Web Browsers: Navigating through previously visited pages using the back and forward
buttons.
6. Parsing and Evaluating Nested Structures
Description: Stacks are crucial in parsing and evaluating nested structures, such as balanced
parentheses or HTML/XML tags. They help ensure that every opening symbol has a
corresponding closing symbol and is properly nested.
Examples:
 Syntax Checking: Validating expressions with nested parentheses or braces.
 HTML/XML Parsing: Ensuring tags are correctly nested and closed.

7. Classify the structure and operations of the Stack ADT, and compare its
efficiency with other data structures in terms of time and space complexity
or
8. Illustrate a detailed implementation of the Stack ADT using arrays. Include an
evaluation of the advantages and limitations of this approach
.
Stack Data Structure is a linear data structure that follows LIFO
(Last In First Out) Principle , so the last element inserted is the
first to be popped out. In this article, we will cover all the basics of
Stack, Operations on Stack, its implementation, advantages,
disadvantages which will help you solve all the problems based on
Stack.

The Last In, First Out (LIFO) principle is a key concept in stack data structures. In a stack, the
most recently added element (the "last in") is the first one to be removed (the "first out"). This
principle ensures that elements are managed in a way that the most recent operations take
precedence over older ones. Let's delve into how the stack operations—push, pop, and peek—
support this principle.
1. Push Operation
Definition: The push operation adds an element to the top of the stack.
LIFO Principle:
 Support: When an element is pushed onto the stack, it becomes the new top element. Since the
stack only allows access to the top element, this means that the most recent element (the one
just pushed) is the first one that will be removed during subsequent operations.
 Implementation: The push operation involves placing the new element on top of the current
top of the stack and updating the top pointer/reference to this new element.
Example:
// Stack before push
// Top -> [A] -> [B] -> NULL

push(stack, 'C');

// Stack after push

// Top -> [C] -> [A] -> [B] -> NULL
In this example, 'C' is the most recently added element and becomes the new top of the stack.
2. Pop Operation
Definition: The pop operation removes the element from the top of the stack.
LIFO Principle:
 Support: The pop operation removes the element that was last added (the top of the stack).
This directly supports the LIFO principle because the last element pushed onto the stack is the
first one to be removed.
  Implementation: The pop operation involves removing the element from the top and then
updating the top pointer/reference to the next element in the stack. If the stack is empty, a pop
operation usually results in an error or underflow condition.
Example:
// Stack before pop
// Top -> [C] -> [A] -> [B] -> NULL

pop(stack); // Removes 'C'

// Stack after pop

// Top -> [A] -> [B] -> NULL
In this example, 'C', which was the last element added, is the first to be removed.
3. Peek Operation
Definition: The peek operation returns the element at the top of the stack without removing it.
LIFO Principle:
 Support: The peek operation reveals the most recently added element (the top of the stack)
without altering the stack. This operation supports the LIFO principle by providing access to the
element that would be the next to be removed by a pop operation.
 Implementation: The peek operation involves accessing the element at the top of the stack but
does not modify the stack’s structure or contents.
Example:
// Stack before peek
// Top -> [A] -> [B] -> NULL

int topElement = peek(stack); // Returns 'A'

// Stack remains unchanged

// Top -> [A] -> [B] -> NULL
In this example, the peek operation shows 'A', which is the last element added but the first to be
removed if a pop operation is executed next.
Summary
 Push: Adds an element to the top of the stack, making it the new "last in" element.
 Pop: Removes the element from the top of the stack, which is the most recent "last in" element
and thus the first to be removed.
 Peek: Accesses the element at the top of the stack without removing it, revealing the current
"last in" element.
By adhering to the LIFO principle, stacks ensure that the most recently added element is always
the one to be removed first, maintaining a strict order of operations that supports various
computational tasks such as function call management, undo mechanisms, and backtracking
algorithms.
9.Classify the core operations of the Queue ADT and analyze their role in
managing data within a queue. Illustrate each operation with examples to show its
functionality.
The Queue Abstract Data Type (ADT) operates on the First In, First Out (FIFO) principle, which
means the first element added to the queue will be the first one to be removed. This order ensures
that elements are processed in the same sequence in which they arrive. Let's illustrate how the
primary operations of the Queue ADT—enqueue, dequeue, and peek—function and their role
in maintaining the FIFO order.
1. Enqueue Operation
Definition: The enqueue operation adds an element to the end (rear) of the queue.
Role in FIFO:
 Support: The enqueue operation places the new element at the rear of the queue, which
maintains the order in which elements were added. This ensures that the oldest element
remains at the front and is the next one to be removed when a dequeue operation is
performed.
 Implementation: Typically involves adding the new element to the end of the underlying data
structure (e.g., a list or an array) and updating the rear pointer/reference.
Example:
// Initial Queue (empty)
Front -> NULL <- Rear

// Enqueue 1
Enqueue(1)
Front -> [1] -> NULL <- Rear

// Enqueue 2
Enqueue(2)
Front -> [1] -> [2] -> NULL <- Rear
In this example, elements 1 and 2 are added to the queue in that order, with 1 at the front and 2 at
the rear.
2. Dequeue Operation
Definition: The dequeue operation removes the element from the front of the queue.
Role in FIFO:
 Support: The dequeue operation removes the element at the front of the queue, which is the
oldest element that was added. This ensures that elements are processed in the exact order in
which they were enqueued.
 Implementation: Involves removing the element from the front of the queue and updating the
front pointer/reference to the next element in the queue. If the queue becomes empty after the
operation, the rear pointer/reference is also updated.
Example:
// Initial Queue
Front -> [1] -> [2] -> NULL <- Rear

// Dequeue
Dequeue()
Front -> [2] -> NULL <- Rear
// Removed element: 1
In this example, element 1, which was the first element added, is removed first, adhering to the
FIFO principle.
3. Peek Operation
Definition: The peek operation returns the element at the front of the queue without removing it.
Role in FIFO:
 Support: The peek operation allows access to the element that will be dequeued next, without
modifying the queue. This operation provides a way to view the oldest element (the front of the
queue) while preserving the FIFO order.
 Implementation: Involves accessing the element at the front pointer/reference without
changing the queue's structure.
Example:
// Initial Queue
Front -> [2] -> NULL <- Rear

// Peek
Peek()
Element at the front: 2

// Queue remains unchanged

Front -> [2] -> NULL <- Rear
In this example, the peek operation shows that the next element to be removed is 2, while the
queue remains in its current state.
Summary of Operations and FIFO Role
 Enqueue: Adds an element to the rear of the queue. This operation maintains the FIFO order by
ensuring that new elements are added to the end, so the front remains the oldest element.
 Dequeue: Removes an element from the front of the queue. This operation respects the FIFO
order by removing the oldest element first, thus maintaining the sequence in which elements
were added.
 Peek: Provides a view of the element at the front of the queue without removing it. This
operation helps verify which element will be removed next, adhering to the FIFO order.
By using these operations, the queue data structure effectively maintains the FIFO order,
ensuring that elements are processed in the order they arrive. This is crucial for various
applications such as task scheduling, managing resources, and handling asynchronous data
processing.