DSU Unit 1 Solved Question Bank

Q1 - What is data structure? Why to study data structure? Enlist the five areas of
computer science in which data structure is used?

Ans –
A data structure is a way to organize, manage, and store data efficiently for specific
operations and applications. It provides a means to perform various operations on data, such as
searching, inserting, deleting, and sorting, effectively and efficiently. Common examples of data
structures include arrays, linked lists, stacks, queues, trees, graphs, hash tables, and heaps.

Why Study Data Structures?

1. Efficiency: Proper choice of data structures can significantly improve the performance of
algorithms, making applications faster and more efficient.
2. Problem-Solving: Understanding data structures equips you to design and implement
solutions for complex computational problems.
3. Software Development: Data structures form the foundation of many algorithms and
systems, enabling the development of robust and scalable applications.
4. Optimization: Helps in optimizing both memory usage and processing speed, critical in
resource-constrained systems.
5. Core Computer Science: Data structures are fundamental to understanding computer
science concepts like databases, networks, and operating systems.

Five Areas of Computer Science Where Data Structures Are Used

1. Artificial Intelligence (AI):

2. Database Management Systems (DBMS):
3. Networking:
4. Operating Systems:
5. Machine Learning and Data Science:

Q2 - What is primitive data structure?

Ans -
➢ In the C programming language, primitive data structures are the basic building blocks
for data representation.
➢ These are the most fundamental data structures, and they are essential for developing any
kind of software application.
➢ Primitive data structures are characterized by their simplicity and directness in
representing single pieces of data.
1|Page
➢ These are predefined data types provided by the language to store and manipulate simple
data.

Types of Primitive Data Structures in C

Integer (int)

o Represents whole numbers (positive or negative).

o Size: Typically 2 or 4 bytes (platform-dependent).
o Example:
▪ int num = 10;

Floating-Point (float and double)

• Represents real numbers with decimal points.

• float: Single-precision (4 bytes).
• double: Double-precision (8 bytes).
• Example:
▪ float pi = 3.14; double largeValue = 1234567.89;

Character (char)

• Represents a single character or symbol (e.g., letters, digits, or special characters).

• Size: 1 byte.
• Example :
▪ char grade = 'A';

Boolean (_Bool)

• Represents true (1) or false (0).

• C does not have a built-in bool type in earlier versions but supports _Bool since C99.
• Example:
▪ #include <stdbool.h>bool isTrue = true;

Q3 - Enlist the differences between primitive and non-primitive data structures.

Ans –
Enlistment of Primitive and Non-Primitive Data Structures
Primitive Data Structures
• Integer (int)
• Floating-point numbers (float, double)
• Character (char)
• Boolean (_Bool or bool)

2|Page
Non-Primitive Data Structures
• Arrays
• Strings
• Structures (struct)
• Unions (union)
• Pointers
• Linked Lists
• Stacks
• Queues
• Trees
• Graphs

Differences Between Primitive and Non-Primitive Data Structures

Aspect Primitive Data Structures Non-Primitive Data Structures

Definition Basic data types provided by the Complex data structures derived from
programming language. primitive types.
Complexity Simple and directly represent Can represent multiple values or
single values. relationships between values.
Storage Used to store single data elements Can store multiple data elements or
(e.g., int, float). complex objects.
Usage Ideal for simple operations like Useful for handling large and
arithmetic or comparisons. structured data sets.
Operations Supports direct operations like Requires user-defined operations for
addition, subtraction, etc. tasks like traversal, search.
Memory Fixed and minimal memory based Requires more memory as they store
Requirement on type. complex and multiple elements.
Examples int, float, char, bool. Arrays, linked lists, stacks, queues,
trees, graphs.
Abstraction Operates at a low level of Operates at a higher level of
abstraction. abstraction.
Flexibility Less flexible; size and type are More flexible; can grow dynamically
fixed. (e.g., linked lists).
Usage Context Used for simple data handling and Used in algorithms, data processing,
arithmetic calculations. and complex application logic.

3|Page
Q4 – Define Space Complexity?
Ans -
Space Complexity
Space Complexity refers to the total amount of memory space required by an algorithm
to execute. It includes the memory needed to store the inputs, outputs, and any intermediate
computations during the algorithm's execution. It is typically expressed as a function of the input
size n.
Space complexity plays a critical role in evaluating and optimizing algorithms,
particularly when working with large datasets or embedded systems with limited memory.

Components of Space Complexity

1. Fixed Part:
The memory required for constants, program code, and fixed-sized variables. This part
does not depend on the input size.
2. Variable Part:
The memory required for:
o Inputs (depends on the input size).
o Outputs (if the algorithm generates data).
o Auxiliary/Temporary Variables (used during computation, such as stacks, arrays,
etc.).

How to Measure Space Complexity?

For an input of size n:
• Constant Space: If the memory requirement is constant regardless of nnn, space
complexity is O(1). Example: Swapping two variables.
• Linear Space: If the memory requirement grows linearly with nnn, space complexity is
O(n). Example: Storing an array.
• Logarithmic Space: If memory grows logarithmically with nnn, space complexity is
O(log n ). Example: Recursive binary search.

Q5 - What is Complexity? Explain Space Complexity with Example?

Ans –
Complexity in computer science refers to the measure of the resources an algorithm
requires to solve a problem. The two primary types of complexity are:
1. Time Complexity: The amount of time an algorithm takes to execute as a function of the
input size nnn.
2. Space Complexity: The amount of memory an algorithm uses during execution as a
function of the input size nnn.

Space Complexity

4|Page
Space Complexity specifically measures the total amount of memory space
required by an algorithm to execute successfully. It is crucial for understanding how
efficiently an algorithm uses memory, especially in systems with limited resources.
Components of Space Complexity
1. Fixed Space Requirements:
o Memory for constants, program instructions, and static variables.
o Independent of input size.
2. Variable Space Requirements:
o Memory for the input data structure.
o Memory for output data structure.
o Memory for temporary or auxiliary variables during computation.

The total space complexity is the sum of these fixed and variable requirements.

Example of Space Complexity

Example Code: Simple Swap Operation

void swap(int *a, int *b) {

int temp = *a; // Constant space
*a = *b;
*b = temp;
}
Space Analysis
1. Fixed Space:
o Space for the variable temp: O(1)O(1)O(1).
Total Space Complexity: O(1), as the memory usage is constant regardless of input size.

Q6 - Explain Time Complexity with Example?

Ans –
Time Complexity is a measure of the amount of computational time an algorithm takes
to run as a function of the size of its input nnn.
It quantifies the number of operations or steps executed by an algorithm relative to the
input size.
• Time complexity helps assess the scalability and efficiency of an algorithm.
• It provides a theoretical measure to compare algorithms for different input sizes.
• Understanding and optimizing time complexity is crucial for designing fast and
efficient software.
How to Measure Time Complexity?

1. Count the number of basic operations (e.g., additions, comparisons, assignments).

2. Identify the dominant term that grows fastest as nnn increases.
3. Drop lower-order terms and constants to focus on asymptotic behavior.

5|Page
Big-O Notation
Time complexity is commonly expressed using Big-O notation, which represents the upper
bound of the algorithm's growth rate.
Common Time Complexities:
1. O(1): Constant time – execution time is the same regardless of input size.
2. O(log n): Logarithmic time – execution time increases logarithmically as input size
grows.
3. O(n): Linear time – execution time grows proportionally to input size.
4. O(n²): Quadratic time – execution time grows quadratically as input size increases.
5. O(2ⁿ): Exponential time – execution time doubles with every additional input element.

Example: Analyze Time Complexity

1. Constant Time (O(1))

int getFirstElement(int arr[]) {

return arr[0];
}

• Regardless of the array size, the function always performs one operation.
• Time Complexity: O(1)O(1)O(1).

2.Linear Time (O(n))

int sumArray(int arr[], int n) {
int sum = 0;
for (int i = 0; i < n; i++) {
sum += arr[i];
}
return sum;
}

• The loop iterates nnn times, performing one addition per element.
• Time Complexity: O(n)O(n)O(n).

6|Page
Q7 - Types of Data Structures
Ans –

Types of Data Structures

Data structures are broadly categorized into two types based on their complexity and usage:
Primitive Data Structures and Non-Primitive Data Structures.

1. Primitive Data Structures

These are the basic, built-in data types provided by a programming language. They are the
building blocks for more complex data structures.
Examples:

7|Page
• Integer (int): Stores whole numbers.
• Floating-point (float, double): Stores decimal numbers.
• Character (char): Stores single characters.
• Boolean (bool): Stores true/false values.

2. Non-Primitive Data Structures

These are more complex data structures derived from primitive data types. They are further
divided into Linear and Non-Linear data structures.
A. Linear Data Structures
In linear data structures, data elements are organized sequentially, one after the other.
1. Arrays:
o A collection of elements stored at contiguous memory locations.
o Example: int arr[5] = {1, 2, 3, 4, 5};
2. Linked Lists:
o A collection of nodes where each node contains data and a pointer to the next
node.
o Types: Singly Linked List, Doubly Linked List, Circular Linked List.
3. Stacks:
o A collection of elements with LIFO (Last In, First Out) access.
o Operations: push(), pop(), peek().
4. Queues:
o A collection of elements with FIFO (First In, First Out) access.
o Types: Simple Queue, Circular Queue, Priority Queue, Deque.
B. Non-Linear Data Structures
In non-linear data structures, elements are connected in a hierarchical or interconnected
manner, without a sequential organization.
1. Trees:
o A hierarchical structure consisting of nodes.
o Types: Binary Tree, Binary Search Tree, AVL Tree, B-Trees, etc.
2. Graphs:
o A collection of nodes (vertices) connected by edges.
o Types: Directed Graph, Undirected Graph, Weighted Graph, Unweighted Graph.

Q8 - What are arrays, and how are they represented in memory?

Ans –
An array is a collection of elements, all of the same data type, stored in contiguous memory
locations. It allows efficient access to elements using an index.
Homogeneous: All elements in an array must be of the same data type (e.g., integers, floats,
or characters).
Fixed Size: The size of an array is defined at the time of its declaration and cannot be
changed.
Random Access: Elements can be accessed directly using their index in constant time, O(1).

8|Page
Zero-Based Indexing: In most programming languages, including C, array indexing starts at
0.

Declaration and Initialization in C

• Declaration
data_type array_name[size];

• Example:
int numbers[5];

• Initialization:
int numbers[5] = {1, 2, 3, 4, 5};

• Accessing Elements
printf("%d", numbers[2]); // Accesses the 3rd element (value: 3)

Advantages of Arrays
1. Fast Access: Elements can be accessed in constant time using the index.
2. Efficient Memory Use: Contiguous allocation reduces overhead.
3. Easy Traversal: Loops can iterate through the elements efficiently.

Limitations of Arrays
1. Fixed Size: Once declared, the size of an array cannot be changed.
2. Insertion/Deletion: Adding or removing elements can be inefficient as it may require
shifting elements.
3. Homogeneity: Only supports elements of the same data type.
Memory Representation of Arrays
In memory, arrays are represented as a contiguous block of memory. Each element in
the array is stored at consecutive memory addresses.
Representation in Memory
• If the base address of the array is A and the size of each element S:
o Address of array[i]=A+i×S

Example
Consider an array:
int arr[4] = {10, 20, 30, 40};

Assume:

• The base address of arr is 1000.

• Size of an integer (int) is 4 bytes.
Index Element Address
0 10 1000
1 20 1004

9|Page
Index Element Address
2 30 1008
3 40 1012
Accessing Memory
To access arr[2]:
Address = 1000+2×4=1008

Q9 - Describe Big O notation and how it is used to classify algorithms

Ans –
Big O notation is a mathematical notation used to describe the upper bound of the time
complexity or space complexity of an algorithm in terms of the size of the input data, nnn. It
provides an abstract measure of the algorithm's efficiency, focusing on how it scales as the input
grows.
Big O notation expresses the worst-case scenario, or the maximum time or space
required for an algorithm to run, which helps to understand how an algorithm performs with
large inputs.
1. Simplifying Dominant Terms: When analyzing Big O, only the fastest-growing term is
considered. For example, O(2n+3) simplifies to O(n), and O(n2+n) simplifies to O(n2).
2. Constant Factors Are Ignored: Big O ignores constant factors. For example, an
algorithm with O(3n) time complexity is considered O(n), as the constant factor 3 is
disregarded.
3. Different Algorithms for the Same Problem: Algorithms can have the same output but
differ in efficiency based on their time complexity. A more efficient algorithm will
handle larger input sizes better.

How to Classify Algorithms Using Big O Notation:

• Best Case: Describes the scenario where the algorithm performs the least amount of
work, usually when the input is already in an ideal state.
• Worst Case: Describes the scenario where the algorithm performs the maximum number
of steps. Big O typically focuses on the worst-case scenario.
• Average Case: Describes the expected performance of an algorithm over a range of
inputs, not just the extremes.
Case Example Using Linear Search Algorithm
Linear search scans each element in an array to find a target value.
1. Best Case (O(1)):
• The target element is the first element in the array.
int arr[] = {5, 8, 12, 3}; // key = 5
•
Explanation: The target is found immediately at index 0, requiring only one
comparison.
• Time Complexity: O(1).
2. Worst Case (O(n)):
• The target element is either not present or is the last element in the array.
int arr[] = {5, 8, 12, 3}; // key = 3

10 | P a g e
•
Explanation: The algorithm will scan all nnn elements before finding the key or
concluding that it is absent.
• Time Complexity: O(n)
3. Average Case (O(n)):
• On average, the algorithm checks half of the elements in the array.
int arr[] = {5, 8, 12, 3}; // key = 8
• Explanation: The algorithm will find the key after checking a few elements,
averaging around half of the total array length.
• Time Complexity: O(n)

Q10 - What are some common operations on data structures, and why are they important?

Ans –
Data structures are essential for organizing and manipulating data efficiently. They allow
for the implementation of various algorithms, such as searching, sorting, and traversal. Below
are some of the most common operations on data structures and their importance:

1. Insertion
• Description: Insertion involves adding an element to a data structure. The position of
insertion can vary depending on the data structure type (e.g., beginning, end, or a specific
position).
• Example: Inserting a new element at the end of a list or array.
void insertAtEnd(int arr[], int *size, int value) {
arr[*size] = value;
(*size)++;
}
• Importance:
o Essential for dynamically growing data structures like lists and queues.
o Allows data to be added without disrupting the structure's integrity (e.g., inserting
in a sorted array).

2. Deletion
• Description: Deletion refers to removing an element from a data structure. Like
insertion, the position of deletion can vary depending on the data structure (e.g., first, last,
or specific position).
• Example: Removing an element from an array or stack.
void deleteElement(int arr[], int *size, int index) {
for (int i = index; i < *size - 1; i++) {
arr[i] = arr[i + 1];
}
(*size)--;
}
• Importance:

11 | P a g e
o Necessary for maintaining the size of dynamic data structures like queues, stacks,
and lists.
o Helps remove outdated, redundant, or unnecessary data from the structure.

3. Access/Search

• Description: Searching involves looking for a specific element in a data structure.

Access is often used to retrieve an element based on an index or key.
• Example: Searching for a value in an array or linked list.
int search(int arr[], int size, int key) {
for (int i = 0; i < size; i++) {
if (arr[i] == key)
return i;
}
return -1;
}
• Importance:
o Essential for finding data in structures like arrays, linked lists, trees, or hash
tables.
o Efficient searching directly impacts the speed of algorithms like sorting and
searching, e.g., binary search or hash lookups.
4.Traversal
• Description: Traversal refers to visiting all elements of a data structure (often in a
specific order) to perform an operation like printing or searching.
• Example: Traversing through all elements of an array or tree.
void traverseArray(int arr[], int size) {
for (int i = 0; i < size; i++) {
printf("%d ", arr[i]);
}
}

• Importance:
o Traversal is key for operations such as displaying the contents, applying an
operation to all elements (e.g., sorting, updating), or searching for a specific
condition.
o It is crucial for data structures like trees and graphs, where hierarchical
relationships need to be explored (e.g., in-order traversal for binary trees).

Q11 - What is a stack, and how does it follow the Last-In-First-Out (LIFO) principle?

Ans-
A stack is a linear data structure that follows the Last-In-First-Out (LIFO) principle,
meaning that the most recently added element is the first one to be removed. It operates
similarly to a stack of plates, where you can only add or remove plates from the top of the
stack.
12 | P a g e
Stack Operations:
1. Push: Adds an item to the stack.
2. Pop: Removes the item from the top of the stack.
3. Peek/Top: Returns the item at the top of the stack without removing it.
4. IsEmpty: Checks if the stack has no elements.
How Does a Stack Follow the LIFO Principle?
The Last-In-First-Out (LIFO) principle means that the last element added to the stack
will be the first one to be removed. In other words, the stack "remembers" the order in which
elements were added, and the most recent element always "comes out" first.
This makes stacks ideal for reversing operations, such as undo features in text editors,
or handling recursive function calls in programming languages.
The stack data structure is widely used in algorithms and applications like:
1. Expression evaluation (e.g., evaluating arithmetic expressions using infix, prefix, or
postfix notation).
2. Function calls and recursion (as the stack stores the state of function calls).
3. Backtracking algorithms (e.g., maze solving, depth-first search in trees or graphs).

Code For Stack

#include <stdio.h>
#define MAX 5
int stack[MAX];
int top = -1;
void push(int value) {
if (top == MAX - 1) {
printf("Stack overflow\n");
} else {
stack[++top] = value;
printf("Pushed %d\n", value);
}
}
int pop() {
if (top == -1) {
printf("Stack underflow\n");
return -1;
} else {
printf("Popped %d\n", stack[top]);
return stack[top--];
}
}
int peek() {
if (top == -1) {
printf("Stack is empty\n");
return -1;
} else {

13 | P a g e
return stack[top];
}
}
int isEmpty() {
return top == -1;
}

int main() {
push(10);
push(20);
push(30);
printf("Top element: %d\n", peek());
pop();
printf("Top element after pop: %d\n", peek());
return 0;
}

Q12 - Describe a queue and its First-In-First-Out (FIFO) access method.

Ans –
A queue is a linear data structure that follows the First-In-First-Out (FIFO) principle.
This means that the first element added to the queue will be the first one to be removed, much
like a queue at a ticket counter or a line at a checkout. In other words, the first person to stand in
line is the first one to be served.
A queue operates with two main ends:
• Front: The end where elements are removed (dequeued).
• Rear: The end where elements are added (enqueued).

Queue Operations:
1. Enqueue: Adds an element to the rear of the queue.
2. Dequeue: Removes an element from the front of the queue.
3. Front/Peek: Returns the element at the front without removing it.
4. IsEmpty: Checks if the queue is empty.
5. Size: Returns the number of elements in the queue.

How Does a Queue Follow the FIFO Principle?

The FIFO (First-In-First-Out) principle ensures that the element that is added first is
the first to be removed. This is similar to a queue of customers at a counter, where the first
person in line is the first one to be served.
• When an element is added to the queue, it is placed at the rear.
• When an element is removed, it is taken from the front of the queue.

14 | P a g e
Example:

#include <stdio.h>
#define MAX 5
int queue[MAX];
int front = -1, rear = -1;
void enqueue(int value) {
if (rear == MAX - 1) {
printf("Queue overflow\n");
} else {
if (front == -1) {
front = 0;
}
queue[++rear] = value;
printf("Enqueued %d\n", value);
}
}
int dequeue() {
if (front == -1 || front > rear) {
printf("Queue underflow\n");
return -1;
} else {
int dequeuedValue = queue[front++];
printf("Dequeued %d\n", dequeuedValue);
return dequeuedValue;
}
}
int peek() {
if (front == -1 || front > rear) {
printf("Queue is empty\n");
return -1;
} else {
return queue[front];
}
}
int isEmpty() {
return front == -1 || front > rear;
}
int size() {
if (front == -1 || front > rear) {
return 0;
} else {
return rear - front + 1;
}
}

15 | P a g e
int main() {
enqueue(10);
enqueue(20);
enqueue(30);
printf("Front element: %d\n", peek());
dequeue();
printf("Front element after dequeue: %d\n", peek());
return 0;
}

Q13 - What are the differences between static and dynamic data structures?
Ans –

Feature Static Data Structures Dynamic Data Structures

Memory is allocated at compile
Memory Memory is allocated at runtime, during
time, before the program starts
Allocation program execution.
executing.

The size is fixed and cannot be

The size can change dynamically as the
Size changed during program
program runs.
execution.

Linked lists, Stacks, Queues (using

Examples Arrays, Structures (in C)
pointers), Trees

May waste memory if the More memory-efficient since memory is

Memory allocated size is larger than allocated as needed, but it may incur
Efficiency needed, or may lead to overflow overhead due to frequent allocation and
if the size is too small. deallocation.

Less flexible; the size must be

More flexible; the size can grow or shrink
Flexibility known in advance and cannot
based on the needs of the program.
change.

Typically provides faster access

Access times can vary; traversal is slower
(due to contiguous memory
Access Time due to pointers and non-contiguous
allocation) and constant-time
memory.
access for elements.

Requires extra memory for

No overhead for memory
Overhead pointers/references to manage elements
management.
(e.g., for linked lists, trees).

16 | P a g e
Feature Static Data Structures Dynamic Data Structures
Operations like insertion and Insertion, deletion, and resizing are easier
Operations deletion are harder or less and more efficient since the structure can
efficient because the size is fixed. grow or shrink.

More complex implementation due to the

Easier to implement as the size is
Implementation need to manage dynamic memory
fixed.
allocation.

Suitable when the number of Suitable for scenarios where the number
elements is known in advance of elements is not known in advance or
Usage
and does not change (e.g., static changes frequently (e.g., dynamic data
arrays). collection).

Q14 - Difference between Queue and Stack?

Ans –
Feature Queue Stack
First-In-First-Out (FIFO): The first Last-In-First-Out (LIFO): The last
Order of Access element added is the first one to be element added is the first one to be
removed. removed.
Elements are added at the rear or
Insertion End Elements are added at the top.
back.
Elements are removed from the front
Removal End Elements are removed from the top.
or beginning.
A queue is like a line of people
A stack is like a stack of plates
Real-Life waiting for a bus or a ticket. The first
where you can only add or remove
Analogy person to join the line is the first to
the top plate.
get the bus or the ticket.
Enqueue: Add an element to the rear. Push: Add an element to the top.
Basic Operations Dequeue: Remove an element from Pop: Remove an element from the
the front. top.
Front: Get the element at the front Top: Get the element at the top
Peek Operation
without removing it. without removing it.
Used in scenarios like expression
Used in scenarios like task
evaluation, function call
scheduling, breadth-first search
Use Cases management (recursion), undo
(BFS), resource management, and
operations, and depth-first search
print spooling.
(DFS).

17 | P a g e
Feature Queue Stack
Can be implemented using an array or Can be implemented using an array
Implementation
a linked list with pointers. or a linked list.
Memory Access Non-contiguous memory allocation Non-contiguous memory allocation
Pattern (if implemented with a linked list). (if implemented with a linked list).
Size is dynamic in most Size is dynamic, but may have a
Size
implementations but can have fixed limit if implemented with a static
Management
capacity in array-based queues. array.
The order of elements in a queue is The order of elements in a stack is
Order of
maintained in the sequence in which reversed (i.e., last added is first
Elements
they were added. removed).

Q15 - Explain the difference between an abstract data type (ADT) and a data structure.
Ans –

Aspect Abstract Data Type (ADT) Data Structure

An ADT is a logical description or A data structure is the actual
model of a collection of data and the implementation of an ADT in
Definition
operations that can be performed on memory, using a specific
it, independent of the implementation. programming language.
Focuses on what operations can be Focuses on how the data is
Focus performed on the data and what stored and how operations are
behavior the data should exhibit. implemented.
Does not specify the implementation Specifies the memory layout and
Implementation details. It defines the logical methodology for organizing and
behavior of data and operations. storing data.
Queue (ADT): Defines operations Queue (Data Structure): A
like enqueue (add), dequeue specific implementation of the
Example (remove), peek, without specifying queue ADT, such as a queue
how it’s implemented (e.g., using an implemented using an array or
array or a linked list). a linked list.
Tied to a programming language
Language Independent of any programming
and its constructs, such as arrays,
Independence language. It is a theoretical concept.
linked lists, and pointers.
An abstract concept that specifies A concrete implementation that
Abstraction Level only the behavior and the set of includes both the structure and the
operations. algorithm for each operation.

18 | P a g e
Aspect Abstract Data Type (ADT) Data Structure
Implements the actual logic
Defines operations that must be
behind those operations (e.g., how
Operations performed (e.g., insertion, deletion,
to insert or delete elements, how
access).
to organize them in memory).
Directly involves memory
Memory No concern for memory management.
management (e.g., allocation and
Management It's a high-level design.
deallocation of memory).
Example of ADTs - Stack (ADT): Push, pop, peek
- Array-based Stack
and Data - Queue (ADT): Enqueue, dequeue,
- Linked-list-based Queue
Structures peek

• An Abstract Data Type (ADT) is a high-level, abstract definition of data and the
operations that can be performed on it. It is concerned with what operations are available
and their behavior.
• A Data Structure is the actual implementation of the ADT, describing how the data is
stored, organized, and manipulated in memory, with specific details about algorithms and
memory management.
The distinction is important because it allows for flexibility in the implementation of data
structures while ensuring that the abstract behavior (defined by the ADT) remains consistent.
This separation allows programmers to focus on the logical aspects of data handling (ADT)
while still having the ability to choose the most efficient way to implement these concepts (data
structure).

19 | P a g e