Author’s Profile

MASTERING DATA STRUCTURES UNLOCKED : A DEEP DIVE INTO ESSENTIAL CONCEPTS

MASTERING DATA STRUCTURES
Prof. Ankita Chourasia is an Assistant Professor in Computer Science & Engineering
Department at Medi-Caps University, Indore. She holds a B.E. in Computer Engineering
and an M.E. in Information Technology with honors from IET-DAVV, Indore (MP). She
is currently pursuing her PhD from IET-DAVV, Indore (MP). With over 15 years of
combined teaching and industry experience, her research focus is on Network Security UNLOCKED : A DEEP DIVE INTO ESSENTIAL CONCEPTS
and Machine Learning. She has published numerous research papers on Network
Security, Machine Learning and Deep Learning, and Android apps in addition to her
academic and research accomplishments, she has also a published patent on Machine
Learning in the field of Computer Science & Engineering. She is an educator on
Unacademy online platform also she has written a book on AIML.

Dr. Rakesh Pandit is an Assistant Professor in Computer Science & Engineering

Department at Medi-Caps University, Indore. he holds a M.Sc , M.Phil(CSE) and M.Tech.
in Information Technology with honors from SCS-DAVV, Indore (MP). He is currently
pursuing his PhD in Computer Science and Engineering from Mansarovar Global
University, Bhopal. With over vast 30 years of combined teaching and industry
experience, his research focuses on Cloud Computing, Cloud Security and Operating
System. He has published 30 research papers ;4 patent and 1 international Patent on it.

Dr. Pinky Sadashiv Rane Assistant Professor at Medi-Caps University, Indore, holds a
Ph.D. from APJ Abdul Kalam University Indore, and M.Tech from RKDF Indore. With
over 3 years of Software Development, over 14 years academic experience, she has served
at University of Mumbai Dr. Rane has published 14 papers in reputed journals and
conferences and holds two patents, She is served as Course Writer for preparing Self
Learning Material, Examination committee ( IT Co-ordinator for Examination ,Question
Paper Setter Chairperson, Examiner at University of Mumbai).

Prof. Kailash Kumar Baraskar Prof. Kailash Kumar Baraskar is an Assistant Professor in
the Department of Computer Science & Engineering at Medi-Caps University, Indore,
with a strong background in AI, machine learning, and automation. He holds an M.Tech
in Computer Science & Engineering from MTRI, RGPV Bhopal and a B.E. from UIT-UTD,
BU Bhopal. With over 10 years of combined teaching and industry experience, He has
served as a Faculty Research Fellow at IIT Delhi, focusing on AI and deep learning for
automotive health monitoring, and has worked on industrial automation projects at
NEPA Ltd. With multiple AI and IoT-related patents and research publications, his
expertise includes anomaly detection, deep learning, and proficiency in programming
languages like C, C++, Python, Oracle, and Java.
Prof. Ankita Chourasia
Dr. Rakesh Pandit
Dr. Pinky Sadashiv Rane
Prof. Kailash Kumar Baraskar
SCICRATHUB PUBLICATION
www.scicrafthub.com
[email protected]
MASTERING DATA STRUCTURES UNLOCKED:
A DEEP DIVE INTO ESSENTIAL CONCEPTS

Prof. Ankita Chourasia

Assistant Professor
Department of Computer Science & Engineering,
Medi-Caps University, Indore

Dr. Rakesh Pandit

Assistant Professor
Department of Computer Science & Engineering,
Medi-Caps University, Indore

Dr. Pinky Sadashiv Rane

Assistant Professor
Department of Computer Science & Engineering,
Medi-Caps University, Indore

Prof. Kailash Kumar Baraskar

Assistant Professor
Department of Computer Science & Engineering,
Medi-Caps University, Indore
Title : MASTERING DATA STRUCTURES UNLOCKED: A DEEP DIVE INTO
ESSENTIAL CONCEPTS

Author’s Name : Prof. Ankita Chourasia

Dr. Rakesh Pandit
Dr. Pinky Sadashiv Rane
Prof. Kailash Kumar Baraskar

Published by : Scicrafthub Publication, Thane,

Mumbai, Maharashtra, India, 421605
SCICRAFTHUB PUBLICATION
www.scicrafthub.com
[email protected]

Edition Details : I

ISBN : 978-81-981076-0-2

Month & Year : December, 2024

Pages : 268

Price : 550/-
MASTERING DATA STRUCTURES UNLOCKED :A DEEP DIVE INTO ESSENTIAL CONCEPTS

MASTERING DATA STRUCTURES UNLOCKED:

A DEEP DIVE INTO ESSENTIAL CONCEPTS

1
 MASTERING DATA STRUCTURES UNLOCKED :A DEEP DIVE INTO ESSENTIAL CONCEPTS

Preface

"Mastering Data Structures: From Theory to Practical Implementation" is a comprehensive

guide that bridges the gap between theoretical understanding and practical application of data
structures. The world of computer science is vast, and at its core lies the understanding of how
data is structured, accessed, and manipulated. This book is designed to cater to students,
educators, and professionals who seek to deepen their knowledge of data structures while
gaining insights into real-world implementation. By exploring foundational concepts such as
arrays and linked lists and progressing to more complex structures like trees and graphs, this
book emphasizes both clarity and depth to ensure a thorough comprehension of the material.

Data structures are essential for solving complex problems efficiently. Understanding their
properties and the principles behind them can significantly impact how software solutions are
designed and optimized. In this book, we delve into the mathematical foundations that underpin
these structures, paired with clear, practical examples to illustrate how they function in real-
world scenarios. This dual approach ensures that readers build a strong conceptual foundation
and practical skills simultaneously.

Throughout the chapters, we include coding exercises, detailed illustrations, and projects that
encourage hands-on learning. Readers will find that the material challenges them to apply their
knowledge to build efficient algorithms, reinforcing the theoretical principles discussed.
Whether you are a student beginning your computer science journey or a professional looking
to sharpen your skills, this book is structured to guide you step by step toward mastering data
structures.

The journey from theory to practice is crucial for anyone aiming to excel in software
development. By the end of this book, readers will not only have a firm grasp of various data
structures and their operations but also the confidence to implement and adapt them to solve
complex problems. I hope this resource becomes a valuable part of your learning experience
and contributes meaningfully to your growth as a computer science practitioner.

Your Sincerely,

Prof. Ankita Chourasia

Dr. Rakesh Pandit
Dr. Pinky Sadashiv Rane
Prof. Kailash Kumar Baraskar

2
 MASTERING DATA STRUCTURES UNLOCKED :A DEEP DIVE INTO ESSENTIAL CONCEPTS

Acknowledgement

I would like to express my heartfelt gratitude to everyone who contributed to the completion
of this book. First and foremost, I extend my sincere thanks to my mentors and colleagues
whose invaluable feedback and insights helped shape the content into a comprehensive learning
tool. Their expertise and dedication provided the guidance necessary to elevate this book from
an initial concept to a finished product that meets the needs of learners at all levels.

To the students and peers who participated in reviewing drafts and providing constructive
criticism, your suggestions were instrumental in enhancing the quality, clarity, and depth of the
material. Your perspectives ensured that the content was accessible and aligned with the needs
of diverse readers, making the book more practical and effective as a teaching resource.

A special thanks goes to my family for their unwavering support and encouragement
throughout this journey. Your patience, understanding, and belief in my work kept me
motivated, even during challenging times when balancing work, research, and writing felt
overwhelming. I am deeply grateful for your love and steadfastness.

Finally, I extend my appreciation to the broader computer science community, whose passion
for learning and innovation continues to inspire educators and authors like myself. The
collective pursuit of knowledge and the willingness to share that knowledge for the betterment
of all is what makes this field so rewarding. This book is a testament to collaborative learning,
perseverance, and the shared goal of fostering curiosity and expertise in computer science.
Your Sincerely,

Prof. Ankita Chourasia

Dr. Rakesh Pandit
Dr. Pinky Sadashiv Rane
Prof. Kailash Kumar Baraskar

3
 MASTERING DATA STRUCTURES UNLOCKED :A DEEP DIVE INTO ESSENTIAL CONCEPTS

Table of Content

Chapter Chapter Name and Subheadings Page

Number

1 CHAPTER 1

Foundations of Data Structures 1-15

1.1 Linear vs. Non-Linear Structures

1.2 Memory Management and Efficiency

1.3 Real-World Applications and Case Studies

1.4 Complexity and Algorithm Analysis

1.5 The Role of Persistent Data Structures

1.6 Persistent vs. Non-Persistent Data Structures

2 CHAPTER 2

Algorithms, Flowcharts & Complexity 16-49

2.1 Introduction to Algorithms

2.2 Characteristics of Good Algorithms

2.3 Introduction to Flow Chart

2.4 Fundamentals of Complexity and Types

2.5 Basic Algorithm Analysis

2.6 Practice Programs

4
MASTERING DATA STRUCTURES UNLOCKED :A DEEP DIVE INTO ESSENTIAL CONCEPTS

3 CHAPTER 3

Array, Strings and Linked Lists 50-93

3.1 Arrays: Types, Manipulations, and Applications

3.2 Strings: Types, Manipulations, and Applications

3.3 Pointers and Memory Management

3.4 Linked Lists: Types (Singly, Doubly, Circular,

Circular doubly) and Operations

3.5 Practice Programs

4 CHAPTER 4 94-137
Stacks and Queue
4.1 Stacks: Operations (Push, Pop, Peek, etc.),
Applications, and Implementations

4.2 Queues: Types, Operations, and Applications

5 CHAPTER 5
138-171
Trees and Graphs

5.1 Tree Terminology And Types (Binary, AVL, B-Tree)

5.2 Graph Theory Basics: Terminology, Types, and

Applications

5.3 Traversals and Shortest Path Algorithms

5.4 Practice Programs

5
MASTERING DATA STRUCTURES UNLOCKED :A DEEP DIVE INTO ESSENTIAL CONCEPTS

6 CHAPTER 6
Searching and Sorting 172-193

6.1 Introduction to Searching and Sorting

6.2 Types of Searching

6.3 Sorting: Bubble Sort, Quick Sort, Merge Sort

7 CHAPTER 7
File Handling 194-209

7.1 Concept of Files: Text and Binary

7.2 File Input/Output Functions

7.3 Practices Programs

8 CHAPTER 8
Specialized Data Structures 210-228

8.1 Hashing: Hash Functions and Collision Resolution

Techniques

8.2 Hash Tables: Use Cases in Databases, Caching, and

Memory Management

8.3 Specialized Data Structures

8.4 Practice Programs

9 CHAPTER 9
229-248
Emerging Data Structures

9.1 Data Structures in Distributed and Parallel Systems

9.2 Data Structures for Blockchain and Decentralized

Networks

9.3 Quantum Data Structures and Potential Applications

6
 9.4 Future Challenges and Innovations

9.5 Practice Programs

10
CHAPTER 10
249-254
Case Study

REFERENCES 255-257

7
MASTERING DATA STRUCTURES UNLOCKED :A DEEP DIVE INTO ESSENTIAL CONCEPTS

8
 MASTERING DATA STRUCTURES: FROM THEORY TO PRACTICAL IMPLEMENTATION

CHAPTER 1

Foundations of Data Structures

Data structures are one of the fundamental building blocks of computer science and software
engineering, forming the backbone of efficient programming and data management. From the
simplest arrays to the most complex trees and graphs, each data structure has a unique purpose,
advantages, and limitations. These structures define how information is organized, accessed,
manipulated, and stored in a computer system, making it possible to handle vast amounts of
data efficiently. In the digital age, where information is generated and consumed at
unprecedented rates, a profound understanding of data structures is essential for anyone looking
to excel in computing fields.

Fig 1: Overview of Data Structures

1
 MASTERING DATA STRUCTURES: FROM THEORY TO PRACTICAL IMPLEMENTATION

Understanding the Basics

Fig 2: Differences between arrays and linked lists after their definitions.

The concept of a data structure revolves around organizing data in ways that make it
manageable and accessible. At its core, a data structure is an abstract format for organizing and
storing data, tailored for various operations such as searching, sorting, insertion, and deletion.
Common examples include arrays, linked lists, stacks, queues, trees, and graphs. Each structure
offers unique advantages in specific scenarios: arrays, for instance, provide quick access to
elements based on indices, making them ideal for situations where data needs to be retrieved
sequentially or at random. Linked lists, on the other hand, allow dynamic memory allocation,
making them suitable for applications where memory use must be flexible.

2
1.1 Linear vs. Non-Linear Structures

A Linear Data Structures

Definition: Data elements are arranged sequentially, where each element is connected to its
previous and next element.

Structure Type: Single-level structure.

Traversal: Traversed in a single run (one direction at a time).

Examples:

Array: Fixed-size sequential collection of elements.

Linked List: Dynamically allocated sequence of nodes connected by pointers.

Stack: Follows LIFO (Last In First Out) order.

Queue: Follows FIFO (First In First Out) order.

Applications:

Used in simple data storage, task scheduling, and undo functionalities.

B Non-Linear Data Structures

Definition: Data elements are arranged hierarchically or in interconnected networks.

Structure Type: Multi-level structure (e.g., tree or graph).

Traversal: Requires multiple runs or complex algorithms to traverse all elements.

Examples:

Tree Structure: Hierarchical relationships (e.g., parent-child).

Graph Structure: Network-based relationships with vertices and edges.

Applications:

Used in complex systems like database indexing, AI, image processing, and social networks.

1.2 Memory Management and Efficiency

Memory is a finite resource, and efficient memory management is crucial for high-performance
applications. Data structures play a significant role in managing memory effectively. Arrays,
for instance, require contiguous memory allocation, which can be limiting in scenarios where
3
memory is fragmented. Linked lists address this issue by using pointers, allowing elements to
be stored in non-contiguous locations. However, they introduce additional memory overhead
due to pointers. More complex structures like hash tables and trees are designed to optimize
space utilization while ensuring rapid access to data. Hash tables use a concept called hashing
to assign unique keys to each data element, making search operations extremely fast. Trees,
especially balanced trees like AVL and Red-Black trees, maintain a specific structure that
prevents them from becoming skewed, thereby ensuring that operations remain efficient even
as the dataset grows.

1.3 Real-World Applications and Case Studies

Data structures are the backbone of various real-world applications. In databases, for example,
B-trees and B+ trees are commonly used for indexing, enabling efficient data retrieval. Hash
tables find extensive use in caching, where quick access to recently used information is
essential. In networking, graph theory aids in the optimization of routing paths, enhancing data
flow efficiency. Social media platforms rely heavily on graphs to map connections between
users, facilitating complex queries that can suggest friends or recommend content based on
shared interests. By mastering these data structures, developers gain the skills needed to design
systems that are not only functional but also highly efficient and scalable.

1.4 Complexity and Algorithm Analysis

When choosing the right data structure, understanding the computational complexity of various
operations is key. Complexity analysis, especially time and space complexity, determines how
well a data structure will perform under different conditions. In scenarios where large datasets
need to be processed quickly, selecting an efficient structure can make the difference between
a program that performs smoothly and one that becomes sluggish. Stacks and queues, for
example, operate under constant time complexity for insertion and deletion, while tree-based
structures can vary in complexity based on their balance. Balanced trees maintain a time
complexity of

𝑂(log⁡𝑛)
O(logn) for search, insertion, and deletion, which is considerably faster than an unbalanced
tree, which can degrade to linear complexity in the worst case.

1.5 The Role of Persistent Data Structures

Persistent data structures have become increasingly important with the advent of applications
that require data immutability, such as blockchain and version control systems. Unlike
4
traditional data structures, which lose their previous state when modified, persistent data
structures retain past versions of themselves. This feature is vital for applications where
historical data needs to be preserved. In a blockchain, for example, each block references the
previous one, creating an immutable ledger that records every transaction ever made. Similarly,
in version control systems, persistent data structures allow for the creation of branching
histories, enabling developers to track changes over time and revert to previous versions if
needed.

Table 1 : Comparison of Linear and Non-Linear Structures

5
  Linear Structures (Arrays, Linked Lists)

Fig 3 : Array vs. Linked List: Structural Comparison

Arrays and linked lists are two foundational types of linear data structures in computer science,
each with its distinct mode of operation and use case scenarios. Arrays are a staple in
programming, providing a way to allocate a block of fixed-size contiguous memory locations
that can be efficiently accessed via indices. This structure is particularly advantageous when it
comes to random access of elements, as the time complexity is O(1) for accessing any element
if the index is known. However, arrays are not without limitations; they have a fixed size, which
means that the array's capacity needs to be defined upfront and cannot be changed dynamically
without creating a new array and copying over the data. This can lead to inefficiencies and
increased computational overhead, especially in scenarios where the data size might not be
known beforehand or can change dynamically. Arrays are immensely useful in situations
requiring frequent access to elements but infrequent addition and removal of elements, such as
in storing data for applications that do not require modification of the data set, like a static
lookup table or storing the RGB values of a pixel in an image.

Linked lists, on the other hand, offer dynamic sizing with elements known as nodes connected
through pointers, which makes them particularly useful for applications where the data

6
structure needs to frequently expand or shrink. Unlike arrays, linked lists do not require
contiguous memory locations; each node contains its data and a reference (or link) to the next
node, making it easy to add or remove nodes without reallocating the entire data structure. This
makes linked lists an excellent choice for implementations where memory utilization efficiency
and flexibility are more critical than speed of access, such as in implementing queues, stacks,
and other abstract data types where elements are continuously inserted and removed. However,
the major drawback of linked lists is the increased time complexity for accessing elements, as
nodes must be accessed sequentially starting from the head of the list. This can be mitigated by
using more complex variations like doubly linked lists, which allow backward traversal as well,
or circular linked lists that loop back on themselves for continuous cycling through the data.
Despite their slower element access time, linked lists are invaluable in scenarios requiring
adaptable memory usage and frequent insertion and deletion of elements, making them
indispensable for certain types of algorithmic implementations and applications.

Feature Array Linked List

Memory Allocation Contiguous Non-contiguous

Size Fixed Dynamic

Element Access O(1) O(n)

Insertion/Deletion O(n) O(1) at ends

Memory Overhead Low Higher due to pointers

Cache Performance Better Poorer

7
Non-linear data structures such as trees and graphs are fundamental components in the field of
computer science, used for organizing information in a way that facilitates efficient retrieval,
insertion, and deletion operations. Trees, a type of hierarchical data structure, consist of nodes
connected by edges with a designated node known as the root. Each node in a tree can have
zero or more child nodes, which branches out further into more nodes, creating a branching
structure. This makes trees especially useful for scenarios where data naturally forms a
hierarchy, such as file systems or organizational structures. Binary trees, where each node has
at most two children, are particularly common, with special forms like binary search trees
(BSTs) enabling fast lookup, addition, and deletion operations, all of which are essential for
efficient performance in search applications and maintaining sorted data.

Graphs, on the other hand, are more generalized than trees and can represent a set of objects
(vertices) along with their interconnections (edges). Unlike trees, graphs can have cycles,
meaning a sequence of edges and vertices wherein a vertex is reachable from itself. Graphs can
be either directed or undirected, where edges in directed graphs have a direction associated
with them, indicating a one-way relationship. This makes graphs ideal for representing complex
relationships and networks such as social connections, logistical networks, and web links.
Algorithms to traverse these structures, such as Depth-First Search (DFS) and Breadth- First
Search (BFS), allow for comprehensive analysis and manipulation of data. For instance, these
algorithms can be used to detect cycles, find the shortest path between nodes, and check
connectivity within the graph, making them incredibly powerful tools in network analysis and
routing.

The versatility and utility of non-linear data structures like trees and graphs lie in their ability
to adapt to various real-world data sets and problems. Trees are particularly valuable in
applications requiring hierarchical relationships and efficient, ordered storage, such as in
database indexing, where the ability to quickly traverse and retrieve data is critical. Graphs are
indispensable in scenarios requiring the representation of complex networked data, such as in
the case of the internet's structure, where each webpage can be seen as a vertex and links as
edges. Additionally, understanding and implementing algorithms for these structures are
critical in optimizing performance for applications ranging from route planning in GPS systems
to predicting user behavior in social media platforms. These structures not only provide a way
to store data but also facilitate complex operations and queries, which can be executed with
significant efficiency, demonstrating their profound impact on modern computing practices.

8
  Comparative Analysis of Linear vs. Non-Linear Data Structures

Fig 4: Classification of Linear and Non-Linear Data Structures

Linear and non-linear data structures serve as the backbone for data storage and manipulation
in programming. Linear structures like arrays, stacks, and queues organize data in a sequential
manner, allowing for easy access and manipulation based on a linear sequence. For instance,
arrays store elements in contiguous memory locations, which facilitates quick access using
indices but can be limiting when the size of the dataset needs to dynamically change. On the
other hand, stacks and queues, while also linear, operate on the principles of "Last In, First
Out" (LIFO) and "First In First Out" (FIFO) respectively. These properties make stacks ideal
for applications such as recursion programming and undo functionalities in software, whereas
queues are essential in scenarios requiring a natural ordering of operations, like print spooling
or task scheduling in operating systems.

Non-linear data structures, such as trees and graphs, provide a more flexible approach to data
management compared to their linear counterparts. Trees allow for hierarchical data
representation, which is crucial in scenarios like maintaining a sorted stream of data as seen in
binary search trees. This hierarchy enables operations such as searching, inserting, and deleting
more efficiently than linear data structures when dealing with large datasets. When comparing
performance, linear data structures generally provide faster access for simple and small datasets
due to their straightforward nature, but they fall short in scalability and handling complex data
operations as efficiently as non-linear structures. Non-linear structures, although sometimes
more complex to implement and understand, offer superior flexibility and efficiency in
9
operations involving large and complex datasets. They are optimized for querying large datasets,
hierarchical data manipulation, and complex networked data scenarios.

1.6 Persistent vs. Non-Persistent Data Structures

Non-Persistent Data Structures are the more common form used in everyday programming.
These structures do not maintain their state across different operations or sessions; once an
operation is completed, any changes to the data structure are finalized, and the previous states
are not directly accessible. Examples include traditional stacks, queues, and linked lists used
in application memory during runtime. These structures are optimized for speed and efficient
memory use during their active period but do not inherently support retrieval of previous
versions of the data after modifications. This makes them ideal for use cases where historical
data states are not required or are managed through external mechanisms, such as transaction
logs in databases.

Persistent vs. Non-Persistent Data Structures

10
Persistent Data Structures, on the other hand, allow access to past versions of themselves
even after modifications. This does not necessarily mean that they are stored permanently on
disk; rather, persistence refers to the ability of the structure to maintain multiple versions of its
state over time. Persistent structures are crucial in applications where it is necessary to revert
to or analyze previous states without needing to undo all subsequent changes. Functional
programming languages often utilize persistent data structures due to their ability to handle
data immutably. A simple example is a persistent tree, where each modification—such as
adding or removing a node—results in a new version of the tree, while keeping the old versions
accessible and intact. This feature is particularly valuable in concurrent programming and
versioned databases where multiple threads or processes may need to access data states at
different times without conflict.

The distinction between persistent and non-persistent structures significantly impacts software
design and performance. Non-persistent structures are typically faster and more memory-
efficient for tasks where historical data is not needed since they do not require additional
mechanisms to keep old versions available. This makes them well-suited for high-performance,
real-time applications where the overhead of maintaining versions is undesirable. On the
contrary, persistent structures, while generally slower due to the overhead of managing multiple
states, provide invaluable benefits in terms of error recovery, undo functionalities, and complex
data transaction management in multi-threaded environments. This trade-off between
performance and flexibility is a critical consideration when architects and developers choose
the appropriate data structure for their applications. Understanding the specific requirements
and constraints of an application's data handling can guide the choice between using persistent
and non-persistent structures to optimize both functionality and efficiency.

Persistent data structures in programming provide a different flavor of persistence by

maintaining previous versions of themselves as updates are made. These structures do not
overwrite their states; rather, they allow operations to yield new versions of the structure, with
all previous states remaining intact and accessible. This immutability aspect makes persistent
data structures particularly valuable for functional programming, where side effects are
avoided, and each state is kept trackable and reversible. An example of this is the persistent
tree, which, when an element is inserted or removed, creates a new version of the tree rather
than altering the existing tree. This functionality allows programmers to revert to any previous
state of the tree without needing to reverse the operations manually.

11
  Use Cases for Persistent Data Structures

Persistent data structures are widely used in applications where maintaining a history of
previous states is critical. One of the most prominent examples is in version control systems
such as Git, where each modification to the codebase creates a new version or “snapshot.”
Persistent data structures allow developers to track changes over time, revert to previous
versions if errors are introduced, and review the history of updates collaboratively without
affecting the current state. By storing each version as a new immutable snapshot, these systems
avoid overwriting existing code and ensure that every historical change remains accessible for
future reference, thus maintaining a full and traceable history.

Another key use case for persistent data structures is in functional programming languages,
where immutability is a core principle. In functional languages like Haskell and Clojure, data
structures are typically immutable by default, meaning that operations do not change the
original structure but instead create new instances. Persistent data structures fit perfectly here
as they inherently support immutability while allowing new versions to be created without
affecting previous states. This is especially useful for concurrent programming, where multiple
processes or threads can access the same data structure without causing data conflicts or race
conditions. Since each version remains intact, processes can work independently on different
versions of the data structure, ensuring data integrity and facilitating safer concurrent
operations.

Applications requiring undo or rollback functionalities are also ideal candidates for
persistent data structures. For example, text editors, drawing applications, and spreadsheet
programs often allow users to revert to previous states with an “undo” function. Persistent data
structures enable this by preserving each state as modifications are made, so the application

can easily revert to any past version without having to sequentially reverse all changes.
Similarly, databases that support multiversion concurrency control (MVCC) rely on persistent-
like data structures to manage multiple snapshots of data, allowing transactions to work
independently and consistently without interfering with each other. This way, users can view
data as it was at a particular point in time, providing a stable and reliable experience even in
high-concurrency environments.

12
  Overview of Non-Persistent Data Structures

Non-persistent data structures are those that do not retain previous states after modifications,
meaning each operation directly alters the current structure. This characteristic is typical of
data structures like arrays, stacks, queues, and linked lists, which are commonly used in
procedural and object-oriented programming languages. These structures prioritize speed and
efficiency, making them ideal for scenarios where rapid data manipulation is more important
than retaining historical data. For example, in a stack, when elements are pushed or popped,
the stack only reflects the most recent changes without keeping prior versions of the stack. This
makes non-persistent structures simpler and faster for scenarios where historical state tracking
is not required, such as temporary data handling or quick calculations in algorithm
implementations.

One of the primary advantages of non-persistent data structures is their efficiency in terms of
memory and processing time. Since they do not create new versions with each modification,
they are more memory-efficient, as only one version of the structure needs to be stored in
memory at any given time. This makes them suitable for applications that need real-time
performance and are constrained by memory, such as embedded systems or mobile applications
where resources are limited. Additionally, the ability to directly overwrite data in these
structures allows for faster execution of operations, as there’s no need to allocate memory for
new versions or manage multiple instances of the same structure. This advantage is crucial for
applications that require high throughput or where data changes are frequent and do not need
to be reverted, such as buffering in audio/video streaming and rapid sorting of elements in
search algorithms.

13
MCQ:

Which of the following is NOT a data structure?

(A) Array
(B) Stack
(C) Algorithm
(D) Queue
Answer: (C)

What is the time complexity to access an element in an array?

(A) O(1)
(B) O(n)
(C) O(log n)
(D) O(n²)
Answer: (A)

Which of these is a non-linear data structure?

(A) Linked List

(B) Graph
(C) Array
(D) Stack
Answer: (B)

In a linear data structure, the elements are:

(A) Arranged in a hierarchical order

(B) Connected in a random manner
(C) Stored in sequential order
(D) None of the above
Answer: (C)

14
Which of the following is an example of a non-linear data structure used to represent
relationships?

(A) Linked List

(B) Graph
(C) Array
(D) Stack
Answer: (B)

15
 CHAPTER 2

Algorithms, Flowcharts & Complexity

2.1 Introduction to Algorithms:

In computer science, an algorithm is a set of well-defined instructions or a finite sequence of

steps designed to accomplish a particular task or solve a specific problem. Algorithms are
foundational in computing, guiding the operations that enable software to function efficiently
and effectively. They range from simple tasks, like sorting a list of numbers, to complex
procedures for processing massive datasets, training machine learning models, or making
predictions. An algorithm can be viewed as a recipe that provides precise steps for achieving
an outcome. For example, if making a cup of tea, an algorithm would include steps like boiling
water, adding tea leaves, steeping for a specific time, and straining. Each step is clear, finite,
and directed toward a goal. In computer science, algorithms are similarly precise: they operate
on data, process it, and generate an output, ideally using minimal resources.

Defining an Algorithm

Fig 5 : Definition of Algorithm with Flowchart

In simple terms, an algorithm is a procedure or formula for solving a problem. It consists of a

series of steps that are followed to produce an outcome or perform a function. Each step in an

16
algorithm is clear and unambiguous, designed to ensure that the task is completed in a logical
and orderly fashion. Algorithms are used in every aspect of computer science and software
development, from simple data manipulation to complex decision-making. They are also the
basis of mathematical problem-solving, simulations, and artificial intelligence models. An
algorithm, therefore, is both a tool for computation and a logical framework for structuring data
and instructions.

For example, consider an algorithm to find the maximum value in a list of numbers. The steps
could include: (1) setting the first value as the maximum, (2) comparing each subsequent
number to the current maximum, and (3) updating the maximum if a larger number is found.
By following these steps, the algorithm achieves its objective of finding the largest number in
the list. This straightforward yet effective approach showcases the importance of defining each
step in an algorithm and ensuring that it leads to a clear result. Whether for simple tasks like
finding the largest number or complex functions like sorting, algorithms serve as precise
blueprints that drive computer programs.

2.2 Characteristics of Good Algorithms

Fig 6 : Characteristics of an Algorithm

A good algorithm possesses specific characteristics that differentiate it from average or

inefficient ones. These characteristics ensure that the algorithm is not only functional but also

17
effective and reliable in solving problems. Key characteristics of a well-designed algorithm
include clarity, efficiency, definiteness, finiteness, input-output specifications, and generality.

 Clarity

One of the most important characteristics of a good algorithm is clarity. A good algorithm
should be easy to understand, with each step clearly defined and unambiguous. This
characteristic ensures that anyone reading the algorithm can follow it logically without
confusion. For instance, if an algorithm is designed to calculate the average of a list of numbers,
it should have steps like adding all numbers, counting them, and dividing the sum by the count.
Clarity in algorithms is crucial, particularly in collaborative environments where multiple
programmers work on or review code. A clear algorithm minimizes misinterpretation, enhances
maintainability, and simplifies debugging.

 Efficiency

Efficiency is another critical attribute of a well-designed algorithm. Efficiency refers to how

quickly and effectively an algorithm completes its task using minimal resources. In algorithm
analysis, efficiency is discussed in terms of time complexity and space complexity. Time
complexity measures how the running time of an algorithm increases relative to the input size,
typically represented in Big O notation (e.g., O(n) for linear complexity or O(log n) for
logarithmic complexity). Space complexity quantifies the memory an algorithm requires to
execute. For instance, different sorting algorithms have varying efficiencies; a bubble sort, with
O(n^2) time complexity, is less efficient than a merge sort, which operates at O(n log n).
Efficient algorithms are essential in applications where large datasets are processed, such as
machine learning and data mining, as they significantly impact performance and resource
usage.

 Definiteness

Definiteness is another key characteristic of a good algorithm. Each step in the algorithm should
be explicitly defined, leaving no room for doubt or ambiguity. Definiteness ensures that each
action is executable without further clarification, maintaining consistency across different
implementations or platforms. For instance, an algorithm for checking if a number is prime
should have specific steps for dividing the number by possible divisors and returning a clear
result, either true or false, based on whether divisors are found. This definiteness ensures that

18
any programmer implementing the algorithm can produce the correct result, contributing to the
algorithm’s reliability.

 Finiteness

Another essential feature of a good algorithm is finiteness. A good algorithm should have a
finite number of steps and reach an end after a specific number of operations, ensuring it does
not enter an infinite loop. Finiteness is critical because an algorithm that never terminates is
impractical for real-world applications. For example, a loop to sum numbers in an array should
have a clear termination condition, typically when it has iterated through each element.
Ensuring finiteness is especially important in recursive algorithms, where each call to the
function must approach a base case to prevent infinite recursion.

 Input and Output

Input and output specifications are integral to a good algorithm’s design. A well-defined
algorithm should specify what data it expects as input and what it will produce as output. For
example, an algorithm designed to find the largest number in an array should clearly state that
it requires an array of numbers as input and will return the largest number as output. This input-
output clarity is essential for correct implementation, ensuring that the algorithm is used
appropriately within larger programs. Moreover, the algorithm should handle a variety of input
scenarios, including edge cases like empty arrays, to prevent unexpected errors.

 Generality

A hallmark of an effective algorithm is generality, meaning the algorithm should handle a broad
range of inputs, not just a few specific cases. For instance, an algorithm that sorts numbers
should work for any list of numbers, regardless of size or ordering. Generality ensures that the
algorithm is robust and adaptable, making it applicable to a wide range of problems and
datasets. Generality also extends to scalability, where a good algorithm should perform
efficiently as the input size grows, ensuring viability for larger datasets.

 Examples of Well-Designed Algorithms

Examples of algorithms abound across various domains, illustrating these characteristics in

action. Sorting algorithms like quicksort and mergesort are classic examples that demonstrate
efficiency and generality. Quicksort, with an average-case time complexity of O(n log n), is
widely used due to its speed and efficiency for large datasets, while mergesort is known for its

19
stability and consistent performance despite requiring more space. Another example is the
search algorithm like binary search, which operates with a logarithmic time complexity of
O(log n) and efficiently finds elements within a sorted array by repeatedly dividing the search
interval in half.

In more complex applications, Dijkstra’s shortest path algorithm demonstrates the power of
well-designed algorithms. Dijkstra’s algorithm, widely used in network routing and mapping
applications, finds the shortest path between nodes in a weighted graph. Its clear, well-defined
steps allow it to handle large datasets and produce accurate results for applications like GPS
navigation, where identifying the shortest or fastest route is crucial. Dijkstra’s algorithm
exemplifies clarity in its approach, efficiency in resource use, and generality in its applicability
to various graph-based problems.

Example 1: Finding the Maximum Number in an Array

One of the simplest and most common algorithms is to find the maximum number in an array
of integers. This algorithm involves iterating through the array and keeping track of the largest
value encountered so far. This algorithm is widely used in scenarios where identifying the
highest or most significant value is essential, such as finding the top scorer in a list of scores
or identifying the highest temperature in a dataset.

Algorithm Definition: The algorithm starts by assuming the first element as the maximum and
then iterates through each element in the array, comparing it with the current maximum. If an
element is greater than the current maximum, the maximum is updated. At the end of the
iteration, the current maximum holds the largest number in the array.

Step 1: Initialize the maximum as the first element in the array.

Step 2: For each subsequent element in the array, compare it with the current maximum.

Step 3: If the current element is greater than the maximum, update the maximum to this new
value.

Step 4: Continue until all elements have been checked.

Step 5: Return the final value of the maximum.

Example Execution: Given an array [3, 7, 2, 9, 5], the algorithm would start with 3 as the
maximum, then update to 7, and finally to 9. The final maximum, 9, is returned as the largest
number in the array.
20
Example 2: Calculating the Sum of Numbers from 1 to N

This algorithm calculates the sum of all numbers from 1 to a given integer N. It is a simple yet
powerful algorithm, often used as a practice problem in learning loops and arithmetic
operations. This sum calculation appears in various applications, such as determining the total
amount when calculating incremental values or summarizing data over a sequence of numbers.

Algorithm Definition: This algorithm either uses a loop to add each number from 1 to N or
applies the mathematical formula for summation: Sum = N * (N + 1) / 2, which directly
calculates the sum without iteration.

Step 1: Initialize the sum to 0.

Step 2: For each integer from 1 to N, add the integer to the sum.

Step 3: Continue until all numbers up to N have been added.

Step 4: Return the final sum.

Example Execution: For N = 5, the sum is calculated by adding 1 + 2 + 3 + 4 + 5, resulting in

a sum of 15. Alternatively, using the formula, the result would also be 5 * (5 + 1) / 2 = 15.

Example 3: Checking for a Prime Number

Another fundamental algorithm is determining whether a number is prime. A prime number is

a natural number greater than 1 that has no positive divisors other than 1 and itself. Prime-
checking algorithms are essential in cryptography, random number generation, and
mathematical computations where factors are considered.

Algorithm Definition: This algorithm checks if a number has any divisors other than 1 and
itself. By iterating through potential divisors up to the square root of the number, it can
efficiently determine whether the number is prime.

Step 1: If the number is less than or equal to 1, return false (not prime).

Step 2: For each integer i from 2 up to the square root of the number, check if i divides the
number without a remainder.

Step 3: If any divisor is found, return false.

Step 4: If no divisors are found, return true (the number is prime).

21
Example Execution: For the number 11, the algorithm checks divisors 2 and 3. Since neither
divides 11 evenly, it confirms 11 as a prime number.

Example 4: Reversing a String

String manipulation is a common programming task, and reversing a string is a classic example.
This algorithm involves rearranging the characters in a string so that they appear in reverse
order. This operation is frequently encountered in tasks related to data formatting, text
processing, and problem-solving exercises that involve manipulating text.

Algorithm Definition: To reverse a string, the algorithm swaps characters from the beginning
and end, moving towards the center, until the entire string is reversed.

Step 1: Initialize two pointers, one at the start of the string and the other at the end.

Step 2: Swap the characters at the start and end pointers.

Step 3: Move the start pointer forward and the end pointer backward.

Step 4: Continue until the start pointer is greater than or equal to the end pointer.

Step 5: Return the modified string.

Example Execution: For the string "hello", the algorithm swaps characters to form "olleh".

Example 5: Linear Search in an Array

Linear search is a basic algorithm for finding a specific element within an array. It involves
checking each element sequentially until the target is found or the entire array has been
searched. This algorithm is simple but effective in cases where the dataset is unsorted or small.

Algorithm Definition: Starting from the beginning of the array, the algorithm compares each
element with the target. If a match is found, it returns the index; otherwise, it continues until
the end.

Step 1: For each element in the array, check if it equals the target.

Step 2: If a match is found, return the index of the element.

Step 3: If no match is found by the end of the array, return -1.

Example Execution: For an array [10, 23, 15, 7] and target 15, the algorithm returns index 2
22
after finding 15 at that position.

Example 6: Factorial of a Number

Calculating the factorial of a number is a popular algorithm in mathematical programming. The

factorial of a number N (denoted N!) is the product of all positive integers from 1 to N. Factorial
calculations are commonly used in statistics, probability, and combinatorics.

Algorithm Definition: The algorithm calculates the factorial of N by multiplying all numbers
from 1 to N. Alternatively, recursive algorithms can also be used, where N! = N * (N-1)!.

Step 1: Initialize the result to 1.

Step 2: For each integer from 1 to N, multiply the result by the current integer.

Step 3: Continue until all integers are multiplied.

Step 4: Return the final result.

Example Execution: For N = 4, the result is calculated as 1 * 2 * 3 * 4 = 24.

Simple algorithms, such as finding the maximum in an array, calculating sums, checking for
primes, reversing strings, searching arrays, and calculating factorials, are essential in
programming. These algorithms provide a strong foundation for understanding algorithm
design, as they emphasize clarity, definiteness, and step-by-step problem-solving. Mastering

these basic algorithms allows programmers to tackle more complex problems and lays the
groundwork for effective coding practices and efficient solutions in real-world applications.

2.3 Introduction to Flowcharts:

Flowcharts are visual representations of the steps involved in a process or algorithm, using
standardized symbols to depict actions, decisions, inputs, outputs, and other operations. They
provide a clear, organized, and easy-to-understand layout for conveying the logical sequence
of tasks, making flowcharts an essential tool in both software development and process
management. Flowcharts help designers and developers conceptualize, organize, and
communicate the structure of algorithms or workflows before diving into code or process
implementation. By providing a visual breakdown, flowcharts improve understanding, reduce
complexity, and facilitate collaboration. They are especially valuable in programming, where
they can help map out complex logic structures, such as loops and conditional branches, in a

23
straightforward way. In addition to programming, flowcharts are widely used in business,
manufacturing, project management, and various fields where processes and workflows need
to be visualized.

Flowcharts use a set of standardized symbols, each representing a different type of action or
decision in the process. These symbols are crucial to maintaining clarity and consistency across
different diagrams, as they provide a universal language that enables anyone to interpret the
flowchart without extensive explanation. Understanding these symbols is the first step in
creating an effective flowchart, as they establish the structure and flow of information in the
process being diagrammed. Below are some of the most commonly used flowchart symbols
and explanations of their roles.

 Basic Flowchart Symbols

Fig 7: Common Flowchart Symbols and Their Meanings

24
  Start/End Symbol

The Start/End symbol is represented by an oval or rounded rectangle and marks the beginning
and end of a process. It is the first and last symbol in any flowchart, clearly indicating where
the process starts and where it concludes. In the context of an algorithm or program, the start
symbol denotes the initial point of execution, while the end symbol signifies the final outcome
or completion of the process. This symbol is essential for defining the boundaries of a
flowchart, making it clear when the process begins and ends.

 Process Symbol

The Process symbol is a rectangle used to represent any single operation, action, or calculation
that takes place within the process. It typically contains a description of the specific task or step
being performed, such as "Add two numbers" or "Sort the array." This symbol is one of the
most frequently used in flowcharts because it captures the core actions that drive the process
forward. In programming, each rectangle might correspond to a line or block of code, while in
business or manufacturing workflows, it might indicate tasks such as "Approve document" or
"Check inventory." The process symbol is crucial for breaking down complex procedures into
manageable steps, ensuring each action is visually represented.

 Input/Output Symbol

The Input/Output symbol, represented by a parallelogram, is used to denote the points where
data is either received as input or presented as output. For instance, in a program, inputs may
include entering numbers, selecting options, or gathering information, while outputs could be
displaying results, printing data, or writing information to a file. The Input/Output symbol is
essential for any algorithm or process where data is exchanged or displayed to the user, as it
helps distinguish between operations that handle data versus those that merely process it. In a
flowchart for a user login system, the Input/Output symbol could represent the step where the
user inputs their username and password. It’s an important element because it signals the stages
where interaction with external data or the user occurs, highlighting the process’s dependency
on or impact from these exchanges.

 Decision Symbol

The Decision symbol, depicted as a diamond shape, represents any point in the process where
a decision is required, typically involving a yes/no, true/false, or similar binary choice. This
symbol is vital in flowcharting because it introduces branching, allowing for multiple possible
paths based on conditions. In programming terms, it often corresponds to if statements, loops,
25
or conditions that influence the flow of execution. For example, in a flowchart to check if a

number is even or odd, the Decision symbol might contain the question "Is the number divisible
by 2?" with two paths emerging: one for "yes" (even) and one for "no" (odd). Decision symbols
are crucial for mapping out processes that require conditional logic, allowing the flowchart to
reflect the multiple outcomes that may arise from different conditions. By enabling branching,
the decision symbol adds flexibility and detail to the process, accommodating more complex
scenarios and providing a comprehensive view of possible pathways.

 Connector Symbol

The Connector symbol, typically represented by a circle or small oval, is used to connect
different parts of a flowchart when they are too far apart on the page or when the chart becomes
too complex for a straightforward top-to-bottom arrangement. Connectors are labeled with
letters or numbers to show where the flow continues, helping maintain readability and
coherence in large flowcharts. Connectors are particularly useful in complex algorithms with
multiple branches, where parts of the flowchart need to loop back or jump forward without
crossing lines or causing visual clutter.

 Flow Line

The Flow Line is a simple arrow that connects the symbols and shows the sequence in which
the steps occur. Flow lines are essential because they guide the viewer’s eye through the
flowchart, ensuring the process can be followed in the correct order. Arrows indicate the
direction of the flow, leading from one step to the next and illustrating how each task or
decision connects to the following one. For instance, in a flowchart for processing an online
order, flow lines would connect each step from "Receive Order" to "Process Payment," then to
"Ship Order." Flow lines are fundamental to the readability of a flowchart, as they establish a
clear path through the process. In cases of looping or conditional paths, flow lines may lead
back to previous steps or to alternative branches, further adding depth to the process’s
representation.

26
  Creating Flowcharts for Simple Problems

Fig 8 :Decision-Making Flowchart Example

This image illustrates a decision-making flowchart, a graphical representation of a process or

workflow that involves decision points. The flow begins with a starting point, progresses
through decision nodes (indicated by diamond shapes), and continues based on specific
conditions or choices, which are represented by labeled arrows leading to different steps. The
flowchart also highlights subsequent actions or processes depending on the outcomes of the
decisions, showcasing a clear, structured path for various scenarios. This visual tool is often
used for problem-solving, project planning, or illustrating workflows to ensure clarity and
efficiency in decision-making processes.

 Flowchart Examples and Practice

Example 1: Flowchart for Finding the Maximum of Two Numbers

Consider a problem where we need to determine which of two given numbers is larger. This
task is straightforward and involves a comparison, making it an ideal candidate for practicing
flowchart design. The flowchart begins with a start symbol, followed by an Input/Output
symbol to receive the two numbers as input. A Decision symbol then compares the two
numbers. If the first number is greater, the flowchart proceeds to a Process symbol labeled
“Display First Number as Maximum.” If not, it goes to a different Process symbol labeled
“Display Second Number as Maximum.” The flowchart ends after displaying the result. This
simple example demonstrates how decision-making can be represented visually, clarifying the
27
process of comparing values and selecting an outcome based on conditions.

Facebook Login Process Flowchart

This flowchart illustrates the Facebook login process, detailing the sequence of actions
required to access a user account. It begins with the user entering the website URL, leading to
the homepage where they input their email ID and password. A decision point then evaluates
the correctness of the login credentials. If the credentials are valid, the account is displayed,
completing the process. If not, the user is directed to an error message and prompted to re-enter
their details. This flowchart highlights a logical step-by-step approach to ensure secure and
efficient user authentication.

Example 2: Flowchart for Calculating Factorial of a Number

Calculating the factorial of a number involves multiplying all positive integers from 1 up to the
given number

28
 N. This is a common practice problem for loops, and its flowchart can illustrate the steps in a
looping process. The flowchart starts with an Input/Output symbol to receive the number

N, followed by a process to initialize a variable factorial to 1. A loop then iterates from 1 to

N, multiplying factorial by each integer in turn. This loop structure is represented by a Decision
symbol that checks if the loop has reached

N. After the loop completes, the flowchart proceeds to display the final factorial value,
followed by an end symbol. This example demonstrates how repetitive calculations are
represented visually, highlighting the initialization, iteration, and termination of a loop.

Flowchart for Calculating Factorial of a Number

This flowchart demonstrates the process of calculating the factorial of a given number. It begins with a
"Start" step, followed by reading the input number (n). The initial values are set as i = 1 and fact = 1.
A decision point checks if i <= n. If true, the factorial is updated as fact = fact * i, and the counter

29
i is incremented by 1. This loop continues until i exceeds n. Once the condition is false, the factorial
value (fact) is printed, and the process ends. This flowchart effectively visualizes the iterative logic of
computing a factorial.

Example 3: Flowchart for User Login System

Multi-Factor Authentication Flowchart

In this example, a flowchart outlines the logic for a simple login system that checks if the
entered username and password are correct. This flowchart begins with an Input/Output symbol
for entering the username and password. A Decision symbol then checks if the username
matches the stored username; if it doesn’t, the flowchart branches to an output that displays
“Username Incorrect.” If the username is correct, the flow proceeds to a second Decision
symbol that checks if the password is correct. If the password is incorrect, it displays “Password
Incorrect.” If both username and password are correct, the flow proceeds to a Process symbol
that displays “Login Successful.” The flowchart ends after each display. This example
demonstrates the use of multiple decision points and how flowcharts can model conditional
checks and branching paths in user interactions.

Example 4: Flowchart for Finding the Sum of an Array

This flowchart example calculates the sum of numbers in an array, which involves a looping
structure to iterate through each element. The flowchart begins with an Input/Output symbol to
receive the array of numbers. Next, a Process symbol initializes a sum variable to zero. A

30
Decision symbol then initiates a loop to check if all elements in the array have been added to
the sum. For each iteration, the current array element is added to the sum, and the index counter
is incremented. After the loop completes, the flowchart displays the final sum and ends the
process. This example reinforces the concept of looping and demonstrates how flowcharts can
represent operations on collections of data, such as arrays.

Flowchart for Adding Two Numbers

This flowchart represents the process of adding two numbers. It begins with the "Start" step,
followed by taking two inputs, Number1 and Number2. The next step calculates the sum using
the formula Sum = Number1 + Number2. Once the addition is complete, the resulting sum is
printed. The process concludes with the "End" step. This flowchart provides a clear, step-by-
step visualization of a basic arithmetic operation.

Example 5: Flowchart for Checking Prime Numbers

This flowchart helps determine whether a number is prime by checking if it has any divisors
other than 1 and itself. The flowchart starts with an Input/Output symbol to receive the number.
A Decision symbol checks if the number is less than or equal to 1; if it is, the flowchart displays
31
“Not Prime” and ends. For numbers greater than 1, the flowchart uses a loop to test divisors
from 2 up to the square root of the number. If any divisor is found, the flowchart displays “Not
Prime” and ends. If no divisors are found after the loop, it displays “Prime” and concludes.
This example highlights how flowcharts handle complex decision-making processes, especially
when multiple conditions must be evaluated in sequence.

Flowchart for Determining Prime Numbers

This flowchart illustrates the process of determining whether a number GGG is prime. It starts
by initializing a variable ppp with a value of 3. The flow then loads GGG into the process and
divides GGG by ppp to check if the remainder is 0. If the remainder is 0, GGG is not a prime
number. Otherwise, it checks if ppp is greater than the quotient qqq. If p>qp > qp>q, GGG is
confirmed as a prime number and is printed. If not, ppp is incremented by 2, and the process
repeats until GGG is either confirmed or denied as a prime number. This flowchart efficiently
identifies prime numbers through iterative checks.

32
  Practicing Flowcharts for Problem Solving
Practicing flowcharts for these simple problems enhances understanding of control structures,
decision-making, and looping processes. Flowcharts enable beginners to visualize and organize

Flowchart for Troubleshooting a Lamp

This flowchart represents a troubleshooting process for a lamp that isn't working. It begins with checking
whether the lamp is plugged in. If not, the solution is to plug it in. If it is plugged in, the next step is to
check if the bulb is burned out. If the bulb is burned out, it should be replaced. If neither of these issues
resolves the problem, the final step is to buy a new lamp. This flowchart provides a simple and logical
approach to diagnosing and fixing a non-functional lamp.

33
2.4 Fundamentals of Complexity and Types

Fig 9 : Types of Complexity

In computer science, complexity analysis is a fundamental concept used to evaluate the

efficiency of algorithms. Complexity helps determine how the resources required by an
algorithm (such as time and memory) scale with the input size. This analysis allows developers
to understand how well an algorithm will perform, especially as the dataset grows, which is
essential for making informed decisions about which algorithm to use in different scenarios.
Complexity is usually categorized into time complexity and space complexity. Time
complexity measures how the execution time of an algorithm increases with the input size,
while space complexity measures the memory consumption. Understanding both types of
complexity helps programmers write efficient code, particularly for applications that handle
large datasets or require fast execution times.

Complexity analysis typically uses Big O notation to describe an algorithm’s efficiency in a

standard, simplified format. Big O notation focuses on the dominant term in an algorithm’s
growth rate, ignoring constants and lower-order terms to provide a clear picture of how the
algorithm’s resource usage scales. This notation allows developers to compare algorithms at a
high level, making it easier to select or design efficient solutions. In this section, we will delve
into the fundamentals of time and space complexity, exploring different types of Big O notation
and providing examples of complexity analysis.

34
 Time Complexity (Big O Notation)

Fig 10 : Big O Notation: Graphical Representation of Time Complexities

Time complexity measures the amount of time an algorithm takes to complete based on the
input size, denoted by n. Big O notation describes this time complexity by focusing on the
worst-case scenario, which indicates the maximum time an algorithm might take. By analyzing
the time complexity, programmers can predict how an algorithm will behave with increasingly
larger inputs. Big O notation is expressed in terms of functions, such as O(1), O(n), O(n^2),
O(log n), and so forth, each representing different growth rates. Understanding these types of
time complexity is essential for choosing the right algorithm, especially when handling large
datasets.

Constant Time - O(1): An algorithm with O(1) time complexity takes the same amount of
time to complete, regardless of the input size. It is the most efficient time complexity because
the execution time does not increase as the input size grows. For example, accessing an element
in an array by index takes O(1) time, as the operation does not depend on the array’s length.

Linear Time - O(n): An O(n) time complexity indicates that the execution time grows linearly
with the input size. In other words, if the input doubles, the time required also doubles. Linear
time algorithms are common in scenarios where each element must be processed individually,
such as iterating through an array to calculate the sum of its elements.

35
Quadratic Time - O(n^2): An algorithm with O(n^2) time complexity has a time requirement
that grows quadratically with the input size. This type of complexity is typical in algorithms
with nested loops, where each element in the dataset is compared with every other element. For
instance, the bubble sort algorithm has O(n^2) complexity, as it repeatedly compares adjacent
elements to sort the array.

Logarithmic Time - O(log n): Logarithmic time complexity, O(log n), indicates that the
execution time grows logarithmically as the input size increases. Algorithms with this
complexity divide the input size by a constant factor at each step, resulting in efficient
performance even with large datasets. Binary search is a classic example, where the search
interval is halved with each step, yielding O(log n) complexity.

Linearithmic Time - O(n log n): Linearithmic complexity, O(n log n), appears in algorithms
that combine linear and logarithmic operations. These algorithms are more efficient than
O(n^2) but less efficient than O(n) or O(log n). Examples include efficient sorting algorithms
like merge sort and quicksort, which divide the dataset and then combine sorted subsets.

Exponential Time - O(2^n): Exponential time complexity indicates that the time requirement
doubles with each additional element in the input. Algorithms with exponential complexity are
highly inefficient for large datasets and are generally impractical for real-world applications.
Exponential algorithms, such as recursive solutions for the traveling salesman problem, are
often avoided unless the input size is small or exact solutions are necessary.

Time complexity provides a useful measure of an algorithm’s efficiency, helping to predict

how it will scale with input size. By analyzing time complexity with Big O notation, developers
can choose algorithms that optimize execution time, improving the overall performance of
applications.

Space Complexity

Space complexity measures the amount of memory an algorithm requires relative to the input
size. This complexity includes all the memory that the algorithm needs to store variables, data
structures, function calls, and any other storage requirements. Space complexity is especially
important in memory-constrained environments, such as embedded systems or applications
running on mobile devices, where excessive memory usage can lead to performance
degradation or crashes. Like time complexity, space complexity is also expressed in Big O
notation, providing a high-level view of how memory usage scales with input size.

36
Constant Space - O(1): An algorithm with O(1) space complexity requires a fixed amount of
memory regardless of the input size. This is the most memory-efficient complexity, as the
algorithm’s memory usage does not grow with larger inputs. For example, swapping two
variables requires O(1) space, as only a constant amount of storage is needed for the swap
operation.

Linear Space - O(n): An O(n) space complexity indicates that memory usage grows linearly
with the input size. This is common in algorithms that create additional storage proportional to
the input, such as storing elements in an array or list. For example, copying the elements of an
array to a new array requires O(n) space, as each element needs a separate storage location.

Quadratic Space - O(n^2): Quadratic space complexity means that memory usage grows
quadratically with the input size. This type of complexity appears in algorithms that store
pairwise information or require nested storage structures. For example, creating a two-
dimensional matrix to store distances between n points would require O(n^2) space.

Logarithmic Space - O(log n): Logarithmic space complexity, O(log n), implies that the
memory usage grows logarithmically as the input size increases. Recursive algorithms that use
divide-and-conquer strategies often have logarithmic space complexity because they divide the
problem into smaller subproblems. For instance, the recursive version of binary search has
O(log n) space complexity due to the memory required for each recursive call in the call stack.

Exponential Space - O(2^n): Exponential space complexity means that memory usage grows
exponentially with the input size. Algorithms with exponential space requirements are rarely
feasible for large inputs, as they consume significant memory resources. For instance,
generating all subsets of a set requires O(2^n) space, as each subset needs to be stored
separately.

Understanding space complexity is crucial for optimizing memory usage in applications. By

analyzing space complexity, developers can choose algorithms that are efficient not only in
terms of execution time but also in terms of memory consumption, leading to more robust and
scalable applications.

37
 Examples of Complexity Analysis

Example 1: Linear Search

The linear search algorithm, which searches for a specific element in an unsorted array, has
both time and space complexity implications. In terms of time complexity, linear search
requires checking each element sequentially until the target is found or the entire array has been
traversed. Thus, its time complexity is O(n), as it may need to examine every element in the
worst case. The space complexity of linear search, however, is O(1), as it only requires a
constant amount of memory to store variables (e.g., index pointers) regardless of the array size.
This example illustrates the efficiency trade-off between time and space in simple algorithms.

Example 2: Binary Search

Binary search, an efficient algorithm for finding a target element in a sorted array, highlights
the benefits of logarithmic time complexity. In binary search, the array is divided in half with
each step, narrowing down the search range. This division results in an O(log n) time
complexity, as each step reduces the input size exponentially. Binary search is faster than linear
search for large, sorted datasets. However, the space complexity of binary search depends on
its implementation. The iterative version has O(1) space complexity, as it only needs a few
variables for tracking indices. The recursive version, on the other hand, has O(log n) space
complexity due to the call stack required for each recursive call. This example demonstrates
how different implementations of the same algorithm can impact space complexity.

Example 3: Bubble Sort

Bubble sort is a simple sorting algorithm with O(n^2) time complexity due to its nested loop
structure, where each element is repeatedly compared with adjacent elements. In each pass, the
algorithm checks if elements need swapping and repeats until the array is sorted. While bubble
sort is easy to understand and implement, it is inefficient for large datasets because of its
quadratic time complexity. Its space complexity, however, is O(1) if sorting is done in place,
meaning that no additional memory is needed beyond the input array. Bubble sort is often used
as a teaching tool to illustrate time complexity, as it clearly demonstrates the impact of nested
operations on execution time.

38
Example 4: Merge Sort

Merge sort, an efficient sorting algorithm based on divide-and-conquer, has a time complexity
of O(n log n). The algorithm recursively divides the array into halves, sorts each half, and then
merges the sorted halves to produce a fully sorted array. The logarithmic factor arises from the
recursive division of the array, while the linear factor results from merging the elements. Merge
sort is more efficient than bubble sort for larger datasets, making it a popular choice for sorting
tasks. However, its space complexity is O(n) due to the additional arrays required for merging
sorted halves, making it less memory-efficient than in-place sorting algorithms. Merge sort
exemplifies the trade-off between time and space complexity, as it offers faster execution but
requires additional memory.

Example 5: Fibonacci Sequence (Recursive)

Calculating the Fibonacci sequence using recursion illustrates exponential time complexity. In
the recursive approach, each Fibonacci number is computed by summing the two preceding
numbers, resulting in a tree-like structure of recursive calls. This structure leads to a time
complexity of O(2^n), as each function call generates two additional calls. The recursive
Fibonacci algorithm is inefficient for large values of n due to the exponential growth in
execution time. Its space complexity, however, is O(n), as each recursive call requires stack
memory proportional to n. This example demonstrates the limitations of exponential time
complexity and highlights the need for optimized algorithms.

Understanding the fundamentals of complexity and its types—time complexity and space
complexity—is crucial in algorithm design and analysis. Time complexity, measured using Big
O notation, provides insight into how an algorithm’s execution time scales with input size, with
different complexities (e.g., O(1), O(n), O(n^2)) offering varying performance characteristics.
Space complexity evaluates an algorithm’s memory requirements, helping developers optimize
for memory usage alongside execution speed. By analyzing complexity, developers can choose
algorithms that balance time and space efficiency, especially when dealing with large datasets
or performance-critical applications. Through examples like linear search, binary search,
bubble sort, merge sort, and recursive Fibonacci, it’s clear how complexity analysis guides the
selection of appropriate algorithms, leading to more efficient and scalable code.

39
2.5 Basic Algorithm Analysis

Algorithm analysis is the process of evaluating the efficiency of algorithms, primarily focusing
on their execution time and memory usage. Efficiency is critical in software development,
especially when working with large datasets or developing applications that require real-time
responses. By analyzing algorithms, developers can predict how they will perform as input
sizes increase, choose the best approach to solve a problem, and design systems that are both
time and space-efficient. In analyzing algorithms, the primary focus is on two main aspects:
time complexity and space complexity, both of which are typically measured using Big O
notation. Algorithm analysis helps in comparing different algorithms based on their efficiency,
ensuring that only the most effective ones are selected for implementation.

Analyzing Algorithms for Efficiency

Efficiency in algorithms is typically analyzed in terms of the rate of growth of time and space
requirements with respect to the input size. This approach allows developers to understand how
an algorithm will behave as data scales, which is essential for building applications that are
responsive and scalable. Time complexity analysis, which measures the speed of an algorithm,
is especially critical when optimizing for performance. The primary goal is to determine how
the execution time of an algorithm grows as the input size increases. For instance, if an
algorithm has a time complexity of O(n), it means that the execution time grows linearly with
the input size. This linear growth is manageable for large inputs, but algorithms with higher
complexities, such as O(n^2) or O(2^n), may become impractical as input size increases.

Space complexity, on the other hand, measures the memory usage of an algorithm. While time
complexity is often prioritized, space complexity is crucial in memory-constrained
environments, such as embedded systems or mobile applications. An algorithm’s space
complexity accounts for all the memory it requires, including variables, data structures, and
any additional storage for recursive calls or temporary variables. For example, a simple
algorithm that processes an array in place without using extra storage has a space complexity
of O(1), indicating constant space usage. In contrast, algorithms that require additional arrays
or data structures, such as merge sort, may have a space complexity of O(n), where memory
usage grows linearly with the input size.

Efficient algorithms strike a balance between time and space complexity, ensuring both fast
execution and minimal memory usage. Analyzing an algorithm for efficiency involves

40
understanding its time and space complexity under different scenarios, identifying any trade-
offs, and choosing the best solution based on the specific requirements of the problem. For
example, an algorithm that is fast but uses excessive memory may not be suitable for systems
with limited resources, whereas an algorithm that is slower but has minimal memory usage
may be more appropriate in such cases.

Best, Worst, and Average Case Scenarios

When analyzing algorithms, it’s essential to consider the best, worst, and average case
scenarios. Each scenario describes how the algorithm performs under different conditions,
providing a more comprehensive view of its behavior.

Best Case: The best-case scenario describes the minimum amount of time or space an
algorithm requires. This scenario represents an ideal situation where the algorithm performs at
its most efficient level. For example, in the best case for linear search, the target element is the
first item in the array, resulting in a time complexity of O(1). However, the best-case scenario
is rarely the primary focus in algorithm analysis since real-world data rarely conforms to ideal
conditions. Nonetheless, understanding the best case is useful for assessing an algorithm's
potential for optimal performance.

Worst Case: The worst-case scenario examines the maximum time or space an algorithm will
need, providing an upper bound on its performance. This scenario is crucial in algorithm
analysis, as it guarantees that the algorithm will not exceed this level of resource consumption.
For example, the worst case for linear search occurs when the target element is the last item in
the array, resulting in a time complexity of O(n). Analyzing the worst case helps in predicting
the algorithm’s performance under the most challenging conditions, ensuring that it remains
efficient and stable.

Average Case: The average-case scenario provides a more realistic assessment by considering
the algorithm's expected behavior across different inputs. It calculates the algorithm’s
performance based on the probability distribution of different input cases. For example, in
linear search, the average case would consider that the target element could appear at any
position in the array with equal likelihood, leading to an average time complexity of O(n/2),
which simplifies to O(n). The average case gives a practical view of an algorithm’s efficiency,
as it reflects the expected performance for typical inputs.

41
 By analyzing the best, worst, and average case scenarios, developers gain a well-rounded
understanding of an algorithm’s behavior. This information is essential for selecting algorithms
that meet specific performance requirements, especially in cases where applications must
operate within strict time or memory constraints.

2.6 Practice Programs

Example 1: Binary Search Algorithm

Binary search is a more efficient search algorithm, provided the array is sorted. It operates by
repeatedly dividing the search interval in half, making it faster than linear search for large
datasets.

Binary Search Algorithm Steps:

1. Start: Define the sorted array and the target element you want to search for.
2. Initialize Pointers: Set two pointers, low to the first index (0) and high to the last index (n-1) of
the array.
3. Loop Until Low <= High:
o Calculate the middle index: mid = (low + high) / 2 (or (low + high) // 2 in
programming).
4. Compare the Target with the Middle Element:
o If the middle element equals the target, the target is found. Return the mid index.
o If the target is less than the middle element, narrow the search to the left half by setting
high = mid - 1.
o If the target is greater than the middle element, narrow the search to the right half by setting
low = mid + 1.
5. Repeat the Process: Continue adjusting low and high until the target is found or low > high.
6. End: If the target is not found, return a value indicating the target is not in the array (e.g., -1).

42
 Complexity Analysis:

Best Case: O(1), if the target is the midpoint.

Worst Case: O(log n), as the search interval halves each time.

Average Case: O(log n), with similar reasoning as the worst case.

Practice Goal: Binary search demonstrates the power of logarithmic complexity and introduces
students to efficient searching in sorted data.

Example 2: Bubble Sort Algorithm

Bubble sort is a simple sorting algorithm with a nested loop structure that compares and swaps
adjacent elements. While inefficient for large datasets, it is a good practice program for
understanding sorting basics.

Algorithm Steps:

Bubble Sort Algorithm Steps:

1. Start: Define an array of nnn elements that need to be sorted.

2. Outer Loop: Set up an outer loop that runs n−1n-1n−1 times (for all elements in the array).
3. Inner Loop: Inside the outer loop, set up an inner loop that iterates through the array from the
first element to the n−i−1n-i-1n−i−1-th element (where iii is the current iteration of the outer loop).
4. Compare Adjacent Elements:
o Compare the current element with the next element.
o If the current element is greater than the next element, swap them.
5. Repeat: Continue the inner loop until the largest unsorted element "bubbles" to the correct
position at the end of the array.
6. Optimize (Optional): If no swaps are made during an iteration of the inner loop, the array is
already sorted, and you can break out of the loops.
7. End: Once the outer loop completes, the array is sorted.

The algorithm ensures the largest elements are placed in their correct positions with each iteration
of the outer loop.

43
 Initialize a loop to pass through the array multiple times.

For each pass, compare adjacent elements.

Swap elements if they are out of order.

Repeat until the array is fully sorted.

Complexity Analysis:

Best Case: O(n), if the array is already sorted.

Worst Case: O(n^2), if the array is in reverse order.

Average Case: O(n^2), as each element is compared with others in a nested loop.

Practice Goal: Bubble sort introduces learners to basic sorting logic, helping them grasp
concepts like comparisons, swaps, and nested loops.

Example 3: Factorial Calculation (Recursive and Iterative)

Calculating the factorial of a number demonstrates recursion, looping, and complexityanalysis.

Factorial calculation involves multiplying all integers from 1 to the given number
Algorithm Steps:

Factorial Calculation Algorithms (Recursive and Iterative)

Recursive Approach:

1. Start: Define a function factorial(n) that takes a positive integer nnn as input.
2. Base Case:
o If n=0n = 0n=0 or n=1n = 1n=1, return 1. (The factorial of 0 or 1 is 1.)
3. Recursive Call:
o For n>1n > 1n>1, call the function recursively as factorial(n) = n * factorial(n-1).
4. End: Return the result of the multiplication at each recursion level until the base case is reached.

44
Iterative Approach:

1. Start: Define a function factorial_iterative(n) that takes a positive integer nnn as input.
2. Initialize:
o Set a variable result = 1 to store the factorial value.
3. Loop:
o Use a for loop from 1 to nnn (inclusive):
 Multiply result by the current number iii: result = result * i.
4. Return:
o After the loop, result contains the factorial of nnn.
5. End: Return the value of result.

Both approaches calculate the factorial but differ in their methodology. The recursive approach uses
function calls, while the iterative approach uses a loop to compute the result.

Complexity Analysis:

Iterative Complexity: O(n), as the loop iterates n times.

Recursive Complexity: O(n), with additional space complexity O(n) for the call stack.

Practice Goal: Factorial calculation provides a practical application of recursion and iteration,
essential for understanding function calls and recursive depth.

45
 Example 4: Fibonacci Sequence (Recursive and Iterative)

The Fibonacci sequence is another classic example that helps illustrate the difference in
efficiency between recursive and iterative approaches.
Algorithm Steps:

Fibonacci Sequence Algorithms (Recursive and Iterative)

Recursive Approach:

1. Start: Define a function fibonacci(n) that takes an integer nnn as input.

2. Base Case:
o If n=0n = 0n=0, return 0.
o If n=1n = 1n=1, return 1.
3. Recursive Call:
o For n>1n > 1n>1, return fibonacci(n-1) + fibonacci(n-2).
4. End: The function will return the nnn-th Fibonacci number after the recursive calls resolve.

Iterative Approach:

1. Start: Define a function fibonacci_iterative(n) that takes an integer nnn as input.

2. Initialize:
o If n=0n = 0n=0, return 0.
o If n=1n = 1n=1, return 1.
o Set two variables: a = 0 (first Fibonacci number) and b = 1 (second Fibonacci number).
3. Loop:
o Use a for loop from 2 to nnn (inclusive):
 Calculate the next Fibonacci number: c = a + b.
 Update a to b and b to c.
4. Return:
o After the loop, b contains the nnn-th Fibonacci number.
5. End: Return the value of b.

Key Difference:

 The recursive approach is simple to implement but less efficient due to repeated calculations
for the same values (unless optimized with memoization).
 The iterative approach is more efficient as it avoids redundant calculations and uses constant
space.

46
Complexity Analysis:

Iterative Complexity: O(n), with constant space usage.

Recursive Complexity: O(2^n), as each call generates two more calls, leading to exponential
growth.

Practice Goal: The Fibonacci sequence demonstrates the efficiency impact of recursive versus
iterative solutions and highlights the importance of complexity analysis.

47
MCQ:

What is the purpose of Big O notation in algorithm analysis?

(A) To determine an algorithm’s accuracy

(B) To measure the growth rate of time and space requirements
(C) To select the correct programming language
(D) To make algorithms run faster
Answer: (B)

Which time complexity represents the most efficient growth rate?

(A) O(n²)
(B) O(n)
(C) O(log n)
(D) O(2ⁿ)
Answer: (C)

Which scenario describes the maximum resources an algorithm might require?

(A) Best case

(B) Worst case
(C) Average case
(D) Minimal case
Answer: (B)

If an algorithm has O(n²) time complexity, what does it imply?

(A) Execution time grows linearly with input size

(B) Execution time grows quadratically with input size
(C) Execution time is constant regardless of input size
(D) Execution time grows exponentially with input size
Answer: (B)
What is the time complexity of binary search in a sorted array?

(A) O(n)
(B) O(n²)
(C) O(log n)
(D) O(1)
Answer: (C)

Which complexity type describes the memory requirements of an algorithm?

(A) Time complexity

(B) Space complexity
(C) Best-case scenario
(D) Execution complexity
Answer: (B)

48
Which of the following best describes O(n) time complexity?

(A) Constant time

(B) Linear time
(C) Quadratic time
(D) Logarithmic time
Answer: (B)

49
 CHAPTER 3

Array, Strings and Linked Lists

3.1 Arrays: Types, Manipulations, and Applications

Arrays are one of the most fundamental data structures in computer science, providing a way
to store multiple elements in contiguous memory locations under a single variable name. They
are highly efficient for accessing elements directly by their index, which makes them widely
used in programming for storing, manipulating, and managing data. Arrays can hold different
data types, such as integers, characters, or even objects, depending on the programming
language. By using arrays, developers can organize and process data sets more efficiently,
making arrays a crucial tool in algorithm development, data processing, and real-world
applications. This section explores the types of arrays, techniques for manipulating arrays, and
practical applications of arrays in the real world.

Fig 11: Array Data Structure

50
 Types of Arrays (One-Dimensional, Multi-Dimensional)

One-Dimensional Arrays

Fig 12 : One-Dimensional Array Representation in C

A one-dimensional array is the simplest form of an array, where elements are arranged in a
single row or line. It is often called a linear array and is indexed from 0 up to the array’s length
minus one. Each element in a one-dimensional array can be accessed directly through its index,
making it easy to retrieve or update values. For instance, if we have an array arr with elements
[5, 10, 15, 20], accessing arr[2] would yield 15. This type of array is suitable for storing lists
of data that follow a single sequence, such as a list of scores, a series of numbers, or a list of
names. One-dimensional arrays are efficient in terms of memory and processing speed due to
their simplicity and direct access to elements by index.

One-dimensional arrays are widely used in both simple and complex applications. For example,
they are utilized in sorting algorithms (such as bubble sort and quicksort) where data needs to
be processed sequentially. They are also employed in searching algorithms like linear search
and binary search, where accessing elements by their indices is essential. In real-world
scenarios, one-dimensional arrays can store data such as daily temperatures, grades, or any data
series that can be processed in a sequential manner. Additionally, since memory is allocated in
a contiguous block, one-dimensional arrays make memory management more straightforward.

51
Example 1: Basic Declaration and Access
#include <stdio.h>
int main() {
// Declare and initialize a one-dimensional array
int arr[4] = {5, 10, 15, 20};

// Access and print each element using its index

printf("Element at index 0: %d\n", arr[0]); // Output: 5
printf("Element at index 1: %d\n", arr[1]); // Output: 10
printf("Element at index 2: %d\n", arr[2]); // Output: 15
printf("Element at index 3: %d\n", arr[3]); // Output: 20
return 0;
}
Output:
Element at index 0: 5
Element at index 1: 10
Element at index 2: 15
Element at index 3: 20

Example 2: Iterating Through an Array

#include <stdio.h>
int main() {
int scores[5] = {90, 85, 80, 95, 88};
printf("Student scores:\n");
for (int i = 0; i < 5; i++) {
printf("Score of student %d: %d\n", i + 1, scores[i]);
}
return 0;
}
Output:
Student scores:
Score of student 1: 90
Score of student 2: 85
Score of student 3: 80

52
Score of student 4: 95
Score of student 5: 88

Example 3: Array Input from the User

#include <stdio.h>
int main() {
int n, i;
printf("Enter the number of elements: ");
scanf("%d", &n);
int arr[n]; // Declare a one-dimensional array with user-defined size
// Input elements into the array
printf("Enter %d elements:\n", n);
for (i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
// Display the array elements
printf("The elements of the array are:\n");
for (i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
return 0;
}
Output:
Enter the number of elements: 4
Enter 4 elements:
1
2
4
5
The elements of the array are:
1245

53
Example 4: Using Arrays in a Sorting Algorithm (Bubble Sort)
#include <stdio.h>
void bubbleSort(int arr[], int n) {
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
// Swap arr[j] and arr[j+1]
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}

int main() {
int arr[5] = {64, 34, 25, 12, 22};

// Print the original array

printf("Original array: ");
for (int i = 0; i < 5; i++) {
printf("%d ", arr[i]);
}
printf("\n");

// Sort the array using bubble sort

bubbleSort(arr, 5);

// Print the sorted array

printf("Sorted array: ");
for (int i = 0; i < 5; i++) {
printf("%d ", arr[i]);
}

54
 return 0;
}
Output:
Original array: 64 34 25 12 22
Sorted array: 12 22 25 34 64

Example 5: Using Arrays in Searching (Linear Search)

#include <stdio.h>
int linearSearch(int arr[], int n, int key) {
for (int i = 0; i < n; i++) {
if (arr[i] == key) {
return i; // Return the index of the element
}
}
return -1; // Return -1 if the element is not found
}

int main() {
int arr[6] = {3, 5, 7, 9, 11, 13};
int key = 7;

int index = linearSearch(arr, 6, key);

if (index != -1) {
printf("Element %d found at index %d\n", key, index);
} else {
printf("Element %d not found in the array.\n", key);
}

return 0;
}
Output:
Element 7 found at index 2

55
Example 6: Array for Real-World Data (Daily Temperatures)
#include <stdio.h>
int main() {
float temperatures[7] = {32.5, 31.8, 33.2, 35.0, 34.5, 32.0, 33.8};
printf("Daily temperatures for the week:\n");
for (int i = 0; i < 7; i++) {
printf("Day %d: %.1f°C\n", i + 1, temperatures[i]);
}
return 0;
}
Output:
Daily temperatures for the week:
Day 1: 32.5°C
Day 2: 31.8°C
Day 3: 33.2°C
Day 4: 35.0°C
Day 5: 34.5°C
Day 6: 32.0°C
Day 7: 33.8°C

Summary:
Arrays provide a straightforward and efficient way to handle lists of data.
You can use arrays in algorithms like sorting, searching, or storing real-world data for further processing.
The examples above demonstrate common operations on one-dimensional arrays, including accessing,
iterating, sorting, and searching.

56
Two-Dimensional Array or Multi-Dimensional Arrays

Fig 13 : Two-Dimensional Array Representation

Multi-dimensional arrays extend the concept of one-dimensional arrays by allowing arrays

within arrays, forming rows and columns. The most common form of multi-dimensional arrays
is the two-dimensional array, where data is stored in a grid or matrix format. Each element in
a two-dimensional array is accessed by two indices: one for the row and another for the column.
For example, in a 3x3 matrix matrix[2][1] represents the element in the third row and second
column. Multi-dimensional arrays are useful for representing complex data structures, such as
tables, matrices, or images, where data has a natural arrangement in rows and columns.

Fig 14: Multidimensional Arrays in C

57
Example: Matrix Multiplication Using 2D Arrays
This is one of the most important examples of multi-dimensional arrays, as matrix
multiplication is widely used in mathematics, physics, computer graphics, and machine
learning.

#include <stdio.h>
int main() {
int matrix1[2][3] = {{1, 2, 3}, {4, 5, 6}};
int matrix2[3][2] = {{7, 8}, {9, 10}, {11, 12}};
int result[2][2] = {0};
// Perform matrix multiplication
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 3; k++) {
result[i][j] += matrix1[i][k] * matrix2[k][j];
}
}
}
// Print the result matrix
printf("Result of matrix multiplication:\n");
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
printf("%d ", result[i][j]);
}
printf("\n");
}
return 0;
}
Output:
Result of matrix multiplication:
58 64
139 154

58
Why is this important?
Matrix multiplication is foundational for linear algebra operations, which underpin various
fields, including:

In addition to two-dimensional arrays, some applications may require three-dimensional arrays

or higher-dimensional arrays. For example, a three-dimensional array could represent data with
three attributes, such as a 3D spatial model where each coordinate (x, y, z) maps to a value.
Multi-dimensional arrays are especially useful in fields like image processing, where pixel data
is stored in a two-dimensional array, and scientific computing, where matrices and higher-
dimensional data models are essential. However, multi-dimensional arrays consume more
memory than one-dimensional arrays, and accessing elements is slower because multiple
indices must be processed.

Array Manipulation Techniques

Array manipulation refers to the different operations that can be performed on arrays, including
insertion, deletion, traversal, searching, and sorting. These techniques enable developers to
process and manage data efficiently, making arrays versatile tools for data manipulation.

 Insertion and Deletion

Insertion in an array involves adding a new element at a specific index. If an array has unused
space, the element can be directly placed at the designated position. However, if the array is
already filled to capacity, adding an element may require creating a larger array and copying
the existing elements. Inserting at the beginning or middle of an array requires shifting all
elements after the insertion point to make space for the new element, which can be time-
consuming (O(n) time complexity for shifting elements). Deletion works similarly, where
removing an element from the middle or beginning requires shifting the subsequent elements
to fill the gap, maintaining the order of the array.

 Traversal

Traversal is the process of visiting each element in an array, typically from the first element to
the last. Traversal is essential in most array operations, as it allows access to every element for
processing, modification, or display. Traversing a one-dimensional array is straightforward, as
each element is visited in a linear sequence using a loop. Traversing multi-dimensional arrays,
however, requires nested loops, with one loop per dimension. For instance, traversing a two-
dimensional array involves a nested loop structure, where the outer loop iterates over rows and
the inner loop iterates over columns. Traversal has a time complexity of O(n) for one-
59
dimensional arrays and O(n*m) for two-dimensional arrays of size n by m.

 Searching

Searching is a crucial operation in array manipulation, as it involves finding the index of a

specific element within the array. Two common searching techniques are linear search and
binary search. Linear search iterates through each element, checking if it matches the target
value. It is straightforward but inefficient for large arrays, with a time complexity of O(n).
Binary search, on the other hand, is much faster, with a time complexity of O(log n), but it
requires the array to be sorted. By repeatedly dividing the search range in half, binary search
quickly narrows down the target’s location, making it highly efficient for sorted data.

 Sorting

Sorting arranges elements in a specific order, either ascending or descending. There are
numerous sorting algorithms for arrays, including bubble sort, selection sort, insertion sort,
merge sort, and quicksort. Simple sorting algorithms like bubble sort have a time complexity
of O(n^2), while more efficient algorithms like merge sort and quicksort achieve O(n log n)
time complexity. Sorting is critical in various applications, as it improves the efficiency of
searching, data analysis, and presentation. Sorted arrays make binary search possible and
enable faster data retrieval and organization.

Applications of Arrays in the Real World

Arrays have a wide range of applications in real-world scenarios due to their versatility and
efficiency. From handling simple datasets to powering complex systems, arrays play a critical
role in organizing and processing data across various fields.

Data Storage and Organization

In computer applications, arrays are widely used for data storage and organization. In
spreadsheets, for example, a one-dimensional array may store a list of values in a single
column, while a two-dimensional array organizes data in rows and columns, forming a table.
Arrays are also fundamental in database indexing, where they store pointers to data records in
a way that allows quick access and retrieval. In database systems, arrays are frequently used to
implement B-trees and hash tables, which improve the efficiency of search and retrieval
operations.

60
Image Processing

In image processing, arrays are used to store pixel data for digital images. A grayscale image
can be represented as a two-dimensional array, where each element corresponds to the
brightness value of a pixel. Color images, which have three color channels (red, green, and
blue), can be represented as three-dimensional arrays, with one two-dimensional layer for each
color channel. Manipulating these arrays allows for image transformations, filtering, and
enhancements. For example, blurring an image involves averaging the values of neighboring
pixels, which can be achieved through array manipulation. Arrays also make it possible to apply
complex operations like edge detection and color transformation.

Mathematical Computations and Simulations

In scientific computing and engineering, arrays (often called matrices) are essential for
numerical computations and simulations. Arrays represent matrices, vectors, and higher-
dimensional data structures in linear algebra, which are used to perform calculations such as
matrix multiplication, eigenvalue computation, and system-solving in engineering and physics.
Multi-dimensional arrays are essential in simulations, where they model spatial data. For
instance, in weather forecasting, arrays store data points for temperature, humidity, and wind
speed across a grid representing geographical areas. Arrays enable complex calculations that
support predictions and real-time analysis.

Game Development

Arrays are widely used in game development to store game data, such as player scores, game
levels, and object positions. In a two-dimensional grid-based game (like a chessboard or a
maze), a two-dimensional array can represent the game board, with each cell indicating an
object, obstacle, or open path. Game developers also use arrays to manage animations by
storing sequences of frames, where each frame is an element in the array. Additionally, multi-
dimensional arrays can model 3D game environments by mapping out coordinates for objects
in space. Arrays make it easy to manipulate game data in real time, allowing developers to
create dynamic and interactive experiences.

Machine Learning and Data Science

Arrays, especially in the form of multi-dimensional arrays, are foundational in machine

learning and data science. Libraries like NumPy in Python provide array structures and
operations optimized for large datasets. In machine learning, arrays store features, labels, and

61
parameters for training models. For instance, a dataset with multiple features for each
observation can be represented as a two-dimensional array, with each row representing an
observation and each column representing a feature. Multi-dimensional arrays are essential for
tensor operations in deep learning, where they store weights, biases, and activations for neural
networks. Arrays enable efficient handling of data, matrix transformations, and linear algebra
operations, all crucial in machine learning algorithms.

Arrays are versatile and powerful data structures with numerous types, manipulation
techniques, and applications across various fields. One-dimensional and multi-dimensional
arrays enable developers to store and process data in structured formats, with direct indexing
allowing for efficient access. Array manipulation techniques, including insertion, deletion,
traversal, searching, and sorting, empower developers to organize and analyze data effectively.
Real-world applications of arrays are vast, ranging from data storage and image processing to
scientific simulations, game development, and machine learning. By mastering array concepts
and operations, programmers gain a valuable toolset for managing data, optimizing algorithms,
and solving complex problems efficiently.

3.2 Strings: Types, Manipulations, and Applications

Strings are sequences of characters used to represent text and are one of the most fundamental
data types in computer science. They are essential for handling and processing textual data in
various applications, from simple text storage to complex data encoding and pattern matching.
Strings are extensively used in software development, data processing, web applications, and
user interfaces, making them a crucial data structure to understand. In this section, we will
explore string representation and storage, common string manipulation operations, and
practical applications of strings in real-world scenarios.
String Reversal and Length Calculation
This example shows how to reverse a string and calculate its length.
#include <stdio.h>
#include <string.h>

int main() {
char str[100], reversed[100];
int length, i, j;
// Input a string
printf("Enter a string: ");
62
 fgets(str, sizeof(str), stdin);
str[strcspn(str, "\n")] = 0; // Remove the newline character from input

// Calculate the length of the string

length = strlen(str);
printf("Length of the string: %d\n", length);

// Reverse the string

for (i = length - 1, j = 0; i >= 0; i--, j++) {
reversed[j] = str[i];
}
reversed[j] = '\0'; // Null-terminate the reversed string

// Print the reversed string

printf("Reversed string: %s\n", reversed);

return 0;
}
Input Example:

Enter a string: Hello World

Output:

Length of the string: 11

Reversed string: dlroW olleH

Why is this example important?

String Length Calculation: Used in text processing applications.
String Reversal: Frequently used in algorithms for checking palindromes, encryption, or text-
based operations.
Real-World Applications: Found in tasks like reversing usernames, generating passwords, or
formatting user data.

63
 String Representation and Storage

A string is a sequence of characters, where each character can be a letter, number, symbol, or
space. Strings are typically enclosed in quotes in programming languages and are treated as
immutable data structures in most languages, meaning that once created, they cannot be altered.
This immutability is important for optimizing memory usage and improving performance.
Internally, each character in a string is stored as a series of bytes in memory, following a
specific character encoding such as ASCII or Unicode.

Character Encoding: ASCII and Unicode

Fig 15 : ASCII (American Standard Code for Information Interchange) Chart

ASCII (American Standard Code for Information Interchange) is one of the earliest character
encoding schemes. It uses 7 or 8 bits to represent characters, covering a set of 128 characters,
including English letters, numbers, and control characters. ASCII is efficient for storing text in
English and other Latin-based alphabets but is limited in its ability to handle diverse languages
and symbols.

Unicode, on the other hand, is a more comprehensive encoding standard that accommodates
characters from virtually all languages, including special symbols, emojis, and more. Unicode
uses variable-length encoding schemes like UTF-8 and UTF-16. UTF-8, for instance,
represents characters using 1 to 4 bytes, providing flexibility and efficiency in storage. Unicode
has become the dominant standard for character encoding, as it enables consistent
representation of text across different languages and platforms, making it ideal for global
applications.
64
String Storage and Memory

When stored in memory, a string is represented as a contiguous block of characters, with each
character taking up space based on the encoding used. For example, in UTF-8, common ASCII
characters take 1 byte, while non-ASCII characters may require more bytes. In languages like
C, strings are often null-terminated, meaning a special null character (\0) marks the end of the

string. This approach allows functions to determine where a string ends, but it also means
strings must be carefully managed to avoid memory errors.

In high-level languages like Python and Java, strings are abstracted into objects, with built-in
methods for managing and manipulating them. These languages handle memory allocation and
deallocation automatically, often using string pooling or interning techniques to optimize
memory usage. String pooling stores identical string values in a shared pool to avoid duplicate
storage, which is especially useful for frequently used strings, like variable names or commonly
referenced text.

Common String Manipulation Operations

Strings support a wide range of manipulation operations that enable developers to process and
transform text efficiently. These operations are fundamental for tasks like data parsing,
formatting, and pattern matching.

 Concatenation

Concatenation is the process of joining two or more strings to form a single string. For example,
concatenating "Hello" and "World" would result in "HelloWorld." Concatenation is commonly
used in creating dynamic messages, building file paths, or constructing URLs. Most
programming languages provide a straightforward way to concatenate strings, often using
operators like + in Python, JavaScript, and Java. However, concatenation can be inefficient for
large strings, as each operation may require creating a new string in memory. For frequent
concatenation, languages like Java offer classes such as StringBuilder, which allows strings to
be modified in place for better performance.

 Substring Extraction

Substring extraction is the process of retrieving a specific portion of a string, often by

specifying a start and end index. For instance, extracting a substring from "HelloWorld"
starting at index 0 and ending at index 5 would yield "Hello." Substring operations are useful
in data parsing, where specific parts of text need to be isolated, such as extracting domain
65
names from URLs or names from email addresses. Most languages offer built-in methods for
substring extraction, which can be customized to include or exclude particular indices.

 Searching and Indexing

Searching for a specific character or sequence of characters within a string is a common

operation, often used for locating keywords, parsing data, or validating input. For example,
searching for "@" in an email address helps validate the format. Some popular searching
methods include indexOf or find, which return the position of the target substring. In more
complex scenarios, pattern matching with regular expressions can be used to locate sequences
based on specific patterns, such as phone numbers or email addresses. Searching operations
have different time complexities depending on the method used, with simple searches being
O(n), while regular expressions can have varied complexity.

 Replacement

String replacement is used to substitute specific characters or substrings within a string with
new values. For instance, replacing all occurrences of "world" with "universe" in the sentence
"Hello world" would yield "Hello universe." This operation is particularly useful for
formatting, data sanitization, or transforming text to meet specific requirements. Replacement
can be performed at the character level or for entire substrings, and regular expressions can be
used to specify complex patterns. For example, replacing digits in a string with a placeholder
character, like “*,” is a common application in masking sensitive data.

 Splitting and Joining

Splitting divides a string into a list or array of substrings based on a specified delimiter. For
example, splitting "apple,orange,banana" by the comma delimiter would yield the list ["apple",
"orange", "banana"]. Splitting is essential in data parsing tasks, such as reading comma-
separated values (CSV) or breaking down sentences into words. The reverse operation, joining,
involves combining a list of strings into a single string with a specified delimiter. For instance,
joining ["apple", "orange", "banana"] with a comma results in "apple,orange,banana." Splitting
and joining are frequently used in text processing and data transformation.

 Case Conversion

Case conversion changes the case of characters within a string, such as converting all letters to
uppercase or lowercase. This operation is often used for standardizing text input, such as
transforming user-provided email addresses to lowercase for consistent comparison. Uppercase

66
and lowercase transformations can also be useful in formatting and data validation, ensuring
that the case of text does not affect functionality.

Practical Applications of Strings

Strings have a broad range of applications in software development, data processing,

communication, and more. Due to their versatility, strings are fundamental in many real-world
scenarios that require text handling, storage, and manipulation.

Data Parsing and Transformation

Data parsing is the process of analyzing and converting structured text data into a usable format.
Strings are extensively used for parsing tasks, especially in applications like web scraping, data
extraction, and log analysis. For instance, extracting specific information from a structured log
file requires identifying patterns and isolating fields. In a CSV file, each line represents a
record, and each field within the line is separated by a delimiter (e.g., a comma). By splitting
each line into fields, data parsing enables applications to store and analyze structured data.

Strings also play a significant role in data transformation. For instance, transforming text data
to fit a specified format or converting date formats within strings are common data
transformation tasks. Data transformation is critical in data warehousing, ETL (Extract,
Transform, Load) processes, and database management, where strings are used to store and
manipulate structured and semi-structured data.

Text Processing in Natural Language Processing (NLP)

Natural Language Processing (NLP) relies heavily on string manipulation for tasks like
tokenization, stemming, lemmatization, and pattern recognition. Tokenization breaks down
text into individual words or sentences, which are then processed to extract meaning. For
example, the sentence "The quick brown fox jumps" can be tokenized into the words ["The",
"quick", "brown", "fox", "jumps"]. NLP applications such as chatbots, language translation,
and sentiment analysis involve analyzing and manipulating strings to derive patterns and
insights from text.

Search Engines and Pattern Matching

Strings are central to search engines, which analyze and retrieve relevant text based on user
queries. Search engines use string operations to match query keywords against indexed content.
Techniques like string matching and pattern matching enable search engines to find exact or
approximate matches within large datasets. For example, search engines use pattern matching
67
to find results that partially or exactly match a user’s search terms. Advanced search features,
like wildcard matching and regular expressions, allow users to search for patterns, increasing
the flexibility and precision of search results.

In addition to web search, pattern matching is essential in applications like form validation,
where specific formats (e.g., email addresses or phone numbers) need to be verified. Using
regular expressions, developers can validate strings against predefined patterns, ensuring that
inputs meet expected criteria.

User Interface and Text Rendering

In user interfaces, strings are used to display text elements such as labels, menus, messages,
and notifications. Strings play a key role in enhancing user interaction, as they communicate
information to users through text. For instance, in a web application, button labels, input field
placeholders, and error messages are all stored as strings. Text rendering libraries convert these
strings into visual text that users can read and interact with. Additionally, internationalization
and localization involve using strings to represent text in multiple languages, ensuring that
applications are accessible to global audiences.

Data Encryption and Cryptography

Strings are often used to represent encrypted data in cryptographic systems. Encrypted text, or
ciphertext, is stored as a string of characters that can only be decrypted with a specific key. For
example, passwords are stored as hashed strings, where the original password is transformed
into a fixed-length, encoded representation. This transformation ensures that passwords remain
secure, as the original data cannot be retrieved from the hash without the correct decryption
process. String manipulation techniques are essential for encoding, hashing, and decrypting
sensitive information, making strings integral to data security and encryption.

Strings are versatile and powerful data structures that play a central role in software
development, data processing, and numerous real-world applications. Understanding how
strings are represented and stored, the various operations for manipulating strings, and their
practical applications provides a strong foundation for handling text data effectively. From data
parsing and natural language processing to user interfaces and encryption, strings enable
developers to manage, transform, and secure textual data efficiently. Mastering string
manipulation is essential for building applications that process and analyze text, enhancing both
the functionality and accessibility of software across various domains.

68
 3.3 Pointers and Memory Management

Pointers are a powerful feature in programming that allow developers to directly access and
manipulate memory addresses. Unlike variables, which store values, pointers store the address

of a memory location, enabling more efficient data manipulation and memory management.
Pointers are widely used in languages like C and C++ to optimize performance, manage
dynamic memory, and interact with system resources at a low level. Understanding pointers is
crucial for efficient memory management, as they enable programs to allocate and deallocate
memory dynamically, improve execution speed, and optimize memory usage. This section
covers the basics of pointers, pointer arithmetic, and practical examples of pointer use in
programming.

Fig 16: Pointer Variable Structure

Basics of Pointers

A pointer is a variable that stores the address of another variable, allowing indirect access to
the value stored in that memory location. In languages like C and C++, pointers are declared
using the * symbol, which indicates that the variable is a pointer to a specific data type. For
example, int *ptr; declares a pointer to an integer. When a pointer is assigned the address of a
variable, it can be used to access or modify the value at that memory location. For instance, if
int x = 10; and ptr = &x;, then *ptr (known as dereferencing) would yield the value 10, which
is the value stored at the address pointed to by ptr.

Pointers enable more direct and efficient access to data, as they bypass the need to copy large
data structures. This efficiency is particularly useful for arrays, structures, and other data types
that require significant memory. By using pointers, programs can pass references to data rather
69
than copying entire data structures, resulting in faster execution and lower memory

consumption. However, pointers also introduce complexity, as incorrect usage can lead to
errors like null pointer dereferencing, memory leaks, and segmentation faults.
Pointers are closely tied to memory management because they allow programmers to allocate
and deallocate memory dynamically. In static memory allocation, the amount of memory
required by a program is determined at compile time, limiting flexibility. Dynamic memory
allocation, enabled by pointers, allows memory to be allocated at runtime, ensuring that the
program only uses the memory it needs. This is particularly important in applications where
memory requirements vary, such as data-intensive programs or those that handle user-defined
data.

Pointer Arithmetic

Pointer arithmetic refers to performing mathematical operations on pointers, allowing

programmers to navigate through contiguous memory locations efficiently. Since pointers store
addresses, incrementing or decrementing them shifts the pointer to the next or previous memory
location based on the data type size. For example, if int *ptr points to an integer variable,
incrementing ptr by 1 will move it to the next integer in memory, skipping over sizeof(int)
bytes (typically 4 bytes on most systems). Pointer arithmetic is primarily used with arrays, as it
enables efficient traversal without needing index-based access.

In pointer arithmetic, the following operations are commonly used:

Incrementing: ptr++ advances the pointer to the next element. For example, in an integer array
arr, setting ptr = arr and incrementing ptr with ptr++ will make ptr point to the next element in
the array.

Decrementing: ptr-- moves the pointer to the previous element. This operation is useful when
iterating backward through an array.

Addition: ptr + n shifts the pointer forward by n elements, effectively skipping over multiple
elements in the array. This can be useful for accessing elements at specific intervals.

Subtraction: ptr - n moves the pointer backward by n elements, enabling access to previous
elements in memory.

Pointer arithmetic is essential in low-level programming, where efficient memory access and
manipulation are required. For example, iterating through a large dataset using pointer

70
arithmetic can reduce overhead compared to using index-based access. However, pointer
arithmetic must be used carefully to avoid accessing memory outside the allocated range, which
can lead to segmentation faults or unpredictable behavior.

Practical Examples of Pointer Use

Pointers are employed in various practical scenarios in programming, including dynamic

memory allocation, array manipulation, and implementing complex data structures. Here, we
explore some practical examples of pointer use in programming.

Dynamic Memory Allocation

Dynamic memory allocation is one of the most common uses of pointers. In languages like C
and C++, functions like malloc, calloc, realloc, and free allow programmers to allocate and
manage memory at runtime. Dynamic memory allocation is useful in scenarios where the
amount of memory required is not known at compile time. For instance, when reading user
input or handling data structures like linked lists and trees, memory needs vary depending on
the data’s size and complexity.

Allocation: The malloc function allocates memory of a specified size and returns a pointer to
the allocated memory. For example, int *arr = (int *)malloc(5 * sizeof(int)); allocates memory
for an integer array of 5 elements.

Initialization: The calloc function allocates memory and initializes it to zero, useful when a
block of memory needs to be set to a default value. For instance, int *arr = (int *)calloc(5,
sizeof(int)); allocates and initializes memory for 5 integers.

Reallocation: The realloc function adjusts the size of previously allocated memory, allowing
the program to expand or shrink the memory block as needed. For example, arr = (int
*)realloc(arr, 10 * sizeof(int)); resizes arr to hold 10 integers.

Deallocation: The free function releases dynamically allocated memory, ensuring that memory
is not wasted. Memory leaks occur when allocated memory is not properly freed, leading to
inefficient memory usage. In this example, free(arr); releases the memory previously allocated
for arr.

Dynamic memory allocation is crucial for building scalable applications that adapt to varying
data sizes. Without proper memory management, however, programs can suffer from memory

71
leaks, fragmentation, and crashes, making pointer-based memory management a skill that
requires careful attention to detail.

Array Manipulation

Pointers provide a convenient and efficient way to manipulate arrays, particularly in C and
C++. When an array is declared, a pointer to the first element is automatically created, allowing
array elements to be accessed using pointer arithmetic. For example, if int arr[5] = {1, 2, 3, 4,
5}; is an array of integers, setting int *ptr = arr; allows the program to access elements using
*(ptr + i) instead of arr[i].

Pointer-based array manipulation is beneficial in scenarios that involve complex calculations

or high-performance requirements. For example, in image processing, an image can be
represented as a two-dimensional array of pixels. By using pointers to iterate through the pixel
data, algorithms can efficiently apply filters, transformations, and enhancements without the
overhead of index-based access. Similarly, in scientific computing, arrays are used to store
matrices, vectors, and other data structures that require efficient traversal and manipulation for
mathematical calculations.

Implementing Linked Lists

Pointers are essential for implementing linked data structures like linked lists, where each
element (or node) contains a pointer to the next node. Linked lists provide a flexible alternative
to arrays, allowing dynamic insertion and deletion of elements without reallocating memory.
In a singly linked list, each node has two components: a data field and a pointer to the next
node. For example:
struct Node {

int data;

struct Node *next;

};

In this structure, struct Node *next; is a pointer to the next node in the list. To add or remove
elements, pointers are used to link and unlink nodes, enabling efficient data manipulation.

Linked lists are widely used in scenarios where data needs to be added or removed frequently,
such as in implementing stacks, queues, and dynamic buffers.

Pointers allow for efficient insertion and deletion operations in linked lists without the need to
72
shift elements, as is required with arrays. By updating the pointers, elements can be added or
removed from any position in the list. This flexibility makes linked lists suitable for
applications requiring dynamic data management, such as file systems, memory allocation, and
real-time data processing.

Pointers to Functions

Function pointers allow a pointer to reference a function rather than a data variable, enabling
dynamic selection of functions at runtime. In languages like C, function pointers are commonly
used to create callback functions, where one function is passed as an argument to another
function. For example, in event-driven programming, function pointers are used to define
actions that occur in response to specific events.

Function pointers are also used to implement polymorphism in C, enabling different functions
to be called based on the context. For instance, in sorting algorithms, a function pointer can
specify the comparison function, allowing the sorting criteria to be customized dynamically.
Function pointers make programs more flexible and modular by allowing runtime function
selection and are widely used in applications like operating systems, GUIs, and libraries.

Pointer-Based String Manipulation

Pointers are particularly useful for manipulating strings in low-level programming, where
strings are represented as arrays of characters. In C, strings are null-terminated character arrays,
and pointers can be used to traverse, modify, or analyze strings efficiently. For example, a
function to calculate the length of a string could use a pointer to iterate through the characters
until the null terminator is reached:
int strlen(char *str) {

char *ptr = str;

while (*ptr != '\0') {

ptr++;

}
return ptr - str;
}

In this example, ptr moves through the string, and the difference ptr - str yields the length of
the string. Pointer-based string manipulation is essential for building low-level text processing
functions, such as parsing, formatting, and encoding. Pointers allow strings to be handled as
73
dynamic data structures, optimizing performance in memory-constrained environments.

Pointers and memory management are foundational concepts in programming, providing a

powerful means of accessing and manipulating memory directly. Understanding pointers,
pointer arithmetic, and memory management techniques is essential for writing efficient, high-
performance code. Pointers enable dynamic memory allocation, flexible data structures like
linked lists, efficient array manipulation, and function pointers for runtime flexibility.
However, pointers also require careful handling to avoid errors like memory leaks and
segmentation faults, making pointer management a critical skill for programmers working in
low-level languages. Mastering pointers allows developers to optimize resource usage, manage
memory effectively, and build applications that are both robust and efficient.

3.4 Linked Lists: Types (Singly, Doubly, Circular, Circular doubly) and Operations

Fig 17 : Types of Linked Lists

Linked lists are dynamic data structures that store elements (known as nodes) in a non-
contiguous manner, connected by pointers. Unlike arrays, which require contiguous memory
allocation and fixed size, linked lists are flexible and can grow or shrink as needed, making
them efficient for dynamic data handling. Each node in a linked list contains a data element
and one or more pointers that link it to other nodes. This unique structure allows for efficient
insertion and deletion of nodes without requiring data to be shifted, as is the case with arrays.
Linked lists are fundamental in computer science and are widely used in scenarios requiring
flexible memory usage and dynamic data structures.

74
 Types of Linked Lists and Differences

Linked lists come in several types, each with distinct structures and advantages depending on
the specific application. The three main types are singly linked lists, doubly linked lists, and
circular linked lists.

Singly Linked List

A singly linked list is the simplest type of linked list, where each node contains data and a
pointer to the next node in the sequence. The last node in the list has a NULL pointer, indicating
the end of the list. Singly linked lists only allow traversal in one direction (from the head to the
last node), making them suitable for applications that require sequential data access. For
example, in a singly linked list with nodes [10] -> [20] -> [30] -> NULL, each node points to
the next, and the list terminates when it reaches NULL.

Singly linked lists are memory-efficient, as each node only requires one pointer. They are easy
to implement and ideal for simple applications where backward traversal is not necessary, such
as managing a list of tasks in a queue. However, singly linked lists have limitations, such as
lack of backward traversal, making some operations less efficient.

Example: Singly Linked List

Here is an example demonstrating the creation, traversal, and insertion of nodes in a singly
linked list:

Implementation of Singly Linked List

#include <stdio.h>
#include <stdlib.h>

// Define the structure of a node

75
struct Node {
int data;
struct Node* next;
};
// Function to create a new node
struct Node* createNode(int data) {
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = data;
newNode->next = NULL;
return newNode;
}
// Function to traverse and print the linked list
void printList(struct Node* head) {
struct Node* temp = head;
printf("Linked List: ");
while (temp != NULL) {
printf("%d -> ", temp->data);
temp = temp->next;
}
printf("NULL\n");
}
// Function to insert a new node at the end of the linked list
void insertAtEnd(struct Node** head, int data) {
struct Node* newNode = createNode(data);
if (*head == NULL) {
*head = newNode;
return;
}
struct Node* temp = *head;
while (temp->next != NULL) {
temp = temp->next;
}
temp->next = newNode;
}
// Function to insert a new node at the beginning of the linked list
void insertAtBeginning(struct Node** head, int data) {
struct Node* newNode = createNode(data);

76
 newNode->next = *head;
*head = newNode;
}
int main() {
struct Node* head = NULL;
// Insert nodes into the linked list
insertAtEnd(&head, 10);
insertAtEnd(&head, 20);
insertAtEnd(&head, 30);
printList(head); // Output: 10 -> 20 -> 30 -> NULL
// Insert a node at the beginning
insertAtBeginning(&head, 5);
printList(head); // Output: 5 -> 10 -> 20 -> 30 -> NULL
return 0;
}

Output:

Linked List: 10 -> 20 -> 30 -> NULL

Linked List: 5 -> 10 -> 20 -> 30 -> NULL

Doubly Linked List

A doubly linked list extends the singly linked list by including two pointers in each node: one
pointing to the next node and one pointing to the previous node. This structure allows traversal
in both directions, forward and backward, making doubly linked lists more flexible than singly
linked lists. For example, a doubly linked list with nodes [10] <-> [20] <-> [30] allows
movement from 10 to 30 and vice versa.

77
Example: Doubly Linked List in
Below is an example demonstrating the creation, traversal, and insertion operations in a doubly linked list:
Implementation of Doubly Linked List
#include <stdio.h>
#include <stdlib.h>
// Define the structure of a node
struct Node {
int data;
struct Node* next;
struct Node* prev;
};
// Function to create a new node
struct Node* createNode(int data) {
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = data;
newNode->next = NULL;
newNode->prev = NULL;
return newNode;
}
// Function to traverse the list forward
void printForward(struct Node* head) {
struct Node* temp = head;
printf("Forward Traversal: ");
while (temp != NULL) {
printf("%d <-> ", temp->data);
temp = temp->next;
}
printf("NULL\n");
}

// Function to traverse the list backward

void printBackward(struct Node* tail) {
struct Node* temp = tail;
printf("Backward Traversal: ");
while (temp != NULL) {
printf("%d <-> ", temp->data);

78
 temp = temp->prev;
}
printf("NULL\n");
}

// Function to insert a new node at the end of the list

void insertAtEnd(struct Node** head, struct Node** tail, int data) {
struct Node* newNode = createNode(data);
if (*head == NULL) { // If the list is empty
*head = *tail = newNode;
return;
}
(*tail)->next = newNode;
newNode->prev = *tail;
*tail = newNode;
}
// Function to insert a new node at the beginning of the list
void insertAtBeginning(struct Node** head, struct Node** tail, int data) {
struct Node* newNode = createNode(data);
if (*head == NULL) { // If the list is empty
*head = *tail = newNode;
return;
}
newNode->next = *head;
(*head)->prev = newNode;
*head = newNode;
}
int main() {
struct Node* head = NULL;
struct Node* tail = NULL;
// Insert nodes into the doubly linked list
insertAtEnd(&head, &tail, 10);
insertAtEnd(&head, &tail, 20);
insertAtEnd(&head, &tail, 30);
printForward(head); // Output: 10 <-> 20 <-> 30 <-> NULL
printBackward(tail); // Output: 30 <-> 20 <-> 10 <-> NULL

79
 // Insert a node at the beginning
insertAtBeginning(&head, &tail, 5);
printForward(head); // Output: 5 <-> 10 <-> 20 <-> 30 <-> NULL
printBackward(tail); // Output: 30 <-> 20 <-> 10 <-> 5 <-> NULL

return 0;
}
Output :
Forward Traversal: 10 <-> 20 <-> 30 <-> NULL
Backward Traversal: 30 <-> 20 <-> 10 <-> NULL
Forward Traversal: 5 <-> 10 <-> 20 <-> 30 <-> NULL
Backward Traversal: 30 <-> 20 <-> 10 <-> 5 <-> NULL

Doubly linked lists are useful in scenarios requiring bidirectional traversal, such as in undo/redo
functionality, where movement between states is essential. However, the additional pointer in
each node increases memory usage, making doubly linked lists less memory-efficient than
singly linked lists. The added complexity in managing both pointers also increases the potential
for pointer-related errors.

Circular Linked List

A circular linked list is a variation of linked lists where the last node points back to the first
node, forming a circular structure. Circular linked lists can be singly or doubly linked. In a
circular singly linked list, each node points to the next node, and the last node points back to
the head, while in a circular doubly linked list, each node has pointers to both the next and
previous nodes, with the last node connecting back to the first node and vice versa.
Circular linked lists are particularly useful for applications requiring continuous traversal or
cyclic structures, such as round-robin scheduling in operating systems, where each task is
assigned a time slice in a circular fashion. By connecting the last node to the head, circular
linked lists enable repeated iterations without needing to reset to the start, making them ideal
for implementing circular buffers or queues.

80
 Example: Circular Singly Linked List
Below is an example of implementing a circular singly linked list with creation, traversal, and
insertion operations.
Implementation of Circular Singly Linked List
#include <stdio.h>
#include <stdlib.h>
// Define the structure of a node
struct Node {
int data;
struct Node* next;
};
// Function to create a new node
struct Node* createNode(int data) {
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = data;
newNode->next = NULL;
return newNode;
}
// Function to traverse and print the circular linked list
void printList(struct Node* head) {
if (head == NULL) {
printf("The list is empty.\n");
return;
}
struct Node* temp = head;
printf("Circular Linked List: ");
do {
printf("%d -> ", temp->data);
81
 temp = temp->next;
} while (temp != head);
printf("(Back to head)\n");
}
// Function to insert a node at the end of the circular linked list
void insertAtEnd(struct Node** head, int data) {
struct Node* newNode = createNode(data);
if (*head == NULL) {
*head = newNode;
newNode->next = *head; // Point the new node to itself
return;
}
struct Node* temp = *head;
while (temp->next != *head) { // Traverse to the last node
temp = temp->next;
}
temp->next = newNode; // Point the last node to the new node
newNode->next = *head; // Point the new node to the head
}

// Function to insert a node at the beginning of the circular linked list

void insertAtBeginning(struct Node** head, int data) {
struct Node* newNode = createNode(data);
if (*head == NULL) {
*head = newNode;
newNode->next = *head; // Point the new node to itself
return;
}
struct Node* temp = *head;
while (temp->next != *head) { // Traverse to the last node
temp = temp->next;
}
temp->next = newNode; // Update the last node's next pointer
newNode->next = *head; // Point the new node to the current head
*head = newNode; // Update head to the new node
}

82
int main() {
struct Node* head = NULL;
// Insert nodes into the circular linked list
insertAtEnd(&head, 10);
insertAtEnd(&head, 20);
insertAtEnd(&head, 30);
printList(head); // Output: 10 -> 20 -> 30 -> (Back to head)
// Insert a node at the beginning
insertAtBeginning(&head, 5);
printList(head); // Output: 5 -> 10 -> 20 -> 30 -> (Back to head)

return 0;
}
Output:
Circular Linked List: 10 -> 20 -> 30 -> (Back to head)
Circular Linked List: 5 -> 10 -> 20 -> 30 -> (Back to head)

Circular Doubly Linked List

A Circular Doubly Linked List (CDLL) is a type of linked data structure that combines the
features of both doubly linked lists and circular linked lists. In this list.Each node contains three
fields:

o Data field: Stores the value of the node.

o Next pointer: Points to the next node in the sequence.

o Previous pointer: Points to the previous node in the sequence.

The last node's next pointer points to the first node, and the first node's previous pointer points

to the last node, making the list circular in both directions.

83
 Example: Circular Doubly Linked List
#include <stdio.h>
#include <stdlib.h>
// Define the structure of a node
typedef struct Node {
int data;
struct Node* next;
struct Node* prev;
} Node;
// Function to create a new node
Node* createNode(int data) {
Node* newNode = (Node*)malloc(sizeof(Node));
newNode->data = data;
newNode->next = newNode->prev = NULL;
return newNode;
}
// Function to insert a node at the end of the circular doubly linked list
void insertEnd(Node** head, int data) {
Node* newNode = createNode(data);
if (*head == NULL) {
newNode->next = newNode->prev = newNode;
*head = newNode;
return;
}
Node* tail = (*head)->prev;
newNode->next = *head;
newNode->prev = tail;
tail->next = newNode;
(*head)->prev = newNode;
}
// Function to display the list in forward direction
void displayForward(Node* head) {
if (head == NULL) {
printf("List is empty.\n");
return;
}

84
 Node* temp = head;
do {
printf("%d ", temp->data);
temp = temp->next;
} while (temp != head);
printf("\n");
}
// Function to display the list in backward direction
void displayBackward(Node* head) {
if (head == NULL) {
printf("List is empty.\n");
return;
}
Node* tail = head->prev;
Node* temp = tail;
do {
printf("%d ", temp->data);
temp = temp->prev;
} while (temp != tail);
printf("\n");
}
// Main function
int main() {
Node* head = NULL;
// Insert nodes into the list
insertEnd(&head, 10);
insertEnd(&head, 20);
insertEnd(&head, 30);
insertEnd(&head, 40);
// Display the list in forward and backward directions
printf("Circular Doubly Linked List (Forward): ");
displayForward(head);
printf("Circular Doubly Linked List (Backward): ");
displayBackward(head);
return 0;
}

85
 Output:
Circular Doubly Linked List (Forward): 10 20 30 40
Circular Doubly Linked List (Backward): 40 30 20 10

Operations on Linked Lists (Insertion, Deletion, Traversal)

Traversal

Traversal in linked lists involves visiting each node in sequence to access or modify data. In a
singly linked list, traversal proceeds from the head to the last node, following the pointers in
each node. In doubly linked lists, traversal can occur in either direction, starting from the head
to the end or vice versa. In circular linked lists, traversal continues in a loop, restarting from
the head after reaching the end.

Traversal has a time complexity of O(n) in linked lists, as each node must be visited
sequentially. Traversal is used in various applications, such as searching for an element,
printing the list, or performing operations on each node.

Traversal is the process of visiting each node in a linked list sequentially. It's a fundamental
operation used in many other linked list operations.

How Traversal Works:

1. Start at the head node of the list.

2. Access the data of the current node.

3. Move to the next node using the next pointer.

4. Repeat steps 2 and 3 until reaching the end of the list (when next is null for a singly linked
list)1.
Linked lists support various operations, with insertion, deletion, and traversal being the most
common. These operations enable manipulation of the linked list structure and data, allowing
nodes to be added, removed, or accessed as needed.

Insertion

Insertion involves adding a new node to the linked list. There are three common insertion
scenarios:

1. Insertion at the beginning:

86
Create a new node.

Set its next pointer to the current head.

Update the head to point to the new node.

2. Insertion at the end:

Traverse to the last node.

Create a new node.

Set the last node's next pointer to the new node.

3. Insertion at a specific position:

Traverse to the node just before the desired position.

Create a new node.

Set the new node's next pointer to the current node's next.

Set the current node's next pointer to the new node

Insertion in linked lists involves adding a new node at a specified position, such as at the
beginning, middle, or end of the list.

Insertion at the Beginning: In a singly linked list, a new node is created, and its pointer is set
to the current head of the list. The head pointer is then updated to point to the new node, making
it the first node. In doubly linked lists, the new node’s next pointer is set to the current head,
and the head’s previous pointer is set to the new node.

Insertion at the End: Insertion at the end requires traversing the list to reach the last node,
then setting the last node’s pointer to the new node. For a doubly linked list, the previous pointer
of the new node is set to the current last node, and the next pointer is updated to NULL.

Insertion in the Middle: Insertion at a specific position involves locating the node after which
the new node should be inserted. Once located, the new node’s pointer is set to the subsequent
node, and the previous node’s pointer is updated to the new node. In doubly linked lists, the
previous pointer of the next node is also updated to point to the new node.

Insertion in linked lists is generally efficient, with a time complexity of O(1) for inserting at
the beginning or end, as it does not require shifting elements as in arrays. However, insertion
in the middle requires traversal, leading to an O(n) complexity for locating the position.
87
Deletion

Deletion removes a node from the linked list. There are three main deletion scenarios:

1. Deletion at the beginning:

Update the head to point to the second node.

2. Deletion at the end:

Traverse to the second-to-last node.

Set its next pointer to null.

3. Deletion of a specific node:

Traverse to find the node to be deleted and its predecessor.

Update the predecessor's next pointer to skip the node to be deleted.

Deletion at the Beginning: The head node is deleted by updating the head pointer to the next
node in the list. In doubly linked lists, the next node’s previous pointer is set to NULL.

Deletion at the End: Deletion at the end requires traversal to reach the last node, then updating
the pointer of the second-last node to NULL. In doubly linked lists, the second-last node’s next
pointer is updated, and the last node is removed.

Deletion in the Middle: Deletion of a node in the middle involves adjusting the pointers of the
surrounding nodes to bypass the node to be deleted. In a doubly linked list, both the previous
and next pointers need to be adjusted.

Like insertion, deletion is generally efficient in linked lists, with O(1) complexity for deletion
at the beginning and O(n) complexity for locating a specific node in the middle.

88
 Linked List Applications and Use Cases

Linked lists are used in numerous real-world applications due to their flexibility, dynamic
memory management, and efficient data manipulation capabilities.

Fig 18: Uses of Linked Lists

Dynamic Memory Allocation

Linked lists are often used in dynamic memory allocation, where memory requirements vary
at runtime. By storing memory blocks as linked nodes, memory can be allocated and
deallocated as needed, avoiding the fixed allocation issues associated with arrays. Linked lists
are particularly useful in implementing memory management functions in operating systems,

such as free lists, where each free memory block is linked, enabling efficient allocation and
deallocation.

89
Implementing Stacks and Queues

Stacks and queues are frequently implemented using linked lists, as they provide efficient
insertion and deletion at one or both ends. A stack, which follows a Last In, First Out (LIFO)
principle, can be implemented using a singly linked list, where elements are added and removed
from the beginning of the list. A queue, which follows a First In, First Out (FIFO) principle,
can use a singly or doubly linked list to allow insertion at one end and deletion at the other.
Linked lists offer flexibility in managing dynamic data structures like stacks and queues
without requiring contiguous memory.

Undo and Redo Operations

In applications requiring undo and redo functionality, such as text editors, doubly linked lists
are ideal. Each action is stored as a node in the list, allowing traversal forward for redo and
backward for undo. By linking actions bidirectionally, users can navigate through the history
of actions in both directions, enhancing the functionality of the application. This bidirectional
structure simplifies tracking changes and restoring previous states, making doubly linked lists
an efficient solution for managing history.

Circular Buffers

Circular linked lists are commonly used in implementing circular buffers, which are essential
in applications requiring continuous data storage, such as audio processing or data streaming.
Circular buffers store data in a loop, allowing new data to overwrite old data when the buffer
is full. By linking the last node back to the first, circular linked lists enable continuous traversal
without the need for resetting, making them suitable for managing streaming data or
implementing time-sharing systems.

3.5 Practice Programs

Singly Linked List Implementation

Objective: Implement a singly linked list with operations for insertion at the beginning, deletion
from the end, and traversal.

Description: Create a Node structure containing an integer data field and a pointer to the next
node. Write functions to insert a new node at the beginning, delete the last node, and traverse
the list, printing each element.

90
Doubly Linked List with Insertion and Deletion

Objective: Implement a doubly linked list that supports insertion at both ends and deletion from
any position.

Description: Define a Node structure with data, next, and prev pointers. Implement functions
to insert nodes at the beginning and end, delete nodes at a given position, and print the list in
both forward and backward directions.

Circular Linked List for Round-Robin Scheduling

Objective: Implement a circular linked list to simulate round-robin scheduling.

Description: Create a circular linked list where each node represents a process with a
process_id field. Implement a traversal function that loops through processes in a circular
manner, simulating a round-robin schedule for process execution.

Stack and Queue Using Linked List

Objective: Use singly linked lists to implement stack (LIFO) and queue (FIFO) structures.

Description: Implement push, pop, and display operations for the stack. For the queue,
implement enqueue, dequeue, and display functions, using a singly linked list for each
structure.

Undo/Redo System with Doubly Linked List

Objective: Create an undo/redo system using a doubly linked list.

Description: Each node represents an action, and traversal from head to tail allows redo, while
traversal backward enables undo. Implement add action, undo, and redo functions to simulate
text editor behavior.

91
MCQ:

Which of the following is the correct definition of an array?

(A) A collection of similar data elements stored in a non-contiguous memory location

(B) A collection of different data elements stored in a contiguous memory location
(C) A collection of similar data elements stored in contiguous memory locations
(D) A collection of different data elements stored in non-contiguous memory locations
Answer: (C)

The index of the first element of an array in most programming languages is:

(A) 1
(B) 0
(C) -1
(D) Depends on the programming language
Answer: (B)

Which of the following functions is used to find the length of a string in C?

(A) strlength()
(B) strlen()
(C) length()
(D) size()
Answer: (B)

Which of the following operations can be performed on a string in most programming languages?

(A) Concatenation
(B) Traversal
(C) Comparison
(D) All of the above
Answer: (D)

In C, which of the following is used to declare a string variable?

(A) char str[];

(B) string str[];
(C) string str;
(D) char str[100];
Answer: (D)

What is the primary use of a pointer in data structures?

(A) To allocate memory dynamically

(B) To access elements in an array
(C) To link nodes in linked lists
(D) To sort data
Answer: (C)

92
What is the key advantage of a linked list over an array?

(A) Fixed size

(B) Fast access to elements
(C) Dynamic memory allocation
(D) Easier debugging
Answer: (C)
What is the advantage of a circular linked list over a singly linked list?

(A) Memory efficiency

(B) Allows traversal from any node
(C) Easier deletion of nodes
(D) Fixed size
Answer: (B)

93
 CHAPTER 4

Stacks and Queue

4.1 Stacks: Operations (Push, Pop, Peek, etc.), Applications, and Implementations

A stack is a linear data structure that follows the Last In, First Out (LIFO) principle, meaning
that the last element added is the first to be removed. Stacks are a fundamental concept in
computer science and are widely used in various applications, including function call
management, expression evaluation, undo mechanisms, and more. The stack structure consists
of a series of elements, with the ability to add and remove elements only at the “top” of the
stack. This simple but powerful approach makes stacks ideal for scenarios where the order of
processing is reversed, as each addition or removal happens from a single end. In this section,
we will explore basic stack operations, implement a stack using arrays and linked lists, and
discuss real-world applications of stacks.

Basic Stack Operations

Stacks support several core operations, including push, pop, and peek. These operations allow
the addition, removal, and retrieval of elements, making stacks flexible and efficient for
handling data that requires a LIFO approach.

Fig 1 9 : Stack Operations: Push and Pop

94
  Applications of Stacks

Push:

Fig 20: Push operation

The push operation adds a new element to the top of the stack. If the stack has available
capacity, the element is placed on top of the current top element, becoming the new top. In a
stack implemented with an array, the push operation increments the top index and assigns the
new element to that index. In a linked list-based stack, a new node is created, and its pointer is
set to the previous top node.

For example, if a stack currently contains [5, 10, 15] (with 15 as the top), a push operation
adding 20 will update the stack to [5, 10, 15, 20], with 20 as the new top. Push operations are
typically O(1) in time complexity, as they require only updating the top reference.

95
Pop:

Fig 21 : Pop Operation

The pop operation removes the top element from the stack and returns it. This operation is only
possible if the stack is not empty. In an array-based stack, the top index is decremented to
effectively remove the element, while in a linked list-based stack, the top node is deleted, and
the next node becomes the new top. If a stack contains [5, 10, 15, 20], a pop operation will
remove 20, returning it and leaving [5, 10, 15] with 15 as the new top. Pop operations are also
O(1) in time complexity.

Peek:

Fig 22 : Peek Operation

96
 The peek operation retrieves the top element without removing it from the stack. This operation
provides access to the last element added without altering the stack’s contents. Peek is useful
for examining the top of the stack without modifying it, such as checking the last element
processed in a sequence. For a stack [5, 10, 15, 20], a peek operation will return 20 without
changing the stack’s structure.

IsEmpty and IsFull

In implementations that use arrays with fixed sizes, stacks may include IsFull to check if the
stack has reached its maximum capacity, preventing further push operations. Both array-based
and linked list-based stacks also use IsEmpty to verify if the stack is empty, ensuring that pop
or peek operations are only performed when elements are available. These checks help prevent
errors like stack underflow and overflow, ensuring the stack’s integrity.

 Applications of Stack

Stacks have several important applications in computer science and programming:

Expression Evaluation and Conversion

Applications of Stack in Expression Evaluation and Conversion

Stacks are widely used in the evaluation and conversion of expressions in computer science. Below are
key types of expressions and examples illustrating the role of stacks.

1. Expression Types:
Infix Expression: Operators are written between operands.
Example: A + B * C
Prefix Expression: Operators are written before operands.
Example: + A * B C
Postfix Expression: Operators are written after operands.
Example: A B C * +

2. Expression Evaluation Using Stack:

Stacks are used to evaluate postfix expressions since the order of operations is inherent, and parentheses
are not required.
Algorithm for Evaluating Postfix Expression:
Start: Create an empty stack.

97
Read the Expression:
For each symbol in the postfix expression:
If the symbol is an operand, push it onto the stack.
If the symbol is an operator, pop the top two elements from the stack.
Apply the operator to these elements.
Push the result back onto the stack.
Result:
When the expression is fully traversed, the result will be at the top of the stack.
End.

Example of Postfix Evaluation:

Evaluate: 2 3 + 4 *
Step 1: Read 2, push onto the stack: Stack = [2]
Step 2: Read 3, push onto the stack: Stack = [2, 3]
Step 3: Read +, pop 3 and 2, calculate 2 + 3 = 5, push 5: Stack = [5]
Step 4: Read 4, push onto the stack: Stack = [5, 4]
Step 5: Read *, pop 4 and 5, calculate 5 * 4 = 20, push 20: Stack = [20]
Result: 20

3. Expression Conversion Using Stack:

Infix to Postfix Conversion Algorithm:
Start: Create an empty stack and an output list.
Scan the Expression:
If the symbol is an operand, add it to the output.
If the symbol is an operator:
Pop operators from the stack with higher or equal precedence and append to output.
Push the current operator onto the stack.
If the symbol is an opening parenthesis (, push it onto the stack.
If the symbol is a closing parenthesis ), pop from the stack until an opening parenthesis is encountered.
End:
Append any remaining operators in the stack to the output list.

Example of Infix to Postfix Conversion:

Convert: (A + B) * C

98
Step 1: Read (, push onto stack: Stack = [(]
Step 2: Read A, add to output: Output = [A]
Step 3: Read +, push onto stack: Stack = [(, +]
Step 4: Read B, add to output: Output = [A, B]
Step 5: Read ), pop and add to output: Output = [A, B, +], Stack = []
Step 6: Read *, push onto stack: Stack = [*]
Step 7: Read C, add to output: Output = [A, B, +, C]
Step 8: Append remaining operators in stack to output: Output = [A, B, +, C, *]
Result: A B + C *

Conclusion:
Stacks play a critical role in managing and evaluating the precedence and associativity of operators during
expression evaluation and conversion. These techniques are fundamental in building compilers and
interpreters for programming languages.

Infix to Postfix/Prefix Conversion: Stacks are used to convert infix expressions (e.g., A + B * C) to postfix
(ABC*+) or prefix (+A*BC) notation.

Postfix/Prefix Evaluation: Stacks efficiently evaluate postfix and prefix expressions.

Function Call Management

Call Stack: Programming languages use a stack to manage function calls and local variables.

Undo Mechanism
Undo/Redo Operations: Applications use stacks to implement undo and redo functionality.

Backtracking Algorithms
Depth-First Search: Stacks are crucial in implementing depth-first search algorithms.

Parsing
Syntax Parsing: Compilers and interpreters use stacks for parsing programming language syntax

99
  Tower of Hanoi
The Tower of Hanoi is a classic mathematical puzzle that involves three rods and a number of
disks of different sizes. The disks are stacked on one rod in descending order, with the largest disk
at the bottom and the smallest at the top. The goal is to move the entire stack to another rod,
following
these rules:
Rules:
1. Move one disk at a time.
2. Only the top disk of a stack can be moved.
3. No disk may be placed on top of a smaller disk.

The Tower of Hanoi is a classic recursive problem in computer science:

Problem Description
The puzzle consists of three rods and a number of disks of different sizes.
Initially, all disks are stacked on one rod in order of decreasing size.
The objective is to move the entire stack to another rod, following specific rules.
Recursive Solution
The recursive algorithm for solving the Tower of Hanoi follows these steps:
100
Move n-1 disks from the source rod to the auxiliary rod.
Move the nth (largest) disk from the source rod to the target rod.
Move the n-1 disks from the auxiliary rod to the target rod.

Implementation
#include <stdio.h>
// Function to solve Tower of Hanoi
void towerOfHanoi(int n, char source, char destination, char auxiliary) {
if (n == 1) {
printf("Move disk 1 from %c to %c\n", source, destination);
return;
}
// Step 1: Move n-1 disks from source to auxiliary
towerOfHanoi(n - 1, source, auxiliary, destination);
// Step 2: Move the nth disk from source to destination
printf("Move disk %d from %c to %c\n", n, source, destination);
// Step 3: Move n-1 disks from auxiliary to destination
towerOfHanoi(n - 1, auxiliary, destination, source);
}
int main() {
int n;
printf("Enter the number of disks: ");
scanf("%d", &n);

printf("The sequence of moves:\n");

towerOfHanoi(n, 'A', 'C', 'B'); // A is the source, C is the destination, B is the auxiliary
return 0;
}
Enter the number of disks: 3
The sequence of moves:
Move disk 1 from A to C
Move disk 2 from A to B
Move disk 1 from C to B
Move disk 3 from A to C
Move disk 1 from B to A
Move disk 2 from B to C
Move disk 1 from A to C
101
Time Complexity
The time complexity of the Tower of Hanoi algorithm is O(2^n), where n is the number of disks.
 Recursion
Recursion is a problem-solving technique where a function calls itself to solve smaller instances of the
same problem:
Key Concepts
1. Base Case: A condition to stop the recursion. Without a base case, the function will call itself
indefinitely, causing a stack overflow.
2. Recursive Case: The part of the function where the problem is divided into smaller sub-problems,
and the function calls itself.
How Recursion Works
When a function calls itself:
1. Each call is added to the call stack.
2. The function keeps executing until it hits the base case.
3. Then, the calls start returning in reverse order (from the last call to the first).

102
Example: Factorial Calculation
Factorial of a number n is defined as:
n!=n×(n−1)!, with 0!= 1
#include <stdio.h>
int factorial(int n) {
if (n == 0 || n == 1) { // Base case
return 1;
}
return n * factorial(n - 1); // Recursive case
}
int main() {
int num;
printf("Enter a number: ");
scanf("%d", &num);
printf("Factorial of %d is %d\n", num, factorial(num));
return 0;
}

Disadvantages of Recursion
1. Memory Overhead: Each recursive call uses stack space, which can lead to a stack overflow for
large inputs.
2. Performance: Recursive solutions may be slower due to repeated computations (e.g., Fibonacci
without memoization).
3. Debugging: Debugging recursive functions can be more challenging than iterative ones.

Implementing a Stack Using Arrays and Linked Lists

Stacks can be implemented using different data structures, with arrays and linked lists being
the most common. Each approach has advantages and trade-offs, allowing programmers to
select the best implementation based on specific requirements.

 Array-Based Stack Implementation

In an array-based stack, elements are stored in a contiguous block of memory, with a fixed size
defined at the start. This implementation uses an integer variable, often called top, to keep track
of the index of the last element in the stack. The array-based stack is efficient, with push and
pop operations performed in constant time O(1) by updating the top index.

103
  Initialization: An array and a top variable are created. The top is initially set to -1 to
indicate that the stack is empty.
 Push Operation: The top index is incremented, and the new element is assigned to
stack[top]. If top reaches the maximum size of the array, the stack is considered full.
 Pop Operation: The element at stack[top] is returned, and top is decremented. If top
becomes -1, the stack is empty.
 Peek Operation: The element at stack[top] is returned without modifying top.

Array-based stacks are straightforward and memory-efficient for fixed-size stacks. However,
they lack flexibility, as the stack’s maximum size is predetermined. If more elements are

needed than the stack’s fixed size, a new stack with a larger array must be created, which
involves copying elements and reinitializing the stack.

 Linked List-Based Stack Implementation

A linked list-based stack uses nodes to represent each element, where each node points to the
next node in the stack. The top of the stack is a pointer to the head of the linked list, making
linked lists naturally suited for dynamic stacks.

 Initialization: A pointer variable top is set to NULL, indicating an empty stack.

 Push Operation: A new node is created with the desired data, and its next pointer is set
to the current top node. The top pointer is updated to the new node.
 Pop Operation: The data in the top node is returned, the top pointer is updated to the
next node, and the old top node is deleted.
 Peek Operation: The data in the top node is returned without modifying the linked list.

Linked list-based stacks are flexible and support dynamic memory allocation, allowing the
stack to grow or shrink as needed. There is no fixed limit on the stack’s size, as memory is
allocated for each new node. This implementation is especially useful in applications with
varying data sizes. However, it requires additional memory for the pointer in each node and is
slightly slower than array-based stacks due to dynamic memory allocation and pointer
manipulation.

Applications of Stacks in Real-World Scenarios

Stacks have numerous applications in computer science and real-world scenarios, especially
where the LIFO principle is essential. From expression evaluation to function call management,
stacks are indispensable in managing temporary data and maintaining a structured order of

104
operations.

Expression Evaluation and Syntax Parsing

Stacks are widely used in expression evaluation and syntax parsing, especially for evaluating
arithmetic expressions. In expressions written in infix notation (e.g., 3 + (4 * 5)), parentheses
affect the order of operations, making evaluation more complex. Converting infix expressions
to postfix notation (e.g., 3 4 5 * +) simplifies evaluation by removing parentheses and adhering
to a strict operation order.

The Shunting Yard algorithm, which uses a stack, is commonly used to convert infix
expressions to postfix. A stack temporarily stores operators, while operands are output
immediately. When the expression is evaluated, the operators are applied to the operands in the
correct order, ensuring accurate results. Stacks are also used in syntax parsing for verifying
balanced parentheses, where every opening bracket ( must have a corresponding closing
bracket ).

Function Call Management (Call Stack)

The call stack is a specialized stack used in programming languages to manage function calls.
Each time a function is called, a new activation record (or stack frame) is pushed onto the stack,
storing information such as the return address, local variables, and function arguments. When
the function completes, its activation record is popped from the stack, and control returns to
the previous function.

The call stack is crucial for handling recursive functions, where each function call adds a new
frame to the stack until the base case is reached. Once the base case is completed, each frame
is popped as the recursion unwinds. This stack-based approach allows for the tracking of
function calls in a controlled manner, ensuring that each function’s local environment is
preserved. The call stack is integral to function execution, making it a core feature of most
programming languages.

Undo Mechanisms

Many applications, such as text editors and graphic design tools, use stacks to implement undo
functionality. Each action performed by the user is pushed onto a stack. When the user clicks
“Undo,” the last action is popped from the stack, and the application reverts to the previous
state. This process allows multiple actions to be undone in reverse order, consistent with the

105
LIFO structure.

An additional stack is often used for redo functionality, where actions popped from the undo
stack are pushed onto a redo stack. This setup allows the user to redo actions if they change
their mind. Stacks provide a structured way to manage reversible actions, enhancing the user
experience in applications that require frequent changes or adjustments.

Web Browser Navigation (Back and Forward)

Web browsers use stacks to implement back and forward navigation functionality. When a user
navigates to a new page, the current page is pushed onto the “back” stack, allowing the user to
return to the previous page. If the user clicks “Back,” the current page is pushed onto a
“forward” stack, enabling forward navigation.

This stack-based approach allows browsers to keep track of visited pages in a structured
manner, enabling users to move between pages in the order they were accessed. By using two
stacks, one for back and one for forward navigation, browsers can offer a smooth user
experience, allowing easy access to previously visited pages.

Memory Management in Algorithms

Some algorithms and data structures, such as Depth-First Search (DFS) in graph traversal, rely
on stacks to manage memory efficiently.

4.2 Queues: Types, Operations, and Applications

Fig 23 : Types of Queues

106
 A queue is a linear data structure that follows the First In, First Out (FIFO) principle, where
the first element added is the first to be removed. Unlike stacks, which follow a Last In, First
Out (LIFO) approach, queues are suitable for applications where elements need to be processed

In the order they arrive. Queues are widely used in various real-world applications, including task
scheduling, data buffering, customer service, and resource management. Queues support essential
operations such as enqueue (inserting an element) and dequeue (removing an element), along with
additional operations for peeking and checking the queue’s state. This section covers the types of
queues, queue operations and implementations, and practical applications of queues.

Types of Queues (Simple, Circular, Priority, Deque)

Fig 24: Detailed Visualization of Queue Types

107
Queues come in different types, each with unique characteristics suited to specific applications.
These types include simple queues, circular queues, priority queues, and deques (double-ended
queues).
Simple Queue
A simple queue (or linear queue) is the most basic type of queue, where elements are added at
one end (rear) and removed from the other end (front). In a simple queue, the order of elements
is maintained in a straightforward manner, with the first element inserted being the first one
removed. Simple queues are easy to implement but have a limitation: when the queue reaches
its maximum size, it cannot accept new elements even if there is unused space at the front. This
problem, known as the “false overflow” issue, occurs because elements are not shifted forward
to free up space at the beginning.

Simple queues are useful for basic applications that do not require cyclic behavior, such as
waiting lines or processing tasks in sequential order. However, they are less efficient in
memory usage compared to circular queues.

A simple queue (or linear queue) is a basic data structure where elements are inserted at the
rear (enqueue operation) and removed from the front (dequeue operation). The main
disadvantage of a simple queue is that when elements are removed from the front, the space at
the front is not reclaimed, leading to inefficient memory usage when elements are added again.
This issue is referred to as false overflow.

Simple Queue Operations

Enqueue: Add an element to the rear of the queue.

Dequeue: Remove an element from the front of the queue.

108
 Front: Get the front element of the queue without removing it.

Rear: Get the rear element of the queue.

IsEmpty: Check if the queue is empty.

IsFull: Check if the queue is full.

Size: Get the number of elements in the queue.

Implementation of a linear queue:

#include <stdio.h>
#define SIZE 5
// Simple Queue Structure
typedef struct {
int queue[SIZE];
int front;
int rear;
} SimpleQueue;
// Initialize the queue
void initializeQueue(SimpleQueue* q) {
q->front = -1;
q->rear = -1;
}
// Enqueue operation
void enqueue(SimpleQueue* q, int value) {
if (q->rear == SIZE - 1) {
printf("Queue is full!\n");
} else {
if (q->front == -1) {
q->front = 0;
}
q->rear++;
q->queue[q->rear] = value;
printf("Enqueued: %d\n", value);
}
}

// Dequeue operation
void dequeue(SimpleQueue* q) {
109
 if (q->front == -1) {
printf("Queue is empty!\n");
} else {
int dequeuedValue = q->queue[q->front];
printf("Dequeued: %d\n", dequeuedValue);
q->front++;
if (q->front > q->rear) {
q->front = q->rear = -1; // Reset the queue
}
}
}

// Peek front element

void peekFront(SimpleQueue* q) {
if (q->front == -1) {
printf("Queue is empty!\n");
} else {
printf("Front element: %d\n", q->queue[q->front]);
}
}

// Peek rear element

void peekRear(SimpleQueue* q) {
if (q->rear == -1) {
printf("Queue is empty!\n");
} else {
printf("Rear element: %d\n", q->queue[q->rear]);
}
}

// Check if the queue is empty

int isEmpty(SimpleQueue* q) {
return q->front == -1;
}

// Check if the queue is full

int isFull(SimpleQueue* q) {

110
 return q->rear == SIZE - 1;
}

// Get the size of the queue

int sizeOfQueue(SimpleQueue* q) {
if (q->front == -1) {
return 0;
}
return q->rear - q->front + 1;
}

// Display the queue contents

void display(SimpleQueue* q) {
if (q->front == -1) {
printf("Queue is empty!\n");
} else {
printf("Queue contents: ");
for (int i = q->front; i <= q->rear; i++) {
printf("%d ", q->queue[i]);
}
printf("\n");
}
}

// Example usage
int main() {
SimpleQueue q;
initializeQueue(&q);

// Enqueue elements
enqueue(&q, 10);
enqueue(&q, 20);
enqueue(&q, 30);
enqueue(&q, 40);
enqueue(&q, 50);
enqueue(&q, 60); // This will show "Queue is full!"

111
 // Display the queue
display(&q);

// Dequeue elements
dequeue(&q);
dequeue(&q);

// Display the queue after dequeue

display(&q);

// Check the front and rear elements

peekFront(&q);
peekRear(&q);

// Check if the queue is empty or full

printf("Is the queue empty? %s\n", isEmpty(&q) ? "Yes" : "No");
printf("Is the queue full? %s\n", isFull(&q) ? "Yes" : "No");

return 0;
}
//Size of the queue
printf("Size of the queue:", queue.size_of_queue())
Output:
Enqueued: 10
Enqueued: 20
Enqueued: 30
Enqueued: 40
Enqueued: 50
Queue is full!
Queue contents: 10 20 30 40 50
Dequeued: 10
Dequeued: 20
Queue contents: 30 40 50
Front element: 30
Rear element: 50
Is the queue empty? False
Is the queue full? False

112
Size of the queue: 3

Limitations of Simple Queue:

False Overflow: In a simple queue, when elements are dequeued, the unused space at the front
is not reclaimed. This results in inefficient memory usage.

Non-Cyclic: A simple queue does not reuse space at the front once elements are removed,
which makes it less efficient than a circular queue.

This basic queue can be extended or modified to include more advanced features like dynamic
resizing or circular behavior (which avoids the false overflow issue).

Circular Queue

A circular queue addresses the limitations of a simple queue by connecting the end of the queue
back to the front, forming a circular structure. In a circular queue, the rear pointer wraps around
to the beginning of the array when it reaches the end, allowing for efficient memory usage by
reusing freed space at the front. This cyclic behavior prevents the false overflow issue, making
circular queues ideal for situations where memory needs to be efficiently utilized.

Fig 25 : Circular_Queue

The image illustrates the concept of a circular queue, comparing it to a linear queue. It shows how
elements wrap around when the last position in the queue is filled, utilizing the first position if it is

113
free. This design optimizes memory usage by ensuring that no space is wasted in the queue, making
it ideal for scenarios requiring fixed-size buffers or cyclic data management.

For example, if a circular queue with a capacity of 5 currently holds elements in positions [10,
20, 30, 40, 50] and the front pointer is at 1 while the rear pointer is at 4, the next enqueue
operation will place the new element at position 0, filling the space previously used by the first
element. Circular queues are widely used in applications like buffering data in streaming
systems and implementing round-robin scheduling.

A circular queue is an improvement over the simple queue. It uses a circular or ring buffer to
efficiently use memory. In a simple queue, when elements are dequeued, the space at the front
cannot be reused. In a circular queue, however, when the rear pointer reaches the end of the
queue array, it wraps around to the front of the array (if there's space) to reuse the freed space.
This behavior eliminates the "false overflow" issue and allows for better memory utilization.

Key Properties:

Circular behavior: The queue behaves as if it's circular, meaning when the rear pointer reaches
the end of the array, it will move to the beginning if there is space available.

Efficient memory usage: Since the queue is circular, when elements are dequeued, that space
becomes available for new elements at the front, preventing memory wastage.

Queue operations: It supports the same operations as a simple queue but with cyclic behavior.

Circular Queue Operations

Enqueue: Add an element at the rear. If the rear reaches the end of the array, it wraps around
to the beginning.

Dequeue: Remove an element from the front. The front pointer moves forward, and if it reaches
the end, it wraps around to the beginning.

Front: Get the front element without removing it.

Rear: Get the rear element.

IsEmpty: Check if the queue is empty.

IsFull: Check if the queue is full.

114
 Get the number of elements in the queue.
#include <stdio.h>
#include <stdlib.h>
typedef struct CircularQueue {
int size; // Maximum size of the queue
int *queue; // Array to hold the queue elements
int front; // Front index of the queue
int rear; // Rear index of the queue
} CircularQueue;
// Initialize the circular queue
CircularQueue* createQueue(int size) {
CircularQueue* cq = (CircularQueue*)malloc(sizeof(CircularQueue));
cq->size = size;
cq->queue = (int*)malloc(size * sizeof(int));
cq->front = -1;
cq->rear = -1;
return cq;
}
// Enqueue operation: Add an element at the rear of the queue
void enqueue(CircularQueue* cq, int value) {
if ((cq->rear + 1) % cq->size == cq->front) { // Queue is full
printf("Queue is full!\n");
} else {
if (cq->front == -1) { // If the queue is empty
cq->front = 0;
}
cq->rear = (cq->rear + 1) % cq->size; // Circular increment
cq->queue[cq->rear] = value;
printf("Enqueued: %d\n", value);
}
}
// Dequeue operation: Remove an element from the front of the queue
void dequeue(CircularQueue* cq) {
if (cq->front == -1) { // Queue is empty
printf("Queue is empty!\n");
} else {
int dequeuedValue = cq->queue[cq->front];

115
 printf("Dequeued: %d\n", dequeuedValue);
if (cq->front == cq->rear) { // Queue will be empty
cq->front = cq->rear = -1;
} else {
cq->front = (cq->front + 1) % cq->size; // Circular increment
}
}
}
// Display the front element of the queue
void peekFront(CircularQueue* cq) {
if (cq->front == -1) {
printf("Queue is empty!\n");
} else {
printf("Front element: %d\n", cq->queue[cq->front]);
}
}
// Display the rear element of the queue
void peekRear(CircularQueue* cq) {
if (cq->rear == -1) {
printf("Queue is empty!\n");
} else {
printf("Rear element: %d\n", cq->queue[cq->rear]);
}
}
// Check if the queue is empty
int isEmpty(CircularQueue* cq) {
return cq->front == -1;
}
// Check if the queue is full
int isFull(CircularQueue* cq) {
return (cq->rear + 1) % cq->size == cq->front;
}
// Get the size of the queue
int sizeOfQueue(CircularQueue* cq) {
if (cq->front == -1) {
return 0;
} else if (cq->rear >= cq->front) {

116
 return cq->rear - cq->front + 1;
} else {
return cq->size - cq->front + cq->rear + 1;
}
}
// Display the contents of the queue
void display(CircularQueue* cq) {
if (cq->front == -1) {
printf("Queue is empty!\n");
} else {
printf("Queue contents: ");
int i = cq->front;
while (i != cq->rear) {
printf("%d ", cq->queue[i]);
i = (i + 1) % cq->size;
}
printf("%d\n", cq->queue[cq->rear]);
}
}
// Free the queue memory
void freeQueue(CircularQueue* cq) {
free(cq->queue);
free(cq);
}
// Example usage
int main() {
CircularQueue* queue = createQueue(5);
// Enqueue elements
enqueue(queue, 10);
enqueue(queue, 20);
enqueue(queue, 30);
enqueue(queue, 40);
enqueue(queue, 50);
enqueue(queue, 60); // This will show "Queue is full!"
// Display the queue
display(queue);
// Dequeue elements

117
 dequeue(queue);
dequeue(queue);
// Display the queue after dequeue
display(queue);
// Check the front and rear elements
peekFront(queue);
peekRear(queue);
// Check if the queue is empty or full
printf("Is the queue empty? %s\n", isEmpty(queue) ? "Yes" : "No");
printf("Is the queue full? %s\n", isFull(queue) ? "Yes" : "No");
// Size of the queue
printf("Size of the queue: %d\n", sizeOfQueue(queue));
// Enqueue more elements (reuse space from front)
enqueue(queue, 60);
enqueue(queue, 70);
// Display the queue after reuse of space
display(queue);
// Free the queue
freeQueue(queue);
return 0;
}
Output:
Enqueued: 10
Enqueued: 20
Enqueued: 30
Enqueued: 40
Enqueued: 50
Queue is full!
Queue contents: 10 20 30 40 50
Dequeued: 10
Dequeued: 20
Queue contents: 30 40 50
Front element: 30
Rear element: 50
Is the queue empty? False
Is the queue full? False
Size of the queue: 3

118
Enqueued: 60
Enqueued: 70

Queue contents: 30 40 50 60 70

Advantages of Circular Queue:

Efficient Memory Utilization: The circular nature allows the queue to reuse freed space,
making it more memory-efficient than a simple queue.

No False Overflow: The "false overflow" issue, which occurs in simple queues when space is
available at the front but cannot be used, is eliminated in circular queues.

Ideal for Fixed-size Buffers: Circular queues are particularly useful in situations where the size
of the queue is fixed and memory needs to be reused efficiently (e.g., in buffering or round-
robin scheduling).

Use Cases:

Round-robin Scheduling: In operating systems, circular queues are used to manage processes
in a round-robin manner.

Buffering: In streaming systems or data transmission, circular queues are used to buffer data
efficiently.

Resource Management: Circular queues can manage resources like printers or servers in a
cyclic fashion, ensuring fair and equal distribution of tasks.

Priority Queue

A priority queue is a specialized type of queue where each element is assigned a priority, and
elements with higher priority are processed before those with lower priority. Unlike simple and
circular queues, which follow a strict FIFO order, priority queues allow elements to be

dequeued based on their priority rather than their arrival order. If two elements have the same
priority, they are processed in the order they arrived.

119
 A Priority Queue is a specialized data structure that organizes elements based on their priority
rather than their insertion order. In this structure, elements with the highest priority are
dequeued first, regardless of when they were inserted. The image illustrates a priority queue
where elements are sorted in descending order of priority, with the greatest element (e.g., 900)
at the rear and the least priority element (e.g., 100) at the front. The enqueue operation inserts
elements into the queue while maintaining the order based on priority, and the dequeue
operation removes the element with the least priority from the front. This structure is widely
used in scenarios like task scheduling, shortest path algorithms, and resource management
systems.

Example
#include <stdio.h>
#include <stdlib.h>
#define MAX 100
typedef struct {
int data;
int priority;
} Element;
typedef struct {
Element queue[MAX];
int size;
} PriorityQueue;
// Function to initialize the priority queue
void initialize(PriorityQueue* pq) {
pq->size = 0;
}

120
// Function to enqueue an element into the priority queue
void enqueue(PriorityQueue* pq, int data, int priority) {
if (pq->size == MAX) {
printf("Priority Queue is full!\n");
return;
}
pq->queue[pq->size].data = data;
pq->queue[pq->size].priority = priority;
pq->size++;
}
// Function to dequeue an element with the highest priority
int dequeue(PriorityQueue* pq) {
if (pq->size == 0) {
printf("Priority Queue is empty!\n");
return -1;
}
// Find the element with the highest priority
int maxPriorityIndex = 0;
for (int i = 1; i < pq->size; i++) {
if (pq->queue[i].priority > pq->queue[maxPriorityIndex].priority) {
maxPriorityIndex = i;
}
}
// Get the data of the highest-priority element
int data = pq->queue[maxPriorityIndex].data;

// Shift elements to fill the gap

for (int i = maxPriorityIndex; i < pq->size - 1; i++) {
pq->queue[i] = pq->queue[i + 1];
}
pq->size--;
return data;
}
// Function to display the priority queue
void display(PriorityQueue* pq) {
if (pq->size == 0) {
printf("Priority Queue is empty!\n");

121
 return;
}
printf("Priority Queue:\n");
for (int i = 0; i < pq->size; i++) {
printf("Data: %d, Priority: %d\n", pq->queue[i].data, pq->queue[i].priority);
}
}
int main() {
PriorityQueue pq;
initialize(&pq);
enqueue(&pq, 10, 2);
enqueue(&pq, 20, 5);
enqueue(&pq, 30, 1);
printf("Before dequeuing:\n");
display(&pq);
printf("\nDequeued element: %d\n", dequeue(&pq));
printf("\nAfter dequeuing:\n");
display(&pq);
return 0;
}
Before dequeuing:
Priority Queue:
Data: 10, Priority: 2
Data: 20, Priority: 5
Data: 30, Priority: 1

Dequeued element: 20
After dequeuing:
Priority Queue:
Data: 10, Priority: 2
Data: 30, Priority: 1

Key Features:

Priority-based dequeue: The element with the highest priority is dequeued first.

Order of arrival: If two elements have the same priority, they are dequeued in the order they
were enqueued (FIFO for equal priority elements).

Priority values: Elements are typically associated with a numeric priority value. Higher
122
numbers can represent higher priority, or lower numbers can represent higher priority
depending on the implementation.

Common Uses:

Task Scheduling: Prioritizing tasks based on their importance or urgency.

Data Compression: Algorithms like Huffman coding use priority queues to build the optimal
binary tree.

Graph Algorithms: Algorithms like Dijkstra’s shortest path algorithm use priority queues to
process nodes based on their shortest distance.

Types of Priority Queues:

Max Priority Queue: The element with the highest priority is dequeued first.

Min Priority Queue: The element with the lowest priority is dequeued first.

Advantages of Priority Queue:

Dynamic Priority Handling: Tasks or items can be dynamically prioritized, making it useful
for managing tasks based on urgency or importance.

Efficient Task Scheduling: In operating systems, priority queues are used for scheduling tasks
or processes where higher-priority tasks are given preference.

Optimal Algorithms: Priority queues are essential in algorithms like Dijkstra's shortest path,
Huffman coding, and A* search, where elements need to be processed based on priority.

Use Cases:

Task Scheduling: For scheduling tasks based on priority (e.g., CPU scheduling in operating
systems).

Graph Algorithms: Dijkstra's and Prim's algorithms rely on priority queues to process nodes
with the lowest cost first.

Data Compression: Huffman coding uses priority queues to build a binary tree for optimal data
compression.

Event Simulation: In discrete event simulation systems, events are processed in the order of
their scheduled times (priorities).

123
Customizing Priority Queue:

You can modify the behavior of the priority queue by defining your own comparison logic for
priorities.

You could change it to a min-priority queue by simply reversing the logic (removing the
negation in the enqueue and dequeue operations).

Priority queues are typically implemented using data structures like heaps or binary trees,
which allow efficient retrieval of the highest-priority element. For example, in a hospital
emergency room, patients are prioritized based on the severity of their condition rather than
their arrival time. Priority queues are commonly used in applications that require priority-based
processing, such as task scheduling, traffic management, and event-driven simulations.

Deque (Double-Ended Queue)

A deque (double-ended queue) is a flexible queue structure that allows elements to be added
and removed from both ends, offering greater versatility than other queue types. In a deque,
elements can be enqueued or dequeued from either the front or the rear, making it suitable for
applications that require both FIFO and LIFO behavior. Deques are often used in scenarios
where bidirectional access is needed, such as navigating through a browser’s history or
managing a sliding window in algorithms.
There are two types of deques: input-restricted deques, where insertion is allowed only at one

124
 end, and output-restricted deques, where deletion is allowed only at one end. Deques are
implemented using arrays or linked lists and provide efficient access from both ends, making
them useful in applications like task management, undo-redo operations, and data caching.

A deque (short for double-ended queue) is a type of data structure that allows elements to be
inserted and removed from both ends: the front and the rear. This flexibility makes it more
versatile than simple queues, which only allow elements to be added at one end and removed
from the other.

Example
#include <stdio.h>
#define MAX 5
int deque[MAX];
int front = -1, rear = -1;
// Function to check if deque is full
int isFull() {
return ((front == 0 && rear == MAX - 1) || (front == rear + 1));
}
// Function to check if deque is empty
int isEmpty() {
return (front == -1);
}
// Insert at the front
void insertFront(int data) {
if (isFull()) {
printf("Deque is full\n");
return;
}
if (isEmpty()) { // First element
front = rear = 0;
} else if (front == 0) {
front = MAX - 1;
} else {
front--;
}
125
 deque[front] = data;
}
// Insert at the rear
void insertRear(int data) {
if (isFull()) {
printf("Deque is full\n");
return;
}
if (isEmpty()) { // First element
front = rear = 0;
} else if (rear == MAX - 1) {
rear = 0;
} else {
rear++;
}
deque[rear] = data;
}
// Delete from the front
void deleteFront() {
if (isEmpty()) {
printf("Deque is empty\n");
return;
}
printf("Deleted %d from front\n", deque[front]);
if (front == rear) { // Only one element
front = rear = -1;
} else if (front == MAX - 1) {
front = 0;
} else {
front++;
}
}
// Delete from the rear
void deleteRear() {
if (isEmpty()) {
printf("Deque is empty\n");
return;

126
 }
printf("Deleted %d from rear\n", deque[rear]);
if (front == rear) { // Only one element
front = rear = -1;
} else if (rear == 0) {
rear = MAX - 1;
} else {
rear--;
}
}

// Display the deque

void display() {
if (isEmpty()) {
printf("Deque is empty\n");
return;
}
printf("Deque elements are: ");
int i = front;
while (1) {
printf("%d ", deque[i]);
if (i == rear)
break;
i = (i + 1) % MAX;
}
printf("\n");
}
int main() {
insertRear(10);
insertRear(20);
display();
insertFront(5);
display();
deleteFront();
display();
deleteRear();
display();

127
 return 0;
}
Deque elements are: 10 20
Deque elements are: 5 10 20
Deleted 5 from front
Deque elements are: 10 20
Deleted 20 from rear
Deque elements are: 10

Key Features:

Bidirectional Access: You can insert and remove elements from both ends.

Flexibility: It can function as both a FIFO (First-In-First-Out) queue and a LIFO (Last-In-First-
Out) stack, depending on how it's used.

Efficient Operations: Insertion and deletion operations at both ends are typically done in
constant time, making it efficient for certain applications.

Types of Deques:

Input-Restricted Deque: Insertion is allowed only at one end (either front or rear).

Output-Restricted Deque: Deletion is allowed only at one end (either front or rear).

Fully-Functional Deque: Allows both insertion and deletion at both ends.

Common Uses:

Browser History: Navigating backward and forward between visited pages.

Sliding Window Algorithms: For problems like finding the maximum in a sliding window in
an array.

Task Scheduling: In cases where tasks need to be managed with both FIFO and LIFO
behaviors.

Undo-Redo Operations: Allows multiple undo and redo actions using bidirectional access.

Advantages of Deques:

Bidirectional Operations: Deques allow operations at both ends, providing more flexibility than
a simple queue or stack.
128
Efficient: Insertions and deletions at both ends are typically O(1), meaning the operations are
done in constant time.

Versatile: Can be used as a stack, queue, or even both simultaneously, depending on the use
case.

Memory Efficiency: Since deques are implemented as doubly linked lists or arrays, they are
efficient in terms of both time and space for most operations.

Use Cases:

Sliding Window Problems: In algorithms like "find the maximum in a sliding window," where
you need to access both ends of a window quickly.

Task Scheduling: Managing tasks that need to be processed in both FIFO and LIFO manners
depending on the conditions.

Undo/Redo Operations: In applications where you need to traverse through history in both
directions.

Browser History: Navigating back and forth between pages by managing forward and
backward navigation as a deque.

Customizing Deques:

You can implement a restricted deque where either insertion or deletion is allowed at only one
end by modifying the logic for enqueue and dequeue operations.

Queue Operations and Their Implementations

Queues support a set of fundamental operations: enqueue, dequeue, peek, isFull, and isEmpty.
These operations manage elements in the queue and ensure proper functionality and data flow.

Enqueue

The enqueue operation adds an element to the rear of the queue. In a simple queue implemented
with arrays, the rear pointer is incremented, and the new element is added at the rear index. In
a linked list-based queue, a new node is created and added at the end, and the rear pointer is
updated to point to the new node. If the queue is full, an error or overflow condition is raised
in fixed-size array implementations.

129
In a circular queue, if the rear pointer reaches the end of the array, it wraps around to the
beginning, adding the new element at the first available position. Enqueue operations are

typically O(1) in time complexity, as they only involve updating the rear pointer and adding
the element.

Dequeue

The dequeue operation removes an element from the front of the queue. In an array-based
queue, the front pointer is incremented to remove the first element. In a linked list-based queue,
the front node is deleted, and the front pointer is updated to point to the next node. If the queue
is empty, a dequeue operation cannot be performed, and an error or underflow condition is
raised.

In a circular queue, the front pointer also wraps around to the beginning when it reaches the
end of the array, ensuring that elements are removed in a cyclic order. Like enqueue, dequeue
operations are generally O(1), as they involve only pointer updates and element removal.

Peek

The peek operation retrieves the front element of the queue without removing it. Peek allows
for checking the next element to be processed without modifying the queue structure. Peek is
useful in applications where the next item needs to be inspected before processing. In most
implementations, peek is an O(1) operation, as it involves accessing the element at the front
pointer.

IsFull and IsEmpty

The isFull and isEmpty operations check the queue’s current status. IsFull verifies if the queue
has reached its maximum capacity, which is particularly relevant in array-based
implementations. If the rear pointer has reached the maximum index (or wraps around in a
circular queue), the queue is full. IsEmpty checks if the queue has no elements, indicated by an
initial front and rear pointer configuration or an empty linked list. These operations ensure that
enqueue and dequeue actions occur only when appropriate, preventing overflow or underflow
errors.

130
 Practical Example: Printer Queue Simulation

Example for Printer Queue Simulation

#include <stdio.h>
#include <stdlib.h>
#define MAX_QUEUE_SIZE 5 // Maximum size of the printer queue
// Define the structure of a Print Job
typedef struct {
int jobId;
char jobName[100];
} PrintJob;
// Define the Printer Queue structure
typedef struct {
PrintJob queue[MAX_QUEUE_SIZE];
int front;
int rear;
} PrinterQueue;
// Function to initialize the printer queue
void initializeQueue(PrinterQueue *pq) {
pq->front = -1;
pq->rear = -1;
}
// Function to check if the queue is full
int isQueueFull(PrinterQueue *pq) {
return pq->rear == MAX_QUEUE_SIZE - 1;
}
// Function to check if the queue is empty
int isQueueEmpty(PrinterQueue *pq) {
return pq->front == -1;
}
// Function to enqueue a print job to the queue
void enqueue(PrinterQueue *pq, PrintJob job) {
if (isQueueFull(pq)) {
printf("Queue is full! Cannot add more print jobs.\n");
} else {
if (pq->front == -1) {
pq->front = 0; // First job in the queue

131
 }
pq->rear++;
pq->queue[pq->rear] = job;
printf("Print job '%s' added to the queue.\n", job.jobName);
}
}
// Function to dequeue a print job from the queue
PrintJob dequeue(PrinterQueue *pq) {
PrintJob job = {0};
if (isQueueEmpty(pq)) {
printf("Queue is empty! No jobs to process.\n");
} else {
job = pq->queue[pq->front];
printf("Processing print job '%s'...\n", job.jobName);
pq->front++;
if (pq->front > pq->rear) {
pq->front = pq->rear = -1; // Queue is empty now
}
}
return job;
}
int main() {
PrinterQueue pq;
initializeQueue(&pq);
// Create some print jobs
PrintJob job1 = {1, "Document_1"};
PrintJob job2 = {2, "Document_2"};
PrintJob job3 = {3, "Document_3"};
// Enqueue print jobs
enqueue(&pq, job1);
enqueue(&pq, job2);
enqueue(&pq, job3);
// Dequeue and process jobs
dequeue(&pq); // Process first job
dequeue(&pq); // Process second job
dequeue(&pq); // Process third job

132
 return 0;
}

Explanation:
Print Job Structure: Represents a print job with a job ID and job name.
Printer Queue Structure: Contains an array of print jobs and pointers to the front and rear of the queue.
Queue Functions:
Initialize Queue: Initializes the queue.
Is Queue Full: Checks if the queue is full.
Is Queue Empty: Checks if the queue is empty.
enqueue: Adds a new print job to the queue.
dequeue: Removes the next job from the queue and processes it (in the order of arrival).
Main Function:
Adds three print jobs to the queue using enqueue.
Processes the jobs in the order they were added using dequeue.

Output:
Print job 'Document_1' added to the queue.
Print job 'Document_2' added to the queue.
Print job 'Document_3' added to the queue.
Processing print job 'Document_1'...
Processing print job 'Document_2'...
Processing print job 'Document_3'...
This simple simulation shows how jobs are enqueued (added to the queue) when they arrive and processed
(dequeued) in the order they were submitted, which is typical for a First In, First Out (FIFO) queue.

Real-World Applications of Queues

Queues are essential in various real-world applications where data needs to be processed in a
sequential or prioritized order. From task scheduling to resource management, queues provide
an efficient way to handle data flow and manage system resources.

Task Scheduling

Task scheduling in operating systems, network routers, and computer processors heavily relies
on queues. In operating systems, tasks waiting for CPU time are stored in a queue, with the
CPU fetching the next task in line. This setup ensures fair processing and efficient resource
133
allocation. Circular queues are commonly used in round-robin scheduling, where each task
receives a fixed time slice before being moved to the end of the queue. Priority queues are also
used for task scheduling, allowing high-priority tasks (e.g., system-critical processes) to be
executed before lower-priority ones.

Data Buffering in Networks

Data buffering in network systems uses queues to manage data packets in transit. In routers,
incoming data packets are placed in a queue before being processed and forwarded to their
destination. This queue-based buffering prevents packet loss and ensures that data is
transmitted in the correct order. Circular queues are frequently used in buffering applications
to handle continuous streams of data, enabling efficient memory usage by reusing buffer space.
Priority queues are also used in networks to manage Quality of Service (QoS), where high-
priority packets, like real-time audio or video data, are processed before lower-priority packets.

Printer Spooling

Printer spooling is a common application of queues, where print jobs are stored in a queue until
the printer is ready to process them. When multiple users send print requests, each request is
added to the spool queue, and the printer processes jobs in the order they were received. This
FIFO structure ensures that print jobs are completed in sequence, preventing conflicts and
maintaining an organized workflow. Printer spooling improves efficiency and enables users to
submit jobs without waiting for each print to complete.

134
Customer Service Systems

Customer service systems, such as call centers and help desks, use queues to manage customer
requests. When customers call for support, they are placed in a queue based on their arrival
time. The support team then processes requests in the order they were received, ensuring that
each customer is served fairly. Priority queues can also be used in customer service, where VIP
customers or urgent issues are given higher priority in the queue. This setup improves response
time and service quality, making queues an essential component of customer support systems.

Simulation and Event Management

In simulation and event-driven applications, queues are used to manage events that need to be
processed in a specific order. For example, in a simulation of a bank, customer arrival and
service times are stored in a queue, and events are processed sequentially to reflect real-world
customer flow. Similarly, in gaming, queues manage events such as player actions, enemy
movements, or environmental changes, ensuring that these events are handled in the correct
order. Event management using queues provides a structured way to model and process
sequences, making simulations accurate and realistic.

Resource Management in Cloud Computing

In cloud computing, queues are essential for managing resources and handling requests from
multiple users. Cloud providers use queues to distribute computational tasks, allocate
resources, and balance workloads across servers. Queues enable efficient task management,
preventing bottlenecks and optimizing resource usage. For instance, when multiple users
request data processing, the requests are queued, and each server processes the requests in FIFO
order, ensuring that resources are distributed fairly. Priority queues are also used in cloud
systems to prioritize critical tasks, enhancing system reliability and performance.

Queues are fundamental data structures that provide an organized, FIFO-based approach to
managing data flow in diverse applications. Different types of queues, including simple,
circular, priority, and deque, offer unique capabilities suited to various real-world scenarios.
Queue operations, such as enqueue, dequeue, peek, isFull, and isEmpty, enable efficient data
handling and ensure that queues function as intended. The versatility of queues makes them
indispensable in task scheduling, data buffering, customer service, printer spooling, simulation,
and cloud computing.

135
MCQ:

Which data structure uses LIFO (Last In, First Out)?

(A) Queue
(B) Stack
(C) Array
(D) Graph
Answer: (B)

Which operation cannot be performed on a queue?

(A) Enqueue
(B) Dequeue
(C) Peek
(D) Reverse
Answer: (D)

Which of the following operations is the most efficient in a stack?

(A) Searching
(B) Insertion
(C) Traversal
(D) Deletion
Answer: (B)

What is the time complexity of pushing an element into a stack?

(A) O(1)
(B) O(n)
(C) O(log n)
(D) O(n²)
Answer: (A)

Which operation retrieves the front element of a queue without removing it?

(A) Enqueue
(B) Peek
(C) Dequeue
(D) Pop
Answer: (B)

In which scenario is a circular queue used?

(A) File editing

(B) Buffer management
(C) Stack overflow prevention
(D) Searching
Answer: (B)

136
Which data structure is used to implement a priority queue?

(A) Stack
(B) Heap
(C) Graph
(D) Queue
Answer: (B)

Which data structure is best for implementing a browser back button?

(A) Queue
(B) Stack
(C) Heap
(D) Linked List
Answer: (B)

137
 CHAPTER 5

Trees and Graphs

5.1 Tree Terminology And Types (Binary, AVL,B-Tree, etc)

Fig 26 : Tree Data Structure Components

Trees are hierarchical data structures that are essential in computer science, used to represent
hierarchical relationships and support efficient search, retrieval, and data organization. Unlike
linear data structures, trees are non-linear and consist of nodes connected by edges, forming a
parent-child relationship. Trees are fundamental in various applications, such as databases, file
systems, and search algorithms. They come in different types, each with unique properties
suited to specific use cases, such as binary trees, AVL trees, and B-trees. Understanding the
terminology and characteristics of different tree types is essential for choosing the right
structure for a given problem. This section covers basic tree terminology, types of trees, and a
comparative analysis of common tree structures.

138
 Basic Terminology (Nodes, Leaves, Height, Depth)

Before exploring different types of trees, it's essential to understand some fundamental
terminology associated with trees. Each of these terms defines an aspect of a tree’s structure
and helps in understanding how trees are constructed and manipulated.

Nodes

A node is the fundamental building block of a tree, representing each data element within the
tree. Nodes can contain data, references to child nodes, or both, depending on the specific type
of tree. The topmost node in a tree is called the root, and every other node has a unique path
connecting it to the root. Nodes in a tree can be connected by edges, which represent the
relationship between nodes.

Nodes are categorized based on their position and relationships within the tree. A node with
one or more child nodes is called a parent node, while nodes without any children are known
as leaf nodes. The organization of nodes defines the overall structure of the tree and how data
is accessed.

Leaves

Leaves (or leaf nodes) are nodes in a tree that do not have any children. They represent the
endpoints of paths within the tree and play a critical role in defining the depth and complexity
of the tree structure. Leaf nodes are often used in applications where terminal data values or
specific conditions are stored, such as decision-making processes, search trees, and hierarchical
data structures. In a binary tree, leaf nodes typically reside at the last level of the tree.

Height

The height of a tree is the longest path from the root node to any leaf node. The height
determines the number of levels in the tree and, consequently, its depth. The height of an empty
tree is typically considered -1, while a tree with a single node (the root) has a height of 0. The
height is an essential factor in analyzing the efficiency of tree operations, as trees with greater
height may require more comparisons and traversals to locate or insert nodes. Balanced trees,
like AVL trees, aim to minimize height to improve efficiency.

Depth

The depth of a node is the number of edges on the path from the root to that particular node.
The depth of the root node is 0, while each subsequent level increases the depth by one. The

139
depth of a tree is often used in traversals, where nodes are visited based on their depth. The
depth of a node provides insights into its position relative to the root and is crucial in
understanding the overall structure of the tree.

Types of Trees (Binary Tree, AVL Tree, B-Trees, etc.)

Trees come in various forms, each designed for specific use cases and optimized for particular
types of operations. The most common types include binary trees, AVL trees, and B-trees, each
offering unique characteristics and efficiencies.

Binary Tree

Fig 27: Binary Tree Structure and Components

A binary tree is a tree data structure where each node has a maximum of two children, referred
to as the left and right children. Binary trees are the foundation for many specialized trees, such
as binary search trees and AVL trees. Binary trees are efficient for hierarchical data storage
and support various traversal techniques, such as in-order, pre-order, and post-order traversal,
which define the order in which nodes are visited.

140
Binary trees are used in applications like expression parsing, decision trees, and hierarchical
data representation. However, binary trees are not always efficient, as they may become
unbalanced, leading to increased height and reduced performance. To address this, balanced
binary trees, like AVL trees, are introduced.

Example of Binary Tree

#include<stdio.h>

#include<stdlib.h>

struct Node {

int data;

struct Node* left;

struct Node* right;

};

// Function to create a new node

struct Node* createNode(int data) {

struct Node* newNode = (struct Node*) malloc(sizeof(struct Node));

newNode->data = data;

newNode->left = newNode->right = NULL;

return newNode;

// In-order traversal (Left, Root, Right)

void inOrderTraversal(struct Node* root) {

if (root == NULL)

return;

inOrderTraversal(root->left);

printf("%d ", root->data);

inOrderTraversal(root->right);

int main() {

// Create a simple binary tree

141
 struct Node* root = createNode(1);

root->left = createNode(2);

root->right = createNode(3);

root->left->left = createNode(4);

root->left->right = createNode(5);

// In-order traversal

printf("In-order traversal of the binary tree: ");

inOrderTraversal(root);

return 0;

Output:

In-order traversal of the binary tree: 4 2 5 1 3

AVL Tree

An AVL tree (Adelson-Velsky and Landis tree) is a self-balancing binary search tree where
the height difference (balance factor) between the left and right subtrees of any node is at most
one. This property ensures that the AVL tree remains balanced, minimizing the height and
improving search, insertion, and deletion efficiency. Whenever an insertion or deletion
operation causes the tree to become unbalanced, rotations (left, right, left-right, or right-left)
are performed to restore balance.

AVL trees are ideal for applications requiring fast lookups and modifications, such as databases
and cache implementations. With a time complexity of O(log n) for search, insertion, and
deletion operations, AVL trees are efficient and maintain optimal balance, making them
suitable for dynamic data sets.
142
Example of AVL Tree
#include <stdio.h>
#include <stdlib.h>
// Define the structure of a node
struct Node {
int data;
struct Node* left;
struct Node* right;
int height;
};
// Function to get the height of a node
int height(struct Node* node) {
if (node == NULL)
return 0;
return node->height;
}
// Function to get the balance factor of a node
int getBalance(struct Node* node) {
if (node == NULL)
return 0;
return height(node->left) - height(node->right);
}
// Function to perform a right rotation (used to balance the tree)
struct Node* rightRotate(struct Node* y) {
struct Node* x = y->left;
struct Node* T2 = x->right;

// Perform rotation
x->right = y;
y->left = T2;
// Update heights
y->height = (height(y->left) > height(y->right)) ? height(y->left) + 1 : height(y->right) + 1;
x->height = (height(x->left) > height(x->right)) ? height(x->left) + 1 : height(x->right) + 1;
// Return new root
return x;
}

143
/ Function to perform a left rotation (used to balance the tree)
struct Node* leftRotate(struct Node* x) {
struct Node* y = x->right;
struct Node* T2 = y->left;
// Perform rotation
y->left = x;
x->right = T2;
// Update heights
x->height = (height(x->left) > height(x->right)) ? height(x->left) + 1 : height(x->right) + 1;
y->height = (height(y->left) > height(y->right)) ? height(y->left) + 1 : height(y->right) + 1;
// Return new root
return y;
}
// Function to insert a node in the AVL tree
struct Node* insert(struct Node* node, int data) {
// 1. Perform the normal BST insertion
if (node == NULL) {
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = data;
newNode->left = newNode->right = NULL;
newNode->height = 1; // new node is initially at height 1
return newNode;
}
if (data < node->data)
node->left = insert(node->left, data);
else if (data > node->data)
node->right = insert(node->right, data);
else // Duplicate data is not allowed
return node;
// 2. Update height of the current node
node->height = 1 + ((height(node->left) > height(node->right)) ? height(node->left) : height(node->right));
// 3. Get the balance factor of this node to check whether it became unbalanced
int balance = getBalance(node);
// Left Left Case
if (balance > 1 && data < node->left->data)
return rightRotate(node);
// Right Right Case

144
 if (balance < -1 && data > node->right->data)
return leftRotate(node);
// Left Right Case
if (balance > 1 && data > node->left->data) {
node->left = leftRotate(node->left);
return rightRotate(node);
}
// Right Left Case
if (balance < -1 && data < node->right->data) {
node->right = rightRotate(node->right);
return leftRotate(node);
}
// Return the (unchanged) node pointer
return node;
}
// Function for in-order traversal of the AVL tree
void inOrder(struct Node* root) {
if (root != NULL) {
inOrder(root->left);
printf("%d ", root->data);
inOrder(root->right);
}
}
// Driver program to test the AVL Tree implementation
int main() {
struct Node* root = NULL;
// Insert nodes into the AVL tree
root = insert(root, 10);
root = insert(root, 20);
root = insert(root, 30);
root = insert(root, 15);
root = insert(root, 25);
root = insert(root, 5);
root = insert(root, 12);
// Print in-order traversal of the AVL tree
printf("In-order traversal of the AVL tree: ");
inOrder(root);

145
 return 0;
}

Rotations:
Right Rotation (LL Case): If the balance factor of a node is greater than 1 and the inserted node is on
the left of the left child.
Left Rotation (RR Case): If the balance factor of a node is less than -1 and the inserted node is on the
right of the right child.
Left-Right Rotation (LR Case): If the balance factor of a node is greater than 1 and the inserted node
is on the right of the left child.
Right-Left Rotation (RL Case): If the balance factor of a node is less than -1 and the inserted node is
on the left of the right child.

Key Points:
AVL Trees maintain balance by using rotations to ensure that the tree remains approximately
balanced, improving search, insertion, and deletion time complexity to O(log n).
The balance factor ensures that the height difference between the left and right subtrees of any node
is at most 1,
making the AVL Tree a self-balancing binary search tree.

146
B-Trees

A B-tree is a self-balancing tree data structure optimized for systems that read and write large
blocks of data, such as databases and file systems. Unlike binary trees, B-trees allow each node
to have multiple children, making them efficient for storing large volumes of data. B-trees
maintain balance by splitting nodes when they exceed a maximum number of children,
distributing keys across the tree to keep it balanced.

B-trees are commonly used in databases and file systems where data must be stored in large
blocks to reduce disk access. The B-tree structure allows efficient insertion, deletion, and
search operations, with a time complexity of O(log n). B-trees are particularly effective in
minimizing I/O operations, as their multi-level structure enables more data to be stored in fewer
disk blocks.

Binary Search Tree (BST)

A binary search tree (BST) is a specialized binary tree where each node’s left child contains
values less than the parent node, and the right child contains values greater than the parent
node. This ordering property allows efficient searching, as the tree can be traversed based on
comparisons. For instance, searching for a value in a BST involves comparing the value with
the root, then moving to the left or right subtree depending on whether the value is smaller or
larger than the root.

BSTs are commonly used in applications that require ordered data, such as dictionaries and
sets. However, BSTs can become unbalanced, resulting in a structure similar to a linked list,

147
with reduced efficiency in search and insertion operations. Balanced versions of BSTs, such as
AVL trees and red-black trees, are preferred when maintaining efficiency is crucial.

Example of BST

#include<stdio.h>

#include<stdlib.h>

struct Node {

int data;

struct Node* left;

struct Node* right;

};

// Function to create a new node

struct Node* createNode(int data) {

struct Node* newNode = (struct Node*) malloc(sizeof(struct Node));

newNode->data = data;

newNode->left = newNode->right = NULL;

return newNode;

// Function to insert a new node into the BST

struct Node* insert(struct Node* root, int data) {

if (root == NULL) {

return createNode(data);

if (data < root->data) {

root->left = insert(root->left, data);

} else {

root->right = insert(root->right, data);

}
148
 return root;

// In-order traversal

void inOrderTraversal(struct Node* root) {

if (root != NULL) {

inOrderTraversal(root->left);

printf("%d ", root->data);

inOrderTraversal(root->right);

int main() {

struct Node* root = NULL;

root = insert(root, 50);

root = insert(root, 30);

root = insert(root, 70);

root = insert(root, 20);

root = insert(root, 40);

root = insert(root, 60);

root = insert(root, 80);

printf("In-order traversal of the BST: ");

inOrderTraversal(root);

return 0;

Output:

In-order traversal of the BST: 20 30 40 50 60 70 80

149
Red-Black Tree

A red-black tree is a self-balancing binary search tree with an additional color property for each
node: red or black. Red-black trees ensure balance by following specific rules: the root is black,
red nodes cannot have red children, and each path from the root to a leaf must contain the same
number of black nodes. These rules ensure that red-black trees remain balanced and support
efficient search, insertion, and deletion operations.

Red-black trees are widely used in systems requiring ordered data with fast access times, such
as associative arrays in C++ (std::map) and Java (TreeMap). Red-black trees offer O(log n)
time complexity for search, insertion, and deletion, making them efficient for high-
performance applications.

Comparative Analysis of Different Trees

Each type of tree offers unique advantages and is optimized for specific use cases. The
following comparative analysis highlights the strengths and weaknesses of different tree
structures.

Binary Tree vs. AVL Tree: While binary trees are simple and easy to implement, they can
become unbalanced, leading to reduced efficiency. AVL trees address this issue by maintaining

150
balance through rotations, offering better performance for search and update operations with a
time complexity of O(log n). However, AVL trees have higher overhead due to rebalancing,
making binary trees preferable for simpler applications.

Binary Search Tree vs. AVL Tree: BSTs are efficient for ordered data storage, but they can
degrade to O(n) time complexity if unbalanced. AVL trees maintain balance, ensuring that
search, insertion, and deletion remain O(log n). AVL trees are suitable for dynamic datasets,
while BSTs work well in scenarios where balance is not crucial.

AVL Tree vs. Red-Black Tree: Both AVL and red-black trees are self-balancing, but they
achieve balance differently. AVL trees are more strictly balanced, offering faster lookups, but
they require more rotations. Red-black trees, on the other hand, are less balanced but have
fewer rotations, making them more efficient for insertion and deletion. Red-black trees are
commonly used in libraries and databases, where modifications are frequent.

B-Tree vs. Binary Tree: B-trees are multi-way trees, allowing each node to have multiple
children, while binary trees are limited to two children per node. B-trees are designed for disk
storage and minimize disk I/O, making them ideal for databases. Binary trees, while simpler,
are not as efficient for large datasets that require disk access.

B-Tree vs. AVL Tree: B-trees are better suited for large data storage due to their multi-level
structure and disk optimization, while AVL trees are efficient for memory-based storage where
quick access is required. B-trees are widely used in databases, while AVL trees are common in
memory-based applications like caches.

Trees are versatile and powerful data structures that support hierarchical data organization and
efficient search operations. By understanding basic terminology, such as nodes, leaves, height,
and depth, and exploring different types of trees, such as binary trees, AVL trees, B-trees, and
red-black trees, developers can select the best tree structure for a specific application.
Comparative analysis reveals the unique strengths and weaknesses of each type, highlighting
their suitability for various tasks, from fast lookups and dynamic data management to disk-
optimized storage and scheduling applications. Mastery of tree structures is essential for
building efficient and scalable solutions in computer science and real-world applications.

151
 Heaps: Min-Heap, Max-Heap,

Fig 28: Comparison of Min Heap and Max Heap

A heap is a specialized binary tree-based data structure that is used to maintain a partial order
between its elements. Heaps are crucial for implementing priority queues efficiently and have
various applications in scheduling, prioritization, and real-time data processing. There are two
primary types of heaps—Min-Heap and Max-Heap—each serving different purposes based on
their ordering properties. Heaps enable efficient insertion, deletion, and retrieval of minimum
or maximum elements, making them ideal for applications that require sorted access to
dynamically changing datasets. In this section, we explore the properties of Min-Heap and
Max-Heap, methods for building and manipulating heaps, and their applications in real-world
use cases like CPU scheduling and task prioritization.

Properties of Min-Heap and Max-Heap

Heaps are binary trees with two distinct types: Min-Heap and Max-Heap. Each type follows
specific properties that make them suitable for different operations.

Min-Heap

A Min-Heap is a binary tree where the value of each node is less than or equal to the values of
its children. This property ensures that the smallest element is always located at the root of the
tree. In a Min-Heap, the ordering constraint applies only between a parent and its children,
meaning that elements are not fully sorted. Min-Heaps are commonly used in applications
where the minimum value must be accessed quickly, such as priority queues that process tasks
based on priority.

152
The key properties of a Min-Heap are as follows:

Heap Property: Each parent node has a value less than or equal to its children.

Complete Binary Tree: All levels of the tree are filled, except possibly the last level, which is
filled from left to right.

Due to these properties, inserting a new element or removing the minimum element in a Min-
Heap is efficient, with time complexities of O(log n) for both operations.

Max-Heap

A Max-Heap is similar to a Min-Heap, but with the opposite ordering property: each node has
a value greater than or equal to the values of its children. This ensures that the largest element
is always at the root. Max-Heaps are useful for applications where the maximum value must
be accessed quickly, such as tracking the highest priority task or maintaining a leaderboard of
scores.

The main properties of a Max-Heap are:

Heap Property: Each parent node has a value greater than or equal to its children.

Complete Binary Tree: Like Min-Heaps, Max-Heaps are complete binary trees, ensuring that
all levels are filled except for the last.

In Max-Heaps, operations like insertion and deletion of the maximum element are efficient,
taking O(log n) time. Max-Heaps are widely used in applications where maximum-priority
access is essential, such as managing resources in competitive tasks.

Building and Manipulating Heaps

Building and manipulating heaps involves several key operations, including insertion, deletion,
and heapify. These operations maintain the heap properties and allow efficient access to the
minimum or maximum element.

Insertion in a Heap

Inserting an element in a heap involves adding the element at the next available position to
maintain the complete binary tree structure. After insertion, the heap may violate the heap
property, so a process called heapify-up (or bubble-up) is used to restore the heap order.

Insert the new element at the last position in the array representation of the heap.

153
Compare the new element with its parent; if it violates the heap property (for example, if the
element is smaller than the parent in a Min-Heap), swap it with the parent.

Repeat this process until the heap property is restored, or the element reaches the root.

Heap insertion has a time complexity of O(log n), as the element may need to move up several
levels to restore the heap property.

Deletion in a Heap

The deletion operation in a heap typically involves removing the root element, which is the
minimum in a Min-Heap or the maximum in a Max-Heap. This operation is also known as
extract-min in Min-Heaps and extract-max in Max-Heaps.

Replace the root with the last element in the heap.

Remove the last element to reduce the size of the heap.

Perform heapify-down (or bubble-down) by comparing the new root with its children and
swapping it with the smaller child (for Min-Heap) or larger child (for Max-Heap) if necessary.

Repeat this process until the heap property is restored.

The deletion operation has a time complexity of O(log n) due to the heapify-down process, as
the element may need to move down several levels.

Building a Heap from an Array (Heapify)

A common method for building a heap from an unsorted array is the heapify process, which
converts an array into a heap by ensuring that all parent-child relationships follow the heap
property. Heapify can be done in two main ways:

Heapify Up (Bottom-Up Heapify): Starting from the last non-leaf node, perform heapify-up on
each node until the root. This ensures that the heap property is maintained as elements move
up if necessary.

Heapify Down (Top-Down Heapify): Starting from the root, apply heapify-down to each node.
This method is often used when inserting a new element at the root.

Building a heap from an array using the heapify process takes O(n) time complexity, which is
more efficient than inserting elements individually.

154
5.2 Graph Theory Basics: Terminology, Types, and Applications

Graphs are non-linear data structures composed of vertices (nodes) and edges (connections)
that represent relationships or connections between entities. Graphs are widely used in

computer science and various fields to model networks, dependencies, and relationships. They
are crucial for understanding complex structures like social networks, transportation systems,
and the internet. Graph theory provides a foundation for studying these structures, and different
types of graphs are used based on the specific needs of the application. This section covers
fundamental graph terminology, types of graphs, and practical applications in networking and
social media.

Graph Terminology (Vertices, Edges, Paths)

Fig 29: Representing a city's metro network

155
Before diving into different types of graphs, it is essential to understand some basic
terminology used in graph theory.

To illustrate a city's metro network as a graph and demonstrate Breadth-First Search (BFS) and
Depth-First Search (DFS) traversal, here's how the diagram and traversal would look
conceptually:

Graph Representation of Metro Network

Nodes: Represent metro stations (e.g., A, B, C, D, E).

Edges: Represent direct connections between stations.

Example Metro Network:

A
/\
B C
/\ \
D E F

Vertices

Vertices (or nodes) are the primary elements in a graph that represent entities or data points.
Each vertex is a discrete point in the graph, and vertices are often labeled to identify them
uniquely. In a social network graph, vertices might represent people, while in a transportation
network, they might represent locations like cities or intersections. Vertices serve as the
foundation of the graph, with edges connecting them to create relationships.

156
Edges

Edges (or links) are connections between vertices in a graph. Each edge represents a
relationship between two vertices, and these relationships can vary depending on the
application. For example, in a graph representing a social network, edges indicate friendships
or connections between people. Edges can be directed (with a direction) or undirected (no
direction), and they may have weights representing specific values like distance, cost, or
strength of the connection.

Edges can be represented in multiple ways, such as adjacency lists or adjacency matrices. The
presence of an edge between two vertices allows traversal between them, making edges a
crucial element in defining the structure and connectivity of a graph.

Paths

A path is a sequence of vertices connected by edges, starting from one vertex and ending at
another. Paths are important in graph traversal, as they represent possible routes or sequences
of connections between vertices. In some applications, the length of the path (measured in terms
of the number of edges) is significant, as it can indicate the distance or relationship strength

157
between entities.

Paths can be simple (no repeated vertices) or have cycles (returning to the same vertex). In a
social network, a path might represent a chain of friendships connecting two people indirectly,
while in a transportation network, it could represent a series of connected cities from a starting
point to a destination.

Types of Graphs (Directed, Undirected, Weighted, Unweighted)

Graphs come in various types, each suited to different applications and use cases. These types
include directed graphs, undirected graphs, weighted graphs, and unweighted graphs.

Directed Graph (Digraph)

A directed graph (or digraph) is a graph in which edges have a direction, meaning that
connections between vertices are one-way. In a directed graph, each edge is represented by an
arrow pointing from one vertex (the starting point) to another (the endpoint). For example, if
there is a directed edge from vertex A to vertex B, it indicates a relationship from A to B, but
not necessarily from B to A

158
Directed graphs are useful in applications where relationships have an inherent direction. In a
website link structure, for instance, a directed graph can represent hyperlinks between web
pages, where each link goes from one page to another. Similarly, in social media, a directed
graph can represent a "following" relationship, where a user follows another user, but the
following may not be mutual.

Undirected Graph

An undirected graph is a graph in which edges have no direction, meaning that connections
between vertices are bidirectional. In an undirected graph, if there is an edge between vertices
A and B, it implies a two-way relationship, such as friendship or mutual connectivity.
Undirected graphs are commonly used in applications where relationships are naturally mutual,
like social networks where connections are assumed to be bidirectional.

Undirected graphs are often simpler to work with, as the lack of direction reduces the
complexity of certain operations. In transportation networks, for example, undirected graphs
can represent roads between cities, assuming that travel is possible in both directions on each
road.

159
Weighted Graph

A weighted graph is a graph in which each edge is assigned a numerical weight, representing
some attribute of the relationship, such as distance, cost, or strength. Weighted graphs are
commonly used in applications where relationships have varying degrees of importance or
value. For example, in a transportation network, weights can represent the distance or travel
time between cities, while in a network of computers, weights might indicate bandwidth or
latency between devices.

Weighted graphs are crucial in optimization problems, where the goal is to find the shortest or
most efficient path between vertices. Algorithms like Dijkstra’s shortest path and Prim’s
minimum spanning tree use weighted graphs to determine optimal paths and connections based
on edge weights.

Unweighted Graph

An unweighted graph is a graph where all edges are considered equal, with no specific weights
assigned. In an unweighted graph, the presence of an edge simply indicates a connection
160
between vertices, without any additional information about the strength or value of the

relationship. Unweighted graphs are suitable for applications where only connectivity matters,
without regard for quantitative factors like distance or cost.

In social networks, for example, an unweighted graph can represent a basic connection between
users, such as friendship or group membership. In these cases, the focus is on who is connected
to whom, rather than the strength of those connections.

Practical Applications of Graphs in Networking and Social Media

Graphs have extensive applications in real-world scenarios, particularly in networking and

social media, where they are used to model relationships and dependencies.

1. Networking Applications

Graphs are fundamental in networking applications, where they model connections between
devices, routers, and data centers. In a computer network, vertices represent network devices
(such as routers, switches, or computers), and edges represent communication links (wired or
wireless connections) between them. Graphs help visualize and manage network structures,
optimize routing, and analyze network performance.

Routing and Pathfinding: In network routing, algorithms use graphs to find the most efficient
path for data packets between devices. Dijkstra’s algorithm, for instance, uses weighted graphs
to find the shortest path based on factors like latency, bandwidth, or hop count. Efficient
pathfinding minimizes delays and maximizes network throughput.

Network Topology: Network topology, which describes the arrangement of devices and
161
connections, can be represented as a graph. Different topologies, such as star, mesh, and ring,
have distinct graph structures that affect performance and fault tolerance. By analyzing network
topology graphs, network administrators can optimize connectivity and prevent bottlenecks.

Fault Tolerance and Resilience: Graphs are used to assess network resilience and fault tolerance
by identifying critical nodes and edges. In a resilient network, alternate paths exist between
nodes, allowing data to flow even if some links fail. Techniques like minimum spanning trees
help create efficient, robust networks by minimizing redundant connections while maintaining
connectivity.

Social Media Applications

In social media platforms, graphs play a central role in modeling relationships, interactions,
and content discovery. Users and their connections form a social graph, with nodes representing
users and edges representing relationships like friendships, follows, or interactions.

Friendship and Follower Networks: Social networks are typically represented as undirected
graphs for mutual friendships (e.g., Facebook) or directed graphs for follow relationships (e.g.,
Twitter, Instagram). Graph theory allows platforms to analyze connection patterns, identify
influential users, and recommend friends or followers based on mutual connections.

Content Recommendation: Content recommendation systems in social media use graphs to

analyze user interactions and preferences. By connecting users to the content they like or share,
a bipartite graph can be created, linking users with posts, videos, or articles. Algorithms like
collaborative filtering use this graph to recommend similar content to users based on shared
interests, enhancing user engagement.

Community Detection: Graphs enable the detection of communities within social networks,
where clusters of users have dense connections. Community detection algorithms identify
groups of users who interact frequently, revealing shared interests or affiliations. This analysis
is useful for targeted advertising, personalized content recommendations, and understanding
social dynamics.

Influence and Spread of Information: In social media, graphs help track the spread of
information, influence, and trends. Influential users, known as central nodes, have high
connectivity or influence within the network, and their posts can reach a broad audience
quickly. Graph theory enables platforms to analyze information diffusion patterns, measure
user influence, and manage viral content spread.

162
Spam and Fake Account Detection: Graph-based analysis is also applied in detecting spam or
fake accounts in social media. Suspicious accounts often exhibit unusual connection patterns,
such as forming dense clusters or connecting randomly to multiple accounts. By analyzing
these patterns, graph algorithms help identify and remove inauthentic accounts, improving
platform security.

Graphs are powerful tools for modeling complex relationships and structures in various real-
world applications, particularly in networking and social media. Through fundamental
terminology like vertices, edges, and paths, and the different types of graphs (directed,

undirected, weighted, and unweighted), graph theory provides essential insights into the
structure and behavior of interconnected systems. Applications in network routing, topology
management, social media connections, content recommendations, and influence tracking
highlight the versatility of graphs. Understanding graph basics is crucial for effectively solving
problems related to connectivity, optimization, and information flow in today's data-driven
world.

5.3 Traversals and Shortest Path Algorithms

Graph traversals and shortest path algorithms are fundamental techniques in computer science,
enabling the exploration and analysis of nodes in a graph. Graph traversal algorithms, such as
Depth-First Search (DFS) and Breadth-First Search (BFS), provide structured ways to visit
nodes, exploring connections and relationships between them. Shortest path algorithms, like
Dijkstra's algorithm, are used to find the minimum path between nodes, which is essential for
routing, navigation, and optimization problems. These techniques are widely applied in
networking, AI, logistics, and social media analysis. This section explores DFS, BFS, Dijkstra's
algorithm, and applications of graph traversal, followed by practice programs to reinforce
understanding.

163
 Depth-First Search (DFS) and Breadth-First Search (BFS)

DFS and BFS are two primary methods for graph traversal, each with a distinct approach to
exploring nodes and edges. Both algorithms are essential for solving various graph-related
problems, from detecting connectivity to finding paths.

1. Depth-First Search (DFS)

Depth-First Search (DFS) is a graph traversal algorithm that explores as far as possible along
a branch before backtracking. DFS starts from a source node and visits each node along a path
until it reaches a node with no unvisited neighbors. At this point, DFS backtracks and explores
other paths, following a "depth-first" strategy. DFS can be implemented using recursion or an
explicit stack.

Steps in DFS:

Start from the source node and mark it as visited.

Move to an adjacent unvisited node, marking it as visited.

Repeat this process until no unvisited nodes remain.

Backtrack to the previous node with unvisited neighbors and continue the traversal.

DFS is useful for applications that require pathfinding and connectivity checks, such as cycle
detection, topological sorting, and exploring maze-like structures.

Time Complexity: O(V + E), where V is the number of vertices and E is the number of edges.
164
Space Complexity: O(V), mainly due to the stack used for recursive calls or explicit stack
implementation.

2. Breadth-First Search (BFS)

Breadth-First Search (BFS) is a graph traversal algorithm that explores nodes level by level,
starting from the source node and visiting all its neighbors before moving to the next level.
BFS uses a queue to keep track of nodes, ensuring that nodes are visited in the order they were
discovered. This "breadth-first" approach is ideal for finding the shortest path in unweighted
graphs.

Steps in BFS:

Start from the source node and mark it as visited.

Enqueue all unvisited neighbors of the current node.

Dequeue the next node and mark it as visited.

Repeat this process until all reachable nodes are visited.

BFS is particularly useful in applications requiring shortest path discovery in unweighted
graphs, such as finding the minimum number of moves in a game, or shortest paths in social
networks.

Time Complexity: O(V + E), where V is the number of vertices and E is the number of edges.

Space Complexity: O(V), as a queue is used to store nodes at each level.

Dijkstra’s Algorithm for Shortest Path

Dijkstra’s Algorithm is a shortest path algorithm used to find the minimum path between nodes
in a weighted graph. The algorithm starts from a source node and iteratively selects the node
with the smallest known distance, updating distances to its neighbors. Dijkstra’s algorithm is
widely used in applications where the shortest path is required, such as routing, logistics, and
navigation.

 Steps in Dijkstra’s Algorithm:

Initialize the distance of the source node to 0 and all other nodes to infinity.

Place all nodes in a priority queue with their distances.

165
While the queue is not empty:

Remove the node with the smallest distance from the queue.

Update the distances of its neighbors if a shorter path is found.

Reinsert or update nodes in the priority queue with new distances.

Dijkstra’s algorithm is efficient for graphs with non-negative weights, but it may not work
correctly if negative weights are present, as it assumes that once a node is processed, its shortest
distance is finalized.

Time Complexity: O((V + E) log V) with a priority queue. Space

Complexity: O(V), as distances are stored for each vertex.

Applications of Graph Traversals

Graph traversals are used in a variety of real-world applications, where exploring and analyzing
connectivity is essential.

 Pathfinding and Maze Solving

DFS and BFS are commonly used in pathfinding and maze-solving algorithms. In mazes and
grid-based games, BFS finds the shortest path from a starting point to a destination, while DFS
can be used to explore all paths and detect cycles. Pathfinding applications extend to robot
navigation, where robots need to find the optimal route in a structured environment.

 Social Network Analysis

In social networks, DFS and BFS help analyze relationships between users. BFS is useful for
finding the shortest connection path between users, while DFS explores user connections to
determine communities and mutual friends. Social network platforms use these algorithms to
suggest friends and detect clusters within the network.

 Web Crawling

Web crawling, which involves navigating the links between web pages, utilizes DFS or BFS
to systematically explore and index content across the internet. A crawler starts from a given
URL and traverses through linked pages, using DFS for depth-based exploration and BFS for
breadth-based coverage. Web crawlers need to track visited pages to avoid cycles and endless
loops.

166
  Cycle Detection in Graphs

Detecting cycles in graphs is crucial in dependency management and circuit design. DFS-based
cycle detection helps identify cyclic dependencies in build systems or detect loops in digital
circuits. By examining back edges during DFS traversal, developers can identify cyclic
structures, preventing errors in scheduling or system configuration.

 Network Routing

Dijkstra’s algorithm is widely applied in network routing, where finding the shortest path for
data packets is essential. Routers use Dijkstra’s algorithm to calculate the least-cost paths
between network nodes, optimizing the flow of data and minimizing latency. This is crucial in

large-scale networks, including the internet, where efficient routing is necessary for high
performance.

 Logistics and Navigation

Dijkstra’s algorithm is used in logistics and navigation applications to calculate optimal routes
between locations. Delivery services, GPS navigation, and transportation systems rely on
Dijkstra’s algorithm to find the shortest paths, minimizing fuel costs and travel time. Route
optimization is crucial in supply chain management, where companies aim to streamline
logistics and reduce costs.

Spanning Tree
A Spanning Tree of a graph is a subset of the graph that includes all the vertices with the minimum
number of edges and without any cycles. The key property of a spanning tree is that it has exactly
V−1V - 1V−1 edges, where VVV is the number of vertices in the graph.
There are two main methods used to find a Minimum Spanning Tree (MST), where the goal is to
not only span the tree but also minimize the sum of the edge weights:
1. Kruskal’s Algorithm
Kruskal's Algorithm is a greedy algorithm that works by sorting the edges of the graph in increasing
order of their weights and adding them to the spanning tree, provided they do not form a cycle.
Steps for Kruskal's Algorithm:
1. Sort all the edges in increasing order of their weights.
2. Initialize the MST as an empty set.
3. Process each edge, and for each edge:
o If adding the edge doesn't form a cycle (checked using a union-find data structure), add it to the MST.
167
4. Repeat the process until the MST contains V−1V - 1V−1 edges.
5. The resulting edges form the minimum spanning tree.
Time Complexity:
 Sorting edges: O(Elog⁡E)O(E \log E)O(ElogE), where EEE is the number of edges.
 Union-Find operations: O(α(V))O(\alpha(V))O(α(V)), where α\alphaα is the inverse Ackermann
function (which is nearly constant).
 Overall: O(Elog⁡E)O(E \log E)O(ElogE)
2. Prim’s Algorithm
Prim's Algorithm is another greedy algorithm that grows the MST starting from an arbitrary node.
It expands the tree by adding the smallest edge that connects a vertex in the tree to a vertex outside
the tree.
Steps for Prim’s Algorithm:
1. Start from an arbitrary vertex and add it to the MST.
2. Find the edge with the smallest weight that connects a vertex in the MST to a vertex outside the MST.
3. Add this edge and vertex to the MST.
4. Repeat until all vertices are included in the MST.
5. The result is the minimum spanning tree.
Time Complexity:
 Using a priority queue (min-heap): O(Elog⁡V)O(E \log V)O(ElogV)
 Without using priority queues: O(V2)O(V^2)O(V2)
Differences Between Kruskal’s and Prim’s Algorithms:
 Kruskal's Algorithm: Works by adding edges in increasing order of their weights. It is better for
sparse graphs because it processes edges independently.
 Prim's Algorithm: Works by adding vertices and expanding the tree from a starting vertex. It is
often more efficient for dense graphs.
Other Algorithms for Spanning Trees:
 Boruvka’s Algorithm: Another algorithm for finding MSTs, which works by repeatedly finding the
minimum weight edge for each component of the graph and merging the components. It works well
in parallel computing.
Applications of Spanning Trees:
 Network design (such as in laying out cables or wiring).
 Cluster analysis (in machine learning).
 Solving puzzles like the traveling salesman problem.

168
 5.4 Practice Programs

The following practice programs help reinforce understanding of graph traversal and shortest
path algorithms through hands-on implementation.

Implement Depth-First Search (DFS) for Graph Traversal

Objective: Write a program to perform DFS on a given graph and print the nodes in the order
they are visited.

Description: Implement DFS using recursion or a stack. Take the graph as an adjacency list
input and print the traversal order.

Sample Input: A graph represented as an adjacency list.

Expected Output: The order in which nodes are visited.

Implement Breadth-First Search (BFS) for Graph Traversal

Objective: Write a program to perform BFS on a given graph and print the nodes in the order
they are visited.

Description: Implement BFS using a queue. Input the graph as an adjacency list and print each
node as it is visited.

Sample Input: A graph represented as an adjacency list.

Expected Output: The BFS traversal order from the source node.

169
MCQ:

Which type of tree has nodes with at most two children?

(A) Binary Tree

(B) Ternary Tree
(C) AVL Tree
(D) B-Tree
Answer: (A)

What is the balance factor of a perfectly balanced AVL tree?

(A) -1
(B) 0
(C) 1
(D) Any value
Answer: (B)

Which traversal method processes nodes in the order: root, left, right?

(A) Preorder
(B) Inorder
(C) Postorder
(D) Level-order
Answer: (A)

What is the height of a tree with only a root node?

(A) 0
(B) 1
(C) 2
(D) -1
Answer: (A)

170
Which type of binary tree ensures that the left child is smaller and the right child is greater
than the parent?

(A) Binary Search Tree

(B) AVL Tree
(C) Full Binary Tree
(D) Heap
Answer: (A)

What is the time complexity of Breadth-First Search in an adjacency list?

(A) O(V²)
(B) O(V + E)
(C) O(VE)
(D) O(V log V)
Answer: (B)

Which graph representation uses more memory for sparse graphs?

(A) Adjacency List

(B) Adjacency Matrix
(C) Both are equal
(D) None of the above
Answer: (B)

What is the goal of Kruskal's Algorithm?

(A) Find the shortest path

(B) Find the minimum spanning tree
(C) Traverse all nodes
(D) Sort graph edges
Answer: (B)

171
 CHAPTER 6

Searching and Sorting

6.1 Introduction to Searching and Sorting

Fig 30 : Search Algorithms

Searching and sorting are foundational operations in computer science, used to retrieve and
organize data efficiently. Whether it's finding a specific item in a dataset or arranging data in a
specific order, these operations are crucial in a wide range of applications, from database
management and e-commerce to operating systems and data analysis. The efficiency of
searching and sorting algorithms directly impacts the performance of programs, especially
when dealing with large datasets. This section covers the importance of efficient searching and
sorting, real-life use cases, and explores different types of searching and sorting algorithms
with detailed explanations.

 Importance of Efficient Searching and Sorting

Efficient searching and sorting are critical for optimizing data retrieval and manipulation,
especially when dealing with large datasets. Searching allows us to quickly locate items or
information, while sorting enables structured organization of data, making it easier to analyze,
process, and access. Both operations are fundamental in applications that require high
performance, as inefficient searching and sorting can slow down entire systems.

172
Performance Optimization: Efficient searching and sorting algorithms minimize the time
complexity for retrieving and organizing data. A well-designed algorithm can process
thousands or even millions of elements swiftly, while an inefficient algorithm may struggle to
handle large volumes, leading to performance bottlenecks.

Data Management: Sorting data enables structured storage, making it easier to manage, update,
and access. Sorted data is more accessible for analysis, allowing for more efficient search
techniques (like binary search), while unsorted data requires linear search methods that may
take longer to complete.

Enhanced User Experience: In applications like e-commerce or search engines, users expect
quick responses when searching for products or information. Efficient algorithms ensure rapid
retrieval, providing a smoother and more responsive experience.

 Real-Life Use Cases and Applications

Efficient searching and sorting algorithms are vital in numerous real-world scenarios, where
quick data retrieval and organization are essential.

 Database Management

Databases often contain vast amounts of information that need to be queried and sorted
efficiently. For instance, when retrieving customer data or filtering records by criteria,
optimized searching algorithms enable databases to respond quickly. Sorting algorithms are
used to organize data in ascending or descending order, making queries more efficient and
providing ordered results to users.

 E-Commerce and Online Search

In e-commerce, searching algorithms are used to filter and retrieve products based on user
queries, while sorting algorithms arrange products by price, relevance, or popularity. Efficient
searching ensures that users can quickly find what they need, while sorting enhances their
browsing experience, helping them locate the best options within seconds.

 Data Analysis and Visualization

In data analysis, sorting and searching algorithms organize data before analysis, enabling faster
computations and clearer visualizations. For instance, sorted data allows analysts to create

173
accurate charts and graphs, identify trends, and extract meaningful insights more efficiently.
Large-scale data processing frameworks, like Hadoop and Spark, rely on sorting algorithms to
organize and process data efficiently.

 Networking and Internet Routing

In networking, sorting and searching are used in routing algorithms to find the optimal path for
data packets. Sorting helps in prioritizing data traffic, while searching enables efficient lookup
of routing tables. Algorithms like Dijkstra’s shortest path for routing use sorting and searching
concepts to optimize the speed and efficiency of data transfer over networks.
6.2 Types of Searching

This section explores the various types of searching and sorting algorithms, detailing how they
work, their time complexities, and their specific use cases.

 Linear Search and Binary Search

Linear Search and Binary Search are the two primary searching techniques, each suited to
different types of data structures and use cases.

1. Linear Search

Linear Search is the simplest searching algorithm, where each element in a list is sequentially
checked until the desired item is found or the list ends. Linear search does not require the data
to be sorted, making it useful for unsorted lists or arrays.

How It Works: Starting from the first element, each element is compared to the target value. If
a match is found, the index of that element is returned; otherwise, the algorithm moves to the
next element.

Time Complexity: O(n), where n is the number of elements in the list. The algorithm may need
to check every element in the worst-case scenario.

174
 Use Cases: Linear search is suitable for small datasets or when data is unsorted, as it requires
minimal setup and operates sequentially.

Example
#include <stdio.h>
int linearSearch(int arr[], int size, int target) {
for (int i = 0; i < size; i++) {
if (arr[i] == target) {
return i; // Return the index where the target is found
}
}
return -1; // Return -1 if the target is not found
}
int main() {
int arr[] = {10, 20, 30, 40, 50};
int target = 30;
int size = sizeof(arr) / sizeof(arr[0]);
int result = linearSearch(arr, size, target);
if (result != -1) {
printf("Element %d found at index %d\n", target, result);
} else {
printf("Element %d not found in the array\n", target);
}
return 0;
}
Output:
Element 30 found at index 2

2. Binary Search

175
Binary Search is an efficient searching algorithm that works on sorted datasets. By repeatedly
dividing the search interval in half, binary search locates the target value quickly, making it
significantly faster than linear search for large datasets.

How It Works: Binary search starts by comparing the middle element of the list with the target
value. If the target is equal to the middle element, the search is complete. If the target is smaller,
the search continues in the left half; if larger, it continues in the right half. This process repeats
until the target is found or the list is exhausted.

Time Complexity: O(log n), where n is the number of elements. By halving the search range
with each step, binary search achieves logarithmic efficiency.

Use Cases: Binary search is ideal for large, sorted datasets, such as searching in a phone book,
finding records in databases, or looking up words in a dictionary.

Example

#include <stdio.h>

// Function to perform binary search

int binarySearch(int arr[], int size, int target) {

int low = 0, high = size - 1, mid;

while (low <= high) {

mid = low + (high - low) / 2;

// Check if target is present at mid

176
 if (arr[mid] == target) {

return mid;

// If target is greater, ignore left half

if (arr[mid] < target) {

low = mid + 1;

// If target is smaller, ignore right half

else {

high = mid - 1;

// If target is not found

return -1;

int main() {

int arr[] = {2, 5, 8, 12, 16, 23, 38, 41, 59, 74};

int size = sizeof(arr) / sizeof(arr[0]);

int target = 23;

int result = binarySearch(arr, size, target);

if (result != -1) {

printf("Element %d is present at index %d\n", target, result);

} else {

printf("Element %d not found in the array.\n", target);

return 0;

177
}

Output:

Element 23 is present at index 5

6.3 Sorting: Bubble Sort, Quick Sort, Merge Sort

Fig 31 : Sorting

Sorting algorithms organize data in a specific order, such as ascending or descending, and each
algorithm offers different efficiencies and approaches. Here are some of the most commonly
used sorting algorithms.

1. Bubble Sort

178
Bubble Sort is a straightforward but inefficient sorting algorithm that repeatedly steps through
the list, compares adjacent elements, and swaps them if they are in the wrong order. This
process continues until no more swaps are needed.

How It Works: Bubble sort compares each pair of adjacent elements and swaps them if
necessary. After each pass, the largest unsorted element "bubbles" to its correct position at the
end of the list.

Time Complexity: O(n²), where n is the number of elements. Bubble sort has a high time
complexity, making it inefficient for large datasets.

Use Cases: Bubble sort is primarily used for educational purposes to illustrate basic sorting
concepts. It may be used on small datasets or nearly sorted data, where only minor adjustments
are needed.

Example

#include <stdio.h>

void bubbleSort(int arr[], int n) {

int i, j, temp;

for (i = 0; i < n-1; i++) {

for (j = 0; j < n-i-1; j++) {

if (arr[j] > arr[j+1]) {

// Swap the elements

temp = arr[j];

arr[j] = arr[j+1];

arr[j+1] = temp;

void printArray(int arr[], int size) {

for (int i = 0; i < size; i++) {

179
 printf("%d ", arr[i]);

printf("\n");

int main() {

int arr[] = {64, 34, 25, 12, 22, 11, 90};

int n = sizeof(arr)/sizeof(arr[0]);

printf("Unsorted array: \n");

printArray(arr, n);

bubbleSort(arr, n);

printf("Sorted array: \n");

printArray(arr, n);

return 0;

Output:

Unsorted array:

64 34 25 12 22 11 90

Sorted array:

11 12 22 25 34 64 90

2. Quick Sort

180
Quick Sort is a divide-and-conquer sorting algorithm that selects a "pivot" element and
partitions the array into two subarrays: elements less than the pivot and elements greater than
the pivot. The process is then recursively applied to each subarray.

How It Works: Quick sort selects a pivot and partitions the array so that all elements less than
the pivot are on the left and those greater are on the right. It then recursively sorts the subarrays,
eventually merging them into a sorted array.

Time Complexity: O(n log n) on average; however, it can be O(n²) in the worst case if the pivot
selection is poor. Using randomized or median pivot selection can reduce the chances of hitting
the worst case.

Use Cases: Quick sort is widely used in applications requiring fast sorting, such as in database
management, due to its efficiency and low space complexity compared to other algorithms.

Example

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

int temp = *a;

181
 *a = *b;

*b = temp;

int partition(int arr[], int low, int high) {

int pivot = arr[high];

int i = (low - 1);

for (int j = low; j <= high - 1; j++) {

if (arr[j] < pivot) {

i++;

swap(&arr[i], &arr[j]);

swap(&arr[i + 1], &arr[high]);

return (i + 1);

void quickSort(int arr[], int low, int high) {

if (low < high) {

int pi = partition(arr, low, high);

quickSort(arr, low, pi - 1);

quickSort(arr, pi + 1, high);

void printArray(int arr[], int size) {

for (int i = 0; i < size; i++)

printf("%d ", arr[i]);

printf("\n");

int main() {

int arr[] = {10, 7, 8, 9, 1, 5};

int n = sizeof(arr) / sizeof(arr[0]);

182
 printf("Original array: ");

printArray(arr, n);

quickSort(arr, 0, n - 1);

printf("Sorted array: ");

printArray(arr, n);

return 0;

Output:

Original array: 10 7 8 9 1 5

Sorted array: 1 5 7 8 9 10

3. Merge Sort

Merge Sort is a stable, divide-and-conquer algorithm that divides the list into halves, sorts each
half, and then merges the sorted halves back together. Merge sort is particularly useful for
sorting linked lists and large datasets due to its stability and predictable O(n log n) time
complexity.

183
 Table 1: Comparison of Sorting Algorithms

Algorithm Time Time Time Space Stable

Complexity Complexity Complexity Complexity
(Best) (Average) (Worst)
Bubble Sort O(n) O(n²) O(n²) O(1) Yes
Quick Sort O(n log n) O(n log n) O(n²) O(log n) No
Merge Sort O(n log n) O(n log n) O(n log n) O(n) Yes

Insertion O(n) O(n²) O(n²) O(1) Yes

Sort
Selection O(n²) O(n²) O(n²) O(1) No
Sort

How It Works: Merge sort recursively divides the list into smaller sublists until each sublist
contains a single element. It then merges these sorted sublists back together in the correct order.

Time Complexity: O(n log n), as the list is divided repeatedly, and merging takes linear time.

Use Cases: Merge sort is suitable for sorting large datasets, linked lists, and datasets that require
stability (where elements with equal keys retain their order).

Example
#include <stdio.h>
void merge(int arr[], int left, int mid, int right) {
int n1 = mid - left + 1;
int n2 = right - mid;
int L[n1], R[n2];
// Copy data to temp arrays L[] and R[]
for (int i = 0; i < n1; i++) {
L[i] = arr[left + i];
}
for (int j = 0; j < n2; j++) {
R[j] = arr[mid + 1 + j];
}
// Merge the temp arrays back into arr[left..right]
int i = 0, j = 0, k = left;
184
 while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
} else {
arr[k] = R[j];
j++;
}
k++;
}
// Copy the remaining elements of L[], if any
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
// Copy the remaining elements of R[], if any
while (j < n2) {
arr[k] = R[j];
j++;
k++;
}
}
void mergeSort(int arr[], int left, int right) {
if (left < right) {
int mid = left + (right - left) / 2;
// Sort first and second halves
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);

// Merge the sorted halves

merge(arr, left, mid, right);
}
}
void printArray(int arr[], int size) {
for (int i = 0; i < size; i++) {
printf("%d ", arr[i]);

185
 }
printf("\n");
}
int main() {
int arr[] = {38, 27, 43, 3, 9, 82, 10};
int arr_size = sizeof(arr) / sizeof(arr[0]);

printf("Unsorted array: \n");

printArray(arr, arr_size);
mergeSort(arr, 0, arr_size - 1);
printf("\nSorted array: \n");
printArray(arr, arr_size);
return 0;
}
Output:
Unsorted array:
38 27 43 3 9 82 10
Sorted array:
3 9 10 27 38 43 82

4. Insertion Sort

Insertion Sort is a simple algorithm that builds the final sorted array one item at a time by

186
repeatedly picking the next element and inserting it into its correct position in the sorted portion
of the list.

How It Works: Starting with a single sorted element, each new element is picked from the
unsorted portion and placed in the correct position within the sorted portion.

Time Complexity: O(n²), making it inefficient for large datasets but effective for small or nearly
sorted lists.

Use Cases: Insertion sort is commonly used for small datasets or nearly sorted data. It is
efficient for sorting small arrays, making it useful as a base case in hybrid sorting algorithms
like Timsort.

Example

#include <stdio.h>

// Function to implement Insertion Sort

void insertionSort(int arr[], int n) {

int i, key, j;

for (i = 1; i < n; i++) {

key = arr[i];

j = i - 1;

// Move elements of arr[0..i-1], that are greater than key, to one position ahead

while (j >= 0 && arr[j] > key) {

arr[j + 1] = arr[j];

j = j - 1;

arr[j + 1] = key;

// Function to print an array

void printArray(int arr[], int size) {

for (int i = 0; i < size; i++) {

printf("%d ", arr[i]);

187
 printf("\n");

int main() {

int arr[] = {12, 11, 13, 5, 6};

int n = sizeof(arr) / sizeof(arr[0]);

printf("Original array: \n");

printArray(arr, n);

insertionSort(arr, n);

printf("Sorted array: \n");

printArray(arr, n);

return 0;

Output:

Original array:

12 11 13 5 6

Sorted array:

5 6 11 12 13

5. Selection Sort

188
Selection Sort works by repeatedly finding the minimum element from the unsorted portion
and placing it at the beginning. It maintains two subarrays: the sorted and unsorted portions of
the array.

How It Works: Selection sort finds the minimum element in the unsorted portion and swaps it
with the first unsorted element. This process continues until all elements are sorted.

189
Time Complexity: O(n²), as each element must be compared with the remaining unsorted
elements.

Use Cases: Selection sort is suitable for small datasets or when memory write operations need
to be minimized, as it makes fewer swaps than bubble sort.

Searching and sorting algorithms are vital for efficient data management, retrieval, and
organization. Linear and binary search algorithms allow data to be found quickly, with binary
search providing superior performance on sorted data. Sorting algorithms, from simple
techniques like bubble sort to efficient algorithms like quick sort and merge sort, cater to
various needs, from small datasets to massive data handling. Choosing the right algorithm
depends on factors like dataset size, required stability, and time constraints, making an
understanding of these algorithms essential for effective programming and data handling.

Example

#include <stdio.h>

void selectionSort(int arr[], int n) {

int i, j, minIdx, temp;

// One by one move the boundary of the unsorted subarray

for (i = 0; i < n - 1; i++) {

minIdx = i;

// Find the minimum element in unsorted array

for (j = i + 1; j < n; j++) {

if (arr[j] < arr[minIdx]) {

minIdx = j;

// Swap the found minimum element with the first element

temp = arr[minIdx];

arr[minIdx] = arr[i];

190
 arr[i] = temp;

int main() {

int arr[] = {64, 25, 12, 22, 11};

int n = sizeof(arr) / sizeof(arr[0]);

printf("Unsorted Array: ");

for (int i = 0; i < n; i++) {

printf("%d ", arr[i]);

selectionSort(arr, n);

printf("\nSorted Array: ");

for (int i = 0; i < n; i++) {

printf("%d ", arr[i]);

return 0;

Output:

Unsorted Array: 64 25 12 22 11

Sorted Array: 11 12 22 25 64

191
MCQ:

Which of the following is the worst-case time complexity of Binary Search?

(A) O(n)
(B) O(log n)
(C) O(n log n)
(D) O(1)
Answer: (B)

Which sorting algorithm is based on the "divide and conquer" approach?

(A) Bubble Sort

(B) Selection Sort
(C) Merge Sort
(D) Insertion Sort
Answer: (C)

In the worst case, which sorting algorithm has the time complexity of O(n²)?

(A) Quick Sort

(B) Merge Sort
(C) Heap Sort
(D) Bubble Sort
Answer: (D)

Which of the following is NOT a comparison-based sorting algorithm?

(A) Quick Sort

(B) Merge Sort
(C) Counting Sort
(D) Heap Sort
Answer: (C)

192
What is the main advantage of using Binary Search over Linear Search?

(A) Binary Search works on unsorted data.

(B) Binary Search is faster for large, sorted data.
(C) Binary Search can be applied to both sorted and unsorted data.
(D) Linear Search is faster than Binary Search.
Answer: (B)

Which of the following sorting algorithms is considered to be the most efficient for large datasets?

(A) Quick Sort

(B) Bubble Sort
(C) Selection Sort
(D) Insertion Sort
Answer: (A)

Which sorting algorithm works by repeatedly selecting the minimum element and swapping it
with the first unsorted element?

(A) Bubble Sort

(B) Quick Sort
(C) Selection Sort
(D) Merge Sort
Answer: (C)

What is the best-case time complexity of Quick Sort?

(A) O(n²)
(B) O(n log n)
(C) O(n)
(D) O(1)
Answer: (B)

193
 Chapter 7

File Handling

7.1 Concept of Files: Text and Binary

Fig 32 : Text Files and Binary Files

Files are a fundamental concept in computing, used to store and manage data persistently. Files
allow programs to save and retrieve data across sessions, supporting various applications, from
document storage to database management. Files come in two main types: text files and binary
files, each with distinct characteristics and use cases.

 Differences Between Text and Binary Files

Understanding the differences between text and binary files is essential, as each serves different
purposes and has unique storage formats.

194
 A. Text Files

Text files store data in human-readable form, using characters encoded in formats like ASCII
or UTF-8. Each line in a text file is typically terminated by a newline character, making it easy
for users and programs to parse and modify content. Text files are commonly used for
documents, configuration files, source code, and logs, as they are easy to view and edit with
basic text editors.

Storage Format: Text files store data as plain characters, with each character represented by its
ASCII or Unicode value.

Readability: Text files are readable by humans and easy to interpret.

Size: Text files can be larger than binary files for the same data, as each character, including
spaces and line breaks, is stored separately.

Use Cases: Configuration files, logs, source code files, HTML/XML files.

B. Binary Files

Binary files store data in a non-human-readable format, using binary code. Binary files can
represent complex data structures, such as images, audio, video, and compiled programs.
Unlike text files, binary files do not rely on character encoding and can store data compactly
and efficiently, often resulting in smaller file sizes.

Storage Format: Binary files store data in binary format, with each byte representing raw data
without character encoding.

Readability: Binary files are not human-readable; they require specific software to interpret the
data.

Size: Binary files are generally more compact, as they eliminate the need for character encoding
and line breaks.

Use Cases: Images, videos, audio files, executable programs, database files.

 Use Cases for Each Type

Text and binary files serve distinct purposes and are used in various applications based on their
storage format and readability.

195
Use Cases for Text Files

Configuration Files: Text files are often used for configuration settings in software
applications. These files, typically in formats like .INI or .CFG, store parameters in a readable
format that users or administrators can easily modify.

Log Files: Log files, such as server or application logs, are stored as text to allow easy
inspection and troubleshooting. System administrators rely on text logs to track events, errors,
and access data.

Source Code and Scripts: Programming languages use text files to store source code, as code
is meant to be human-readable. Developers write, edit, and compile code from text files,
supporting collaborative development and version control.

Data Serialization for Simple Applications: Text files can store serialized data in formats like
CSV (Comma-Separated Values) and JSON (JavaScript Object Notation), making them ideal
for exchanging structured data in a human-readable format. CSV and JSON files are used for
data exchange between different applications or for simple databases.

Documentation: Text files are used for documents like README files, which provide
information about software projects. They are stored as plain text to ensure universal
compatibility across platforms and editors.

Use Cases for Binary Files

Media Files: Binary files are used for media such as images (JPEG, PNG), videos (MP4, AVI),
and audio (MP3, WAV). Binary storage allows media files to be compressed and stored
efficiently, providing high-quality playback with minimal file size.

Executable Files: Compiled programs, such as executables (EXE) on Windows or binaries on

Linux, are stored as binary files. These files contain machine code that can be directly executed
by the operating system, providing efficient and fast performance.

Database Files: Databases often store data in binary format to optimize storage and retrieval
efficiency. Binary databases, such as SQL databases and proprietary binary formats, allow for
complex data structures and faster access than text-based alternatives.

Serialization of Complex Data Structures: In applications where complex data structures need
to be saved and loaded, binary files allow efficient serialization of data. Languages like Python
and Java provide serialization tools for saving objects and data structures in binary format.

196
Computer Games and Interactive Applications: Game files, which include assets,
configurations, and resources, are stored in binary format for performance optimization. By
storing resources as binary, games can load assets quickly, providing a smoother user
experience.

Text and binary files offer unique advantages for storing data, and understanding their
differences is crucial for selecting the right format for a given application. Text files are suited
for human-readable content, configurations, logs, and data exchange, while binary files are
ideal for performance-intensive applications like media, executables, and databases. Choosing
the right file type helps developers design efficient and user-friendly applications that balance
readability and storage efficiency.

7.2 File Input/Output Functions

Fig 33: Input and Output Streams

File handling is a fundamental concept in programming, enabling data to be stored and

retrieved from persistent storage. File Input/Output (I/O) functions allow programs to read data
from files and write data to files, supporting long-term data retention across sessions.
Understanding file operations is essential for building applications that manage data, from

197
 simple text logs to complex databases. This section covers basic file operations, practical
examples of file handling, formatted and character-based I/O functions, and practice programs
to reinforce these concepts.

 Basic File Operations: Open, Close, Read, Write

The core file operations—open, close, read, and write—form the foundation of file handling.
These operations allow programs to access files, manipulate their content, and close them to
save changes.

Basic Steps for File Handling

1. Open a File: Use fopen() with modes like "r", "w", "a", etc.
2. Perform Operations: Use functions like fgetc(), fputc(), fprintf(), fscanf(), etc.
3. Close the File: Use fclose() to close the file and free resources.

Opening Files

The open operation initiates a connection between a program and a file, allowing data to be
read or written. Depending on the programming language, files can be opened in different
modes, each specifying the type of access allowed.

File Modes

Mode Description
"r" Open for reading (file must exist).
"w" Open for writing (creates/overwrites).
"a" Open for appending (creates if missing).
"r+" Open for reading and writing.
"w+" Open for reading and writing (overwrites).
"a+" Open for reading and appending.

Syntex:

FILE *filePointer;

filePointer = fopen("filename", "mode");

198
Closing Files

The close operation terminates the connection between the program and the file, ensuring that
all data is saved and resources are released. Closing files is crucial for preventing data
corruption and conserving system resources.

Syntex:
int fclose(FILE *stream);

Reading from Files

The read operation extracts data from a file. Different functions allow data to be read as a
whole, line by line, or in chunks.
read(): Reads the entire file.

readline(): Reads one line at a time, useful for processing line-by-line content.

readlines(): Reads all lines and returns a list of strings, each representing a line.

Example

#include <stdio.h>
#include <stdlib.h>

int main() {
FILE *file;
char *content;
long file_size;

// Open the file in read mode

file = fopen("example.txt", "r");
if (file == NULL) {
printf("Error: Could not open file.\n");
return 1;
}

// Seek to the end of the file to determine its size

fseek(file, 0, SEEK_END);
file_size = ftell(file);
rewind(file);

// Allocate memory to hold the file content

content = (char *)malloc(file_size + 1);
if (content == NULL) {
printf("Error: Memory allocation failed.\n");
fclose(file);
return 1;
}

199
 // Read the file content
fread(content, 1, file_size, file);
content[file_size] = '\0'; // Null-terminate the string

// Print the content

printf("File Content:\n%s\n", content);

// Clean up
free(content);
fclose(file);

return 0;
}

Writing to Files

The write operation inserts data into a file. Writing can overwrite existing content or append
new data, depending on the mode.

write(): Writes a string to the file.

writelines(): Writes a list of strings to the file.

Example

#include <stdio.h>

int main() {
FILE *file;

// Open the file in write mode

file = fopen("example.txt", "w");
if (file == NULL) {
printf("Error: Could not open file.\n");
return 1;
}

// Write text to the file

fprintf(file, "Hello, World!");

// Close the file

fclose(file);

return 0;
}

Append in File Handling

In file handling, append refers to adding data to the end of an existing file without modifying or
200
 overwriting its current content. The new data is written after the existing content, preserving what
was already in the file.

How Append Works

1. The file is opened in append mode ("a" or "a+").

o If the file does not exist, it is created.
o If the file exists, the write position is set at the end of the file.
2. New data is added at the end of the file.
3. The existing content remains unchanged.

File Modes for Append

Mode Description
"a" Open for appending. If the file doesn’t exist, it is created.
"a+" Open for reading and appending. If the file doesn’t exist, it is created.

Example

#include <stdio.h>

int main() {
FILE *file = fopen("example.txt", "a");
if (file == NULL) {
printf("Error: Unable to open the file.\n");
return 1;
}
fprintf(file, "This is appended text.\n");
fclose(file);
return 0;
}
Output:
Hello, World!
This is appended text.

201
 7.3 Practices Programs

1. Write a program that creates a text file, writes user input, and reads the content. #include

<stdio.h>

#include <stdlib.h>

int main() {

FILE *file;

char filename[100];

char data[200];

// Step 1: Create and Write to a File

printf("Enter the filename to create: ");

scanf("%s", filename);

// Open the file in write mode

file = fopen(filename, "w");

if (file == NULL) {

printf("Error: Unable to create the file.\n");

return 1;

printf("Enter text to write into the file (Press Enter to finish):\n");

getchar(); // Consume leftover newline

fgets(data, sizeof(data), stdin); // Get user input

fprintf(file, "%s", data); // Write data to the file

fclose(file); // Close the file after writing

printf("Data written successfully to %s.\n\n", filename);

// Step 2: Read from the File

file = fopen(filename, "r");

if (file == NULL) {

202
 printf("Error: Unable to open the file.\n");

return 1;

printf("Contents of the file:\n");

while (fgets(data, sizeof(data), file) != NULL) {

printf("%s", data); // Print the file contents

fclose(file); // Close the file after reading

return 0;

Input :

Enter the filename to create: example.txt

Enter text to write into the file (Press Enter to finish):

Hello, this is a test for file handling in C.

Output:

Data written successfully to example.txt.

Contents of the file:

Hello, this is a test for file handling in C.

2. Create a simple log system that appends messages to a log file.

#include <stdio.h>

#include <stdlib.h>

int main() {

FILE *logFile;

char logMessage[256];

char filename[] = "logfile.txt";

// Open the log file in append mode, create it if it doesn't exist

203
 logFile = fopen(filename, "a");

if (logFile == NULL) {

printf("Error: Unable to open log file.\n");

return 1;

// Prompt the user to enter log messages

printf("Enter log messages (type 'exit' to stop):\n");

while (1) {

printf("Log Message: ");

fgets(logMessage, sizeof(logMessage), stdin); // Get log message from user

// If the user types "exit", stop the program

if (strncmp(logMessage, "exit", 4) == 0) {

break;

// Append the message to the log file

fprintf(logFile, "%s", logMessage);

// Close the log file

fclose(logFile);

printf("Log messages have been successfully saved to %s.\n", filename);

return 0;

Input:

Enter log messages (type 'exit' to stop):

Log Message: System started.

Log Message: User logged in.

204
 Log Message: exit

Output:

Log messages have been successfully saved to logfile.txt.

3. Write a program to save and load a list of numbers in binary format.

#include <stdio.h>
#include <stdlib.h>

int main() {
FILE *file;
int numbers[] = {10, 20, 30, 40, 50};
int numCount = sizeof(numbers) / sizeof(numbers[0]);
char filename[] = "numbers.bin";
int loadedNumbers[5];

// Step 1: Save numbers to a binary file

file = fopen(filename, "wb"); // Open in binary write mode
if (file == NULL) {
printf("Error: Unable to open file for writing.\n");
return 1;
}

fwrite(numbers, sizeof(int), numCount, file); // Write the array to the file

fclose(file); // Close the file after writing
printf("Numbers have been saved to the binary file '%s'.\n\n", filename);

// Step 2: Load numbers from the binary file

file = fopen(filename, "rb"); // Open in binary read mode
if (file == NULL) {
printf("Error: Unable to open file for reading.\n");
return 1;
}

fread(loadedNumbers, sizeof(int), numCount, file); // Read the data into the array
fclose(file); // Close the file after reading

// Step 3: Display the loaded numbers

printf("Loaded numbers from the binary file:\n");
for (int i = 0; i < numCount; i++) {
printf("%d ", loadedNumbers[i]);
}
printf("\n");

return 0;
}

Output:

Numbers have been saved to the binary file 'numbers.bin'.

Loaded numbers from the binary file:

205
 10 20 30 40 50

4. Create a program that copies the contents of one text file to another character by character.
#include <stdio.h>
#include <stdlib.h>

int main() {
FILE *sourceFile, *destinationFile;
char ch;
char sourceFileName[100], destinationFileName[100];

// Prompt the user for the source and destination filenames

printf("Enter the source file name: ");
scanf("%s", sourceFileName);
printf("Enter the destination file name: ");
scanf("%s", destinationFileName);

// Open the source file in read mode

sourceFile = fopen(sourceFileName, "r");
if (sourceFile == NULL) {
printf("Error: Unable to open source file.\n");
return 1;
}

// Open the destination file in write mode

destinationFile = fopen(destinationFileName, "w");
if (destinationFile == NULL) {
printf("Error: Unable to open destination file.\n");
fclose(sourceFile); // Close source file before exiting
return 1;
}

// Copy contents from source to destination character by character

while ((ch = fgetc(sourceFile)) != EOF) {
fputc(ch, destinationFile);
}

printf("Contents copied successfully from '%s' to '%s'.\n", sourceFileName, destinationFileName);

// Close both files

fclose(sourceFile);
fclose(destinationFile);

return 0;
}

Input:
Enter the source file name: source.txt
Enter the destination file name: destination.txt

Output:
Contents copied successfully from 'source.txt' to 'destination.txt'.
206
 5. Write a program to count words in a text file.

#include <stdio.h>
#include <ctype.h>

int main() {
FILE *file;
char filename[100];
char ch;
int wordCount = 0;
int inWord = 0;

// Prompt the user to enter the filename

printf("Enter the filename: ");
scanf("%s", filename);

// Open the file in read mode

file = fopen(filename, "r");
if (file == NULL) {
printf("Error: Unable to open the file.\n");
return 1;
}

// Read the file character by character

while ((ch = fgetc(file)) != EOF) {
// Check if the character is a space or newline
if (isspace(ch)) {
inWord = 0; // End of the current word
} else if (!inWord) {
inWord = 1; // Start of a new word
wordCount++; // Increment word count
}
}

// Close the file

fclose(file);

// Print the total word count

printf("Total words in the file: %d\n", wordCount);

return 0;
}

Input :
Enter the filename: sample.txt

Output:
Total words in the file: 10
207
MCQ :

Which file mode in C is used to open a file for writing and creating it if it doesn't exist?

(A) "r"
(B) "w"
(C) "a"
(D) "rb"
Answer: (B)

What does the function fgetc() do in C file handling?

(A) Reads one character from a file

(B) Writes one character to a file
(C) Reads an entire line from a file
(D) Closes the file
Answer: (A)

Which function is used to write data to a file in binary mode in C?

(A) fputc()
(B) fwrite()
(C) fprintf()
(D) fread()
Answer: (B)

Which of the following file modes opens the file for both reading and writing?

(A) "w+"
(B) "r+"
(C) "a+"
(D) "r"
Answer: (B)

What does the fclose() function do in C?

(A) Closes the file after reading or writing operations

(B) Opens a file
(C) Writes data to a file
(D) Reads data from a file
Answer: (A)

What happens if the fopen() function cannot open a file?

(A) It returns NULL

(B) It throws an exception
(C) It displays an error message
(D) It creates a new file automatically
Answer: (A)

208
Which function is used to read an entire line from a file in C?

(A) fscanf()
(B) fget()
(C) fgets()
(D) fread()
Answer: (C)

209
 CHAPTER 8

Specialized Data Structures

8.1 Hashing: Hash Functions and Collision Resolution Techniques

Hashing is a technique used to convert data (such as a string or number) into a unique, fixed-
size value called a hash code or hash value. This hash code is then used as an index to store the
data in an array-like structure known as a hash table. Hashing ensures efficient storage and
retrieval of data, as items can be accessed based on their computed hash code rather than by
searching through the entire data set.

 Understanding Hash Functions

A hash function is an algorithm that takes an input (or “key”) and returns a fixed-size hash
code. The hash code typically represents the index in a hash table where the data associated
with that key will be stored. A good hash function distributes data uniformly across the table,
minimizing collisions (where multiple keys hash to the same index).

Fig 34 : Distributed Hash Table (DHT) Diagram

210
Characteristics of a Good Hash Function:

Uniform Distribution: Hash values should be evenly distributed across the table to avoid
clustering.

Deterministic: The same input should always produce the same hash code.

Efficiency: The function should compute hash values quickly, even for large datasets.

Minimizes Collisions: Although collisions are inevitable, a good hash function minimizes the
likelihood of different inputs producing the same hash code.

Common hash functions include division-based hashing, multiplication-based hashing, and

cryptographic hash functions (such as SHA-256). However, cryptographic hashes are typically
slower and used for data integrity rather than hash table indexing.

 Collision Handling Techniques

Collisions occur when two different keys produce the same hash code. Since multiple keys
cannot occupy the same position in a hash table, a mechanism is needed to handle collisions
effectively. Common collision handling techniques include chaining and open addressing.

Fig 35: Chaining vs. Open Addressing

211
Chaining

Chaining is a technique where each position in the hash table contains a linked list of entries
that hash to the same index. When a collision occurs, the new entry is added to the linked list
at that index, allowing multiple entries to share the same position.

Advantages: Simple to implement; allows multiple entries per index without requiring a larger
hash table.

Disadvantages: May lead to longer retrieval times if the linked lists grow significantly;
additional memory is required for pointers.

Table 2 : Chaining and Open Addressing

Open Addressing

Open Addressing is a collision resolution technique where, instead of using linked lists, the
hash table itself is probed to find the next available position. There are different methods for
probing, including linear probing, quadratic probing, and double hashing.

Linear Probing: When a collision occurs, the algorithm checks the next slot (index + 1) until
an empty position is found. Linear probing is easy to implement but can lead to clustering,
where groups of consecutive filled slots slow down performance.
212
Quadratic Probing: This technique calculates the next position using a quadratic function. For
instance, if a collision occurs at index i, the next index is (i + 1²), (i + 2²), (i + 3²), ... and so on.
Quadratic probing reduces clustering but can still leave gaps in the table.

Double Hashing: Double hashing uses two hash functions to determine the next position. If
h1(k) is the primary hash function and h2(k) is the secondary hash function, the next position
after a collision is given by index = (h1(k) + i * h2(k)) % m, where i is the number of probes.
Double hashing provides better distribution of entries and minimizes clustering.

8.2 Hash Tables: Use Cases in Databases, Caching, and Memory Management

Hash tables are essential data structures for applications that require efficient key-value data
storage and quick retrieval. Due to their O(1) average-case time complexity for search,
insertion, and deletion operations, hash tables are widely used in databases, caching systems,
and memory management.

8.3.1 Use Cases in Databases

Databases often rely on hash tables for indexing, enabling fast data retrieval based on keys or
values.

Indexing: Hash tables allow databases to create efficient indexes for faster lookup times. For
instance, if a database contains a large number of employee records, it can use a hash table to
quickly access a record by employee ID. This hash-based indexing is faster than searching
through the database linearly.

Hashing for Data Partitioning: In distributed databases, hash functions are used to partition data
across multiple servers. By hashing a key (such as a user ID), data can be stored on a specific
server, reducing access time and balancing the workload.

Hash Joins: Hash tables are also used in hash join operations, a common technique in relational
databases. In a hash join, one table is hashed into a hash table, allowing the other table to be
joined quickly based on matching keys. This operation is efficient for joining large tables where
conventional joins would be slower.

8.3.2 Use Cases in Caching

Caching is a process where frequently accessed data is stored temporarily to speed up future
access. Hash tables are ideal for implementing caches due to their efficient key-value retrieval.

Web Caching: Hash tables are used to store frequently accessed web pages or resources. By

213
caching these resources, web applications can reduce server load and improve response times
for end users.

Memory Caching: In memory caching, hash tables store recently accessed data in memory. For
instance, in applications requiring frequent data access, hash tables are used to cache data,
reducing the need to access slower storage options, like disks.

Database Caching: Hash tables are used in database systems to cache query results, indexes, or
commonly accessed data. By storing the results of frequently run queries, hash tables reduce
the load on the database and provide faster access times for future queries.

Use Cases in Memory Management

Hash tables play an important role in memory management, especially in programming

languages that manage memory automatically.

Garbage Collection: Hash tables help track memory references in languages with garbage
collection. By hashing references to objects, the garbage collector can quickly determine which
objects are still in use and free up unused memory.

Symbol Tables: In programming languages, hash tables are used to store symbols (variable
names, function names, etc.) along with associated metadata. This symbol table allows the
compiler to quickly resolve identifiers, improving compilation efficiency.

Virtual Memory Paging: Hash tables can also be used in virtual memory systems to map virtual
addresses to physical memory addresses. The hash table maintains an index of memory pages,
allowing the operating system to manage memory more efficiently.

Advantages and Disadvantages of Hash Tables

Understanding the strengths and limitations of hash tables helps developers choose the right
data structure for their applications.

Advantages

Constant Time Complexity: Hash tables provide O(1) average-case time complexity for
insertion, search, and deletion, making them extremely efficient for large datasets.

Efficient Memory Usage: By using keys to compute storage positions, hash tables allow data
to be stored compactly.

Versatile: Hash tables can store different types of data and are flexible enough to handle

214
complex data structures through key-value pairs.

Disadvantages

Collision Handling Overhead: Collisions are unavoidable in hash tables, and managing them
can increase complexity.

Increased Memory Usage for Large Hash Tables: Large hash tables may require significant
memory, especially with collision handling through chaining.

Difficulty with Range Queries: Hash tables are not suitable for range queries (e.g., retrieving
all keys within a certain range), as they are designed for fast individual lookups rather than
sequential access.

Table 2: Collision Resolution Techniques

Technique Description Advantages Disadvantages
Chaining Linked list at each table Easy to implement; Extra memory for
index allows growth pointers; slower
when chains grow
Linear Moves to next slot on Simple; requires less Primary clustering;
Probing collision memory performance
degrades with high
load
Quadratic Uses quadratic function to Reduces clustering May leave gaps;
Probing resolve collision difficult to find
empty slots when
table fills
Double Uses a secondary hash Fewer clusters; Slightly more
Hashing function on collision better distribution complex to
implement

Example of Hash Table Implementation

Here is an example of a hash table implementation using chaining for collision resolution:

#include <stdio.h>

215
#include <stdlib.h>

#include <string.h>

#define TABLE_SIZE 10

// Define the structure for a node in the linked list

typedef struct Node {

int key;

char value[50];

struct Node *next;

} Node;

// Define the structure for the hash table

typedef struct HashTable {

Node *table[TABLE_SIZE];

} HashTable;

// Initialize the hash table

void init(HashTable *hash_table) {

for (int i = 0; i < TABLE_SIZE; i++) {

hash_table->table[i] = NULL;

// Hash function

int hash_function(int key) {

return key % TABLE_SIZE;

// Insert a key-value pair into the hash table

void insert(HashTable *hash_table, int key, const char

*value) {

int index = hash_function(key);

216
 Node *current = hash_table->table[index];

// Check if the key already exists and update the

value

while (current != NULL) {

if (current->key == key) {

strcpy(current->value, value);

return;

current = current->next;

// If key does not exist, add a new node

Node *new_node = (Node *)malloc(sizeof(Node));

new_node->key = key;

strcpy(new_node->value, value);

new_node->next = hash_table->table[index];

hash_table->table[index] = new_node;

// Search for a value by key

char *search(HashTable *hash_table, int key) {

int index = hash_function(key);

Node *current = hash_table->table[index];

while (current != NULL) {

if (current->key == key) {

return current->value;

current = current->next;

217
 return NULL; // Key not found

// Delete a key-value pair from the hash table

void delete(HashTable *hash_table, int key) {

int index = hash_function(key);

Node *current = hash_table->table[index];

Node *prev = NULL;

while (current != NULL) {

if (current->key == key) {

if (prev == NULL) {

hash_table->table[index] = current->next;

} else {

prev->next = current->next;

free(current);

return;

prev = current;

current = current->next;

// Example usage

int main() {

HashTable hash_table;

init(&hash_table);

// Insert values

insert(&hash_table, 15, "Value 1");

218
 insert(&hash_table, 25, "Value 2");

// Search for a key

char *value = search(&hash_table, 15);

if (value) {

printf("Found: %s\n", value);

} else {

printf("Key not found\n");

// Delete a key

delete(&hash_table, 15);

value = search(&hash_table, 15);

if (value) {

printf("Found: %s\n", value);

} else {

printf("Key not found\n");

return 0;

219
8.4 Specialized Data Structures

Specialized data structures offer efficient solutions for specific types of computational
problems, such as string matching, range queries, and data segmentation. Understanding these
data structures—Tries, Segment Trees, Fenwick Trees, Disjoint Set Union, and Suffix Trees—
equips developers and data scientists with powerful tools for optimized problem-solving in
areas such as search algorithms, query processing, and memory management. This section
explores each of these data structures, their use cases, and sample applications to illustrate their
utility.

Fig 36: Structure of a Trie

8.4.1 Tries for Efficient String Matching

A Trie (or prefix tree) is a specialized tree-like data structure commonly used for efficient
retrieval of strings and string prefixes. Tries enable fast search, insert, and delete operations,
making them ideal for tasks like autocomplete, spell checking, and dictionary implementations.

Structure of a Trie:

Each node in a Trie represents a single character of a word.

220
The path from the root to a node represents a prefix of the word.

Nodes may have multiple children, one for each possible character extension.

Operations in a Trie:
Insert: Adds a new word by creating a path from the root node to the end of the word, adding
new nodes as needed.

Search: Finds if a word exists by traversing from the root through each character.

Delete: Removes a word by freeing nodes if they are no longer part of another word.

Use Cases of Tries:

Autocomplete Systems: Predicts and suggests words as users type.

Spell Checkers: Quickly verifies if a word exists in the dictionary.

IP Routing: Assists in routing Internet traffic by finding the longest prefix match.

Example:

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

// Define the structure for a Trie Node

typedef struct TrieNode {
struct TrieNode *children[26];
bool is_end_of_word;
} TrieNode;

// Function to create a new Trie node

TrieNode *create_node() {
TrieNode *node = (TrieNode *)malloc(sizeof(TrieNode));
if (node) {
node->is_end_of_word = false;
for (int i = 0; i < 26; i++) {
node->children[i] = NULL;
}
}
return node;
}

// Define the Trie structure

221
typedef struct Trie {
TrieNode *root;
} Trie;

// Function to initialize the Trie

void init_trie(Trie *trie) {
trie->root = create_node();
}

// Function to insert a word into the Trie

void insert(Trie *trie, const char *word) {
TrieNode *current = trie->root;
while (*word) {
int index = *word - 'a'; // Map character to index (assuming lowercase letters only)
if (current->children[index] == NULL) {
current->children[index] = create_node();
}
current = current->children[index];
word++;
}
current->is_end_of_word = true;
}

// Function to search for a word in the Trie

bool search(Trie *trie, const char *word) {
TrieNode *current = trie->root;
while (*word) {
int index = *word - 'a';
if (current->children[index] == NULL) {
return false;
}
current = current->children[index];
word++;
}
return current->is_end_of_word;
}

// Example usage
int main() {
Trie trie;
init_trie(&trie);

// Insert words into the Trie

insert(&trie, "hello");
insert(&trie, "world");

222
 // Search for words in the Trie
printf("Search for 'hello': %s\n", search(&trie, "hello") ? "Found" : "Not Found");
printf("Search for 'world': %s\n", search(&trie, "world") ? "Found" : "Not Found");
printf("Search for 'trie': %s\n", search(&trie, "trie") ? "Found" : "Not Found");

return 0;
}
Explanation:
Structure Definition:

TrieNode: Represents each node in the Trie, containing an array of child pointers (children) and a
boolean flag (is_end_of_word).
Trie: Contains the root node of the Trie.
Node Initialization:

create_node: Allocates memory for a new node and initializes its children to NULL and
is_end_of_word to false.
Insert Function:

Iterates through each character of the word, maps it to an index ('a' to 'z' are mapped to 0 to 25), and
creates a new node if necessary.
Search Function:

Traverses the Trie following the character path of the word and checks if the word ends at a valid
node (is_end_of_word).
Example Usage:

Demonstrates inserting and searching for words in the Trie.

This implementation supports basic Trie operations for lowercase alphabetic characters.

8.4.2 Segment Trees and Fenwick Trees in Range Queries

Range queries often require specialized data structures to handle operations efficiently across
intervals or segments of data. Segment Trees and Fenwick Trees (Binary Indexed Trees) are
advanced data structures that support range queries and updates efficiently, especially for
applications where data changes dynamically.

Segment Trees

A Segment Tree is a binary tree used for storing intervals or segments. Each node represents a
segment or range, enabling efficient querying and updating of segment-based data.
223
Structure of Segment Tree:

Each leaf node represents a single element in the array.

Internal nodes represent the union of child segments.

The root node represents the entire range.

Operations in Segment Tree:

Range Query: Finds the sum, minimum, maximum, or other aggregate over a range in O(log
n) time.

Update: Updates an element and adjusts the relevant segments to reflect this change.

Use Cases of Segment Tree:

Range Sum/Minimum/Maximum Queries: Useful in scenarios where a data range needs

constant updates, such as stock price fluctuations.

Applications in Graphics: Managing range updates in game development, where pixels or

objects are updated dynamically.

Fenwick Trees (Binary Indexed Trees)

A Fenwick Tree (or Binary Indexed Tree) is another data structure used for efficiently
performing range queries and updates. It is simpler and more memory-efficient than Segment
Trees, making it ideal for certain applications.

Structure of Fenwick Tree:

Uses an array to represent cumulative frequencies.

Each element at index i in the array stores cumulative frequency up to index i.

Operations in Fenwick Tree:

Update: Increments or updates a value in O(log n) time.

Prefix Sum Query: Calculates the cumulative sum from the start to a specified position in O(log
n) time.

Use Cases of Fenwick Tree:

Range Sum Queries: Summing elements over a dynamic range, useful in financial applications.

224
 Inversion Count in Arrays: Counts the number of inversions in a list, relevant in
algorithms like sorting.
 Disjoint Set Union and Suffix Trees

Disjoint Set Union (Union-Find)

The Disjoint Set Union (DSU), also known as the Union-Find algorithm, is a data structure that
tracks a set of elements partitioned into disjoint subsets. It supports two main operations—find
and union—which allow elements to be grouped efficiently.
Structure of DSU:

Each element has a representative or "parent."

Union operations merge two subsets, while find retrieves the root of the set containing
the element.

Operations in DSU:

Find: Locates the root of the set containing an element.

Union: Combines two sets into one.

Suffix Trees

A Suffix Tree is a compressed trie that represents all the suffixes of a given string. It is
highly efficient for various string processing tasks, such as substring search and pattern
matching.

Structure of Suffix Tree:

Contains nodes with edges labeled with substrings.

Each suffix of the string is represented as a path from the root.

Operations in Suffix Tree:

Build: Constructs the suffix tree from a string.

Substring Search: Checks if a substring exists in the string in O(m) time.

Use Cases of Suffix Tree:

225
 Pattern Matching: Checks for the presence of a substring in constant time.

DNA Sequence Analysis: Helps in analyzing long DNA sequences by matching patterns
efficiently.

Practice Programs

1. Trie Implementation for Prefix Search

2. Create a Trie and implement a prefix search function to suggest words based on prefixes.

3. Build a Segment Tree for an array, enabling efficient sum queries over ranges.

4. Fenwick Tree for Frequency Count.

5. Suffix Tree for Substring Matching

226
MCQ:
Which data structure is used for fast prefix-based searches in text?

(A) Heap
(B) Trie
(C) Stack
(D) Hash Table
Answer: (B)

Which of the following is a property of a Fibonacci Heap?

(A) Constant time insertion

(B) Logarithmic time for decreasing a key
(C) Both A and B
(D) None of the above
Answer: (C)

Which data structure is commonly used in network routing tables?

(A) Hash Table

(B) Trie
(C) Queue
(D) Binary Tree
Answer: (B)

What is the primary feature of a Disjoint Set data structure?

(A) Finding connected components in graphs

(B) Efficient union and find operations
(C) Maintaining a sorted list of elements
(D) Both A and B
Answer: (D)

227
What is a hash collision?

(A) Two keys hashing to the same index

(B) A key not being found in the hash table
(C) A hash table exceeding its memory limit
(D) A hash function producing negative values
Answer: (A)

Which of the following is a collision resolution technique?

(A) Binary search

(B) Chaining
(C) Breadth-First Search
(D) Depth-First Search
Answer: (B)

228
 CHAPTER 9

Emerging Data Structures

Introduction

As technology evolves, new data structures are emerging to address the unique challenges
posed by distributed and parallel systems, blockchain, and decentralized networks. These
environments require data structures that can handle high data volumes, ensure data
consistency across distributed nodes, support concurrent processing, and maintain data
integrity. This section explores data structures in distributed and parallel systems, blockchain,
and decentralized networks.

9.1 Data Structures in Distributed and Parallel Systems

In distributed and parallel computing environments, data structures must support efficient data
processing, storage, and retrieval across multiple machines or processors. The primary
challenges in these systems are data synchronization, concurrency, and fault tolerance.
Specialized data structures are used to handle data processing in a distributed manner while
optimizing for speed, reliability, and consistency.

Key Data Structures for Distributed and Parallel Systems

 Distributed Hash Tables (DHTs)

Distributed Hash Tables are a data structure that distributes data across multiple nodes in a
network. Each node is responsible for a segment of the hash space, allowing for efficient data
retrieval without a central server. DHTs are resilient to node failures and enable horizontal
scaling by adding or removing nodes.

Use Cases: Peer-to-peer (P2P) networks, distributed storage, file-sharing systems.

Examples: The Chord and Kademlia DHTs, which are used in peer-to-peer networks for
efficient data lookup.

229
  Merkle Trees

A Merkle Tree is a binary tree where each node contains a cryptographic hash of its child nodes.
Merkle trees allow verification of data integrity without transferring entire datasets, making
them ideal for parallel and distributed systems.

Use Cases: Verifying data in distributed databases, securing data integrity in file systems, and
ensuring data authenticity in blockchain networks.

Examples: Git (version control), Bitcoin (blockchain), and IPFS (InterPlanetary File System).

 Vector Clocks

Vector Clocks are a mechanism for tracking causality in distributed systems. Each process
maintains a vector of counters to track the order of events, allowing the system to determine
which events happened before others.

Use Cases: Distributed databases, conflict resolution in replicated data stores, and event
ordering in decentralized systems.

Examples: Amazon DynamoDB uses vector clocks to manage eventual consistency in its
distributed key-value store.

 Conflict-Free Replicated Data Types (CRDTs)

CRDTs are data structures that allow multiple nodes to concurrently update shared data without
conflicts. They are designed to achieve strong eventual consistency, ensuring that all nodes
reach the same final state regardless of the order in which updates are applied.

Use Cases: Collaborative editing (e.g., Google Docs), distributed databases, and real-time
synchronization in decentralized applications.

Examples: CRDTs are used in systems like Riak and Redis for data synchronization and
conflict-free updates.

230
  Distributed Queues and Heaps

Distributed queues and heaps are used to manage task scheduling and priority in distributed
and parallel systems. Distributed queues help balance tasks across multiple nodes, while
distributed heaps maintain priority-based ordering across nodes.

Use Cases: Task scheduling in distributed systems, load balancing, and handling work queues.

Examples: Apache Kafka (distributed message queue), Apache ZooKeeper (coordination), and
Amazon SQS (simple queue service).

 Challenges and Benefits of Distributed Data Structures

Challenges:

Data Consistency: Ensuring all nodes have consistent data in real-time can be difficult.

Fault Tolerance: Systems must handle node failures without data loss.

Concurrency Control: Managing concurrent updates without conflicts or data corruption is

essential.

Benefits:

Scalability: These structures enable systems to scale horizontally.

Fault Tolerance: Data replication and redundancy improve resilience.

Efficient Data Processing: Data structures are optimized for quick retrieval and updates across
distributed nodes.

9.2 Data Structures for Blockchain and Decentralized Networks

Blockchain and decentralized networks are designed to operate without a central authority,
relying on peer-to-peer nodes for validation and data storage. Data structures in these systems
must ensure data security, integrity, and consistency, even in an open network where nodes
may join or leave unpredictably.

231
 Fig 37: Cryptographic Hash Function Example

Key Data Structures in Blockchain and Decentralized Networks

1. Merkle Trees

Fig 38: Merkle Tree Structure

232
Merkle Trees play a crucial role in blockchain by enabling efficient and secure verification of
data. They allow users to verify that a particular piece of data belongs to a dataset without
needing the entire dataset. Each block in a blockchain contains a Merkle root (the top hash of
the Merkle Tree) that represents all transactions in that block.

Use Cases: Verifying transactions in blockchain, file system integrity checks, and tamper-proof
data storage.

Examples: Bitcoin and Ethereum use Merkle Trees to ensure transaction integrity without
needing to store the entire blockchain locally.

2. Patricia Tries

A Patricia Trie is a compressed prefix tree used to store key-value pairs efficiently. Patricia
Tries are widely used in blockchains to store and verify account states and transactions.

Use Cases: Maintaining a record of accounts, storing state data in blockchains, and supporting
fast search and retrieval in decentralized systems.

Examples: Ethereum uses a Patricia Trie to store the state of the network, allowing quick access
to account balances and contract data.

 Directed Acyclic Graphs (DAGs)

Directed Acyclic Graphs (DAGs) represent a graph structure where data flows in a single
direction, and there are no cycles. DAGs allow nodes to reference multiple previous
transactions, enabling high transaction throughput without requiring sequential block
formation.

Use Cases: High-throughput transaction systems, data lineage tracking, and applications
requiring fast, concurrent processing.

Examples: IOTA and Nano use DAGs (referred to as the "Tangle" in IOTA) for high-speed,
feeless transactions.

233
 Fig 39: DAG Structure in Quantum Networks

 Blockchain Trees

Blockchain trees are tree structures adapted for blockchain networks, where each node or block
contains hashes pointing to previous blocks or other nodes in the tree. These structures allow
for efficient storage and quick access to historical data in blockchains.

Use Cases: Organizing and managing data in blockchains, optimizing data retrieval for
historical transactions, and facilitating branching in blockchain applications.

Examples: Sidechains in blockchain networks can be represented as blockchain trees,

providing scalability and flexibility in blockchain protocols.

 Skip Lists

Skip Lists are an advanced linked list structure that enables fast searches, insertions, and
deletions in a decentralized system. In a skip list, elements are arranged in multiple layers,
allowing nodes to "skip" over others for faster traversal.

Use Cases: Indexing in decentralized databases, storing data in key-value stores, and
facilitating fast lookups in peer-to-peer networks.

234
Examples: Skip lists can be used in blockchain for indexing large transaction histories, enabling
efficient data retrieval across the network.

 Challenges and Benefits of Blockchain Data Structures

Challenges:

Data Integrity: Ensuring data has not been altered, especially in an open network.

Efficiency: Many blockchains have high computational and storage requirements.

Scalability: As blockchains grow, data structures must handle increasing data loads.

Benefits:

Security and Trust: Cryptographic techniques ensure data is tamper-resistant.

Decentralization: Data structures in decentralized networks operate without central authority.

Auditability: Blockchain structures provide transparent records for verifying data history.

Practical Examples and Applications

1. DHTs in Peer-to-Peer (P2P) Networks

Example: BitTorrent, a P2P file-sharing protocol, uses DHTs to allow users to locate files
across different nodes without a central server.

Benefit: DHTs enable scalable data lookup and sharing, even as nodes join or leave the
network.

2. Merkle Trees in Blockchain Verification

Example: Bitcoin and Ethereum use Merkle Trees for fast and efficient transaction verification,
reducing the need for storing the entire blockchain.

Benefit: Merkle Trees ensure data integrity and enable lightweight verification, essential for
mobile and embedded devices.

3. Vector Clocks in Distributed Databases

Example: Amazon DynamoDB employs vector clocks to handle eventual consistency and
conflict resolution, ensuring data accuracy across distributed nodes.

235
Benefit: Vector clocks maintain the order of events, enabling consistent data synchronization.

4. CRDTs for Real-Time Collaboration Tools

Example: CRDTs are used in Google Docs to handle concurrent edits, allowing multiple users
to work on a document simultaneously without conflicts.

Benefit: CRDTs provide conflict-free merging of changes, essential for collaborative editing
applications.

5. Patricia Tries in Blockchain State Management

Example: Ethereum uses Patricia Tries to manage the state of accounts and contracts,
supporting efficient state verification.

Benefit: Patricia Tries enable efficient state storage and retrieval, optimizing blockchain
performance.

6. DAGs in High-Throughput Decentralized Networks

Example: IOTA’s Tangle (a DAG) enables high-speed, feeless transactions for IoT devices,
making it ideal for microtransactions.

Benefit: DAGs provide high throughput and scalability, supporting networks with minimal
transaction fees.

9.3 Quantum Data Structures and Potential Applications

As quantum computing continues to evolve, it introduces new paradigms for data processing
and storage that can outperform classical approaches. Quantum data structures and algorithms
leverage the principles of quantum mechanics to achieve significant improvements in
computational tasks. This section explores the basics of quantum computing, quantum data
structures, potential quantum algorithms, and their applications.

236
 Fig 40: Understanding Quantum Entanglement

9.3.1 Basics of Quantum Computing and Data Structures

Quantum Computing is a type of computation that harnesses the peculiar properties of quantum
mechanics, such as superposition and entanglement, to perform calculations. Unlike classical
bits, which represent either a 0 or a 1, quantum bits (qubits) can represent both states
simultaneously due to superposition. This property allows quantum computers to process a vast
amount of information concurrently.

9.3.2 Key Concepts in Quantum Computing

Qubits: The fundamental unit of quantum information. Qubits can exist in multiple states at
once, providing exponential computational power compared to classical bits.

237
Superposition: A principle that allows qubits to be in multiple states simultaneously, leading
to parallelism in computations.

Entanglement: A phenomenon where qubits become intertwined, allowing the state of one
qubit to depend on the state of another, regardless of the distance between them.

Quantum Gates: Operations that manipulate qubits, analogous to classical logic gates. They are
used to perform quantum operations and construct quantum circuits.

Quantum Measurement: The process of observing a quantum state, which collapses it into one
of the possible classical states.

Fig 41: Quantum Circuit Representation

238
 9.3.3 Quantum Data Structures

Quantum data structures differ from classical data structures in that they exploit quantum
mechanics to enhance performance for specific tasks. Some notable quantum data structures
include:

Quantum Stack: A quantum stack can utilize superposition to store multiple states at once.
When performing operations like push and pop, it can simultaneously operate on multiple
elements, potentially leading to faster access times.

Quantum Queue: Similar to classical queues, but with the ability to manage elements in a
superposed state, allowing for concurrent processing of enqueue and dequeue operations.

Quantum Hash Table: A quantum hash table can offer significant speedup in search operations
by leveraging quantum superposition to evaluate multiple hash values at once. Quantum
algorithms for searching could potentially outperform classical hash table implementations.

Quantum Trees: Data structures such as quantum binary trees can enable faster traversal and
searching through the use of quantum states, allowing for operations like insertion and deletion
to be performed more efficiently.

Quantum Graphs: Quantum graphs represent data structures in a way that can exploit quantum
parallelism for graph traversal algorithms, potentially speeding up search operations within
complex networks.

Fig 42 : Quantum vs. Classical Data Structures

239
 9.3.4 Potential Quantum Algorithms and Applications

Quantum computing has the potential to revolutionize various fields through the development
of specific algorithms that outperform their classical counterparts. Some notable quantum
algorithms include:

Shor's Algorithm: A quantum algorithm for integer factorization that can factor large numbers
exponentially faster than the best-known classical algorithms. It has significant implications
for cryptography, particularly for RSA encryption.

Grover's Algorithm: This algorithm provides a quadratic speedup for unstructured search
problems, allowing a quantum computer to search through an unsorted database of

N items in approximately

O(

) time, compared to

O(N) for classical search algorithms.

240
Quantum Fourier Transform: This algorithm underpins many quantum algorithms, including
Shor's, by enabling efficient computation of the discrete Fourier transform on quantum states.

Quantum Approximate Optimization Algorithm (QAOA): This algorithm aims to solve

combinatorial optimization problems using quantum circuits, providing near-optimal solutions
more efficiently than classical heuristics.

Variational Quantum Eigensolver (VQE): Used in quantum chemistry to find the ground state
of quantum systems, VQE applies quantum circuits to optimize parameters and solve for the
lowest energy state.

Table 3 : Comparison of Classical and Quantum Algorithms

241
 9.3.5 Applications of Quantum Algorithms

Cryptography: Quantum algorithms, especially Shor's, challenge classical encryption methods,

leading to the development of quantum-resistant cryptographic protocols.

Drug Discovery and Material Science: Quantum computing can simulate molecular structures
and chemical reactions more efficiently, significantly accelerating research and development
in pharmaceuticals and materials.

Optimization Problems: Quantum algorithms can address complex optimization challenges in

logistics, finance, and supply chain management, providing faster and more accurate solutions.

Machine Learning: Quantum computing has the potential to enhance machine learning
algorithms, allowing for faster processing of large datasets and improved model training
through quantum-enhanced feature space exploration.

9.4 Future Challenges and Innovations

Despite the promise of quantum data structures and algorithms, several challenges remain in
realizing the full potential of quantum computing.

Key Challenges

Quantum Decoherence: Qubits are highly sensitive to their environment, and decoherence can
lead to the loss of quantum information. Building error-resistant quantum systems is critical
for reliable computations.

 Scalability: Current quantum computers have limited qubit counts, and scaling up to
build practical quantum systems poses significant engineering challenges.
 Error Correction: Quantum error correction is essential to mitigate errors during
computation. Developing efficient error correction codes is crucial for practical
applications.
 Algorithm Development: While some quantum algorithms have shown promise, there
is a need for more algorithms that can outperform classical methods across various
applications.

242
  Integration with Classical Systems: Quantum computers must work alongside classical
computing systems, requiring the development of hybrid architectures and frameworks
that facilitate seamless integration.

Fig 43: Future Trends in Quantum Computing

Innovations on the Horizon

Quantum Supremacy: Demonstrating quantum supremacy—where a quantum computer

performs a task that is infeasible for classical computers—will validate the capabilities of
quantum computing.

Advancements in Quantum Hardware: Ongoing research in superconducting qubits, trapped

ions, and topological qubits aims to enhance qubit stability, coherence time, and scalability.

243
Quantum Networking: Developing quantum networks for secure communication and
distributed quantum computing could enable collaborative quantum processing across remote
locations.

New Quantum Algorithms: Continued exploration in the realm of quantum algorithms can lead
to breakthroughs in optimization, simulation, and machine learning, expanding the applications
of quantum computing.

Hybrid Quantum-Classical Algorithms: Research into algorithms that combine classical and
quantum processing can leverage the strengths of both paradigms, enabling practical solutions
to complex problems.

9.5 Practice Programs

1. Implement a Simple Quantum Stack

Objective: Create a quantum stack using qubits to demonstrate push and pop operations.

Description: Implement a basic simulation of a quantum stack where qubits represent stack
elements.

2. Build a Distributed Hash Table (DHT)

Objective: Create a simulation of a DHT to manage data across multiple nodes.

Description: Implement a basic DHT where nodes can store and retrieve data using a consistent
hashing approach.

3. Simulate a Quantum Algorithm for Grover's Search

Objective: Develop a simulation of Grover's algorithm to search through an unsorted dataset.

Description: Use a quantum computing framework to simulate the algorithm and demonstrate
its efficiency.

4. Create a Simple Merkle Tree Implementation

Objective: Implement a Merkle tree to secure data in a blockchain-like structure.

Description: Build a Merkle tree where each node hashes the values of its child nodes, allowing
verification of data integrity.

244
5. Design a Simple Blockchain with Suffix Trees for Data Retrieval

Objective: Develop a basic blockchain application using suffix trees to manage transaction
data.

Description: Implement a blockchain where each block contains transaction data indexed by a
suffix tree for efficient querying.

245
MCQ:

Which of the following is a feature of Distributed Hash Tables (DHTs)?

(A) Centralized data storage
(B) Efficient key-value pair lookups
(C) Lack of scalability
(D) High dependency on a single
node Answer: (B)

What is a primary use case for Merkle Trees?

(A) Sorting algorithms
(B) Data integrity verification in distributed systems
(C) File compression
(D) Dynamic memory
allocation Answer: (B)

Which of the following data structures is commonly used in blockchain technology?

(A) Binary Search Trees
(B) Linked Lists
(C) Merkle Trees
(D) AVL
Trees
Answer: (C)

What does CRDT stand for in the context of emerging data structures?
(A) Conflict-Free Replicated Data Types
(B) Consistent Randomized Data Trees
(C) Cryptographic Resilient Data Types
(D) Conflict-Resistant Data
Tables Answer: (A)

246
Which of the following best describes the primary benefit of CRDTs?
(A) Optimized binary search operations
(B) Conflict resolution in concurrent data edits
(C) Improved sorting efficiency
(D) Reduced memory
usage Answer: (B)

In Distributed Hash Tables (DHTs), what is used to map keys to nodes?

(A) Binary search algorithms
(B) Hashing functions
(C) Linked lists
(D) Depth-first
search Answer: (B)

What is the main advantage of using Merkle Trees in distributed systems?

(A) Efficient search algorithms
(B) Reduced storage requirements
(C) Verification of large data sets with minimal data transfer
(D) Simplified traversal of hierarchical
data Answer: (C)

What makes CRDTs suitable for collaborative applications?

(A) Their ability to merge updates without conflicts
(B) Their support for hierarchical data structures
(C) Their high computational efficiency
(D) Their
immutability
Answer: (A)

Which of the following is NOT a feature of Distributed Hash Tables (DHTs)?

(A) Scalability
(B) Decentralization
(C) Centralized data storage

247
(D) Fault
tolerance
Answer: (C)

What is the primary application of Merkle Trees in peer-to-peer networks?

(A) Data compression
(B) Efficient routing of data
(C) Validation of data consistency
(D) Indexing of
documents Answer: (C)

248
 CHAPTER 10

Case Study
Introduction: Game Created Using Data Structures in C Language

In this case study, we explore how different data structures are applied in creating a
simple game in C language. A game like a Tic-Tac-Toe can demonstrate the use of
arrays, stacks, queues, and linked lists effectively. We will focus on the Tic-Tac-Toe
game implementation, illustrating the usage of these data structures to handle the game
logic, manage player turns, and track the game state.

Game Overview:

Tic-Tac-Toe is a two-player game played on a 3x3 grid. Players take turns marking a
square with either an 'X' or an 'O'. The game ends when one player gets three of their
marks in a row, column, or diagonal.

Data Structures Used:

1. Arrays:

o Game Board: A 2D array is used to represent the 3x3 grid. The board stores
the current state of the game (either 'X', 'O', or a blank space).

char board[3][3]; // 3x3 grid for Tic-Tac-Toe

2. Stacks:

o Undo Moves: A stack is used to keep track of the moves made by the
players. If a player wants to undo their last move, the game can pop the last
move from the stack and revert the board to the previous state.

struct Move {

int row;

int col;
249
 char player;

};

struct Move stack[9]; // Maximum of 9 moves in a game

int top = -1;

// Push a move onto the stack

void push(struct Move move) {

stack[++top] = move;

// Pop the last move from the stack

struct Move pop() {

return stack[top--];

3. Queues:

o Turn Management: A queue can be used to manage the sequence of players’

turns. Players alternate, and the queue helps ensure that the turns are
followed correctly.

struct Player {

char symbol;

int turnOrder; // 0 for Player 1, 1 for Player 2

};

struct Player queue[2] = { {'X', 0}, {'O', 1} }; // Player 1: 'X', Player 2: 'O'
250
 int front = 0, rear = 1;

// Function to get the current player’s turn

struct Player dequeue() {

return queue[front++];

// Add a player to the back of the queue

void enqueue(struct Player player) {

queue[++rear] = player;

4. Linked Lists:
o Game History: A linked list can be used to maintain the history of moves
made in the game. Each node can store information about the move (e.g.,
row, column, and the player who made the move). This allows for reviewing
the sequence of moves after the game ends.
struct Node {
int row;
int col;
char player;
struct Node* next;
};

struct Node* head = NULL;

// Function to insert a move in the linked list

void insertMove(int row, int col, char player) {
struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->row = row;
newNode->col = col;
251
 newNode->player = player;
newNode->next = head;
head = newNode;
}

// Function to print the game history

void printHistory() {
struct Node* temp = head;
while (temp != NULL) {
printf("Player %c moved to (%d, %d)\n", temp->player, temp->row, temp->col);
temp = temp->next;
}
}
Game Logic and Flow:
1. Initializing the Game Board:
o The 3x3 board is initialized with empty spaces (e.g., '-'). Players take turns
marking 'X' and 'O' in the grid.
2. Checking for Win or Draw:
o After each move, the game checks if there is a winner or a draw. The win
condition is met when there are three consecutive marks (either 'X' or 'O') in
any row, column, or diagonal. A draw occurs if all spaces are filled and there
is no winner.
int checkWin() {
// Check rows, columns, and diagonals for a win
// If any row, column, or diagonal contains 3 of the same marks, return 1 (winner)
}

int checkDraw() {
// Check if all positions are filled and no one has won
// If all spaces are occupied and there's no winner, return 1 (draw)
}
3. Undo Move Functionality:
o Players can undo their last move using the stack. This allows players to
retract their moves and change the game state.
4. Game History:
o The linked list stores the history of moves, which can be displayed after the
252
 game ends for review.
Example Code Snippet:
#include <stdio.h>

char board[3][3];

void initializeBoard() {
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
board[i][j] = '-';
}
}
}

void printBoard() {
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
printf("%c ", board[i][j]);
}
printf("\n");
}
}

int checkWin() {
// Check rows and columns
for (int i = 0; i < 3; i++) {
if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][0] != '-')
{
return 1;
}
if (board[0][i] == board[1][i] && board[1][i] == board[2][i] && board[0][i] != '-')
{
return 1;
}
}
253
 // Check diagonals
if (board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[0][0] != '-')
{
return 1;
}
if (board[0][2] == board[1][1] && board[1][1] == board[2][0] && board[0][2] != '')
{
return 1;
}
return 0;
}
int main() {
initializeBoard();
printBoard();
// Implement player turns, move tracking, win checking, etc.
return 0;
}

Conclusion:
Using data structures like arrays, stacks, queues, and linked lists in C allows for efficient
management of game states, player turns, and move history. The game logic becomes
more modular and easier to manage, providing better functionality and flexibility (like
undoing moves or reviewing the game history). This case study demonstrates how data
structures play a crucial role in game development.

254
REFERENCES

1) Cormen, T. H., Leiserson, C. E., Rivest, R. L., & Stein, C. (2009). Introduction to
Algorithms (3rd ed.). The MIT Press.

2) Kleinberg, J., & Tardos, É. (2006). Algorithm Design. Addison-Wesley.

3) Sedgewick, R., & Wayne, K. (2011). Algorithms (4th ed.). Addison-Wesley.

4) Mitchell, R. (2015). Machine Learning. McGraw-Hill Education.

5) Bishop, C. M. (2006). Pattern Recognition and Machine Learning. Springer.

6) Koller, D., & Friedman, N. (2009). Probabilistic Graphical Models: Principles and
Techniques. MIT Press.

7) McKinsey & Company. (2021). The State of AI in 2021: Trends and Insights.
McKinsey & Company.

8) Khatchadourian, A. (2020). Practical Data Science with Python: A Hands-On Guide to

Data Science. Packt Publishing.

9) Gibbons, P. B., & Raghavan, P. (2005). Algorithmic Methods in Quantitative Finance.

Princeton University Press.

10) Duflo, E. (2017). Poor Economics: A Radical Rethinking of the Way to Fight Global
Poverty. PublicAffairs.

11) Shor, P. W. (1994). Algorithms for quantum computation: Discrete logarithms and
factoring. Proceedings of the 35th Annual ACM Symposium on Theory of Computing.

12) Grover, L. K. (1996). A fast quantum mechanical algorithm for database search.
Proceedings of the 28th Annual ACM Symposium on Theory of Computing.

255
13) Farhi, E., & Gutmann, S. (2018). An analog quantum adiabatic algorithm for the graph
partitioning problem. Proceedings of the National Academy of Sciences, 115(22),
11239-11244.

14) Babbush, R., et al. (2018). Constructing Quantum Circuits for Mixed-Integer
Programming. Nature Communications, 9(1), 22.

15) Quantum Computing Report. (n.d.). Quantum Computing Overview. Retrieved from
Quantum Computing Report

16) Qiskit. (n.d.). Qiskit Documentation. Retrieved from Qiskit

17) IBM. (2019). Quantum Computing: From Theory to Reality. Retrieved from IBM
Research

18) National Institute of Standards and Technology (NIST). (2019). NIST Special
Publication 800-186: A Taxonomy and Terminology of Quantum Computing and
Quantum Information Technology. Retrieved from NIST

19) Google AI. (2020). BERT: Pre-training of Deep Bidirectional Transformers for
Language Understanding. Retrieved from Google AI Blog

20) McKinsey Global Institute. (2021). The Future of Work After COVID-19. Retrieved
from McKinsey Global Institute

21) IBM Research. (2021). Quantum Computing: From Theory to Reality. Retrieved from
IBM Research

22) OpenAI. (2022). AI and the Future of Work. Retrieved from OpenAI Blog

23) World Economic Forum. (2021). The Future of Jobs Report 2021. Retrieved from
World Economic Forum

256
24) Proceedings of the International Conference on Quantum Computing and Engineering
(QCE). (n.d.). Retrieved from IEEE Xplore

25) Proceedings of the ACM Symposium on Cloud Computing (SoCC). (n.d.). Retrieved
from ACM Digital Library

26) Nielsen, M. A., & Chuang, I. L. (2010). Quantum Computation and Quantum
Information (10th Anniversary ed.). Cambridge University Press.

a. M. & L. M. (2020). Quantum Machine Learning. Nature Reviews Physics,

2(10), 626-638.

27) Dede, A., & Balog, A. (2020). A Practical Introduction to Quantum Computing.
Springer.

28) Analytics Vidhya. (2021). Understanding the Basics of Quantum Computing. Retrieved
from Analytics Vidhya

29) Towards Data Science. (2021). A Comprehensive Guide to Quantum Computing and
Machine Learning. Retrieved from Towards Data Science

30) Koller, D., & Friedman, N. (2009). Probabilistic Graphical Models: Principles and
Techniques. MIT Press.

31) Lutz, M. (2013). Learning Python (5th ed.). O'Reilly Media.

32) Witten, I. H., Frank, E., & Hall, M. A. (2011). Data Mining: Practical Machine Learning
Tools and Techniques (3rd ed.). Morgan Kaufmann.

33) Charniak, E. (1993). Statistical Language Learning. MIT Press.

34) Goodfellow, I., Bengio, Y., & Courville, A. (2016). Deep Learning. MIT Press.

257
35) Arute, F., et al. (2019). Quantum Supremacy Using a Programmable Superconducting
Processor. Nature, 574(7779), 505-510.

36) Harrow, A. W., Hassidim, A., & Lloyd, S. (2009). Quantum Algorithms for Fixed Qubit
Architectures. Physical Review Letters, 103(15), 150502.

37) Wang, D., et al. (2019). Quantum Algorithms for Fixed Qubit Architectures. Physical
Review A, 100(4), 042328.

a. R. & T. W. (2018). A Survey of Quantum Machine Learning. ACM Computing

Surveys, 54(4), 1-35.

38) The Quantum Computing Stack Exchange. (n.d.). Quantum Computing FAQs.
Retrieved from Quantum Computing Stack Exchange

39) Quantum Computing Report. (n.d.). Quantum Computing Overview. Retrieved from
Quantum Computing Report

40) IBM Quantum. (n.d.). Quantum Computing Basics. Retrieved from IBM Quantum

41) Microsoft Azure. (n.d.). Scaling Data Science and Machine Learning. Retrieved from
Microsoft Azure Blog

42) ISO/IEC. (2021). ISO/IEC 2382-36:2021: Information technology – Vocabulary – Part

36: Quantum computing. International Organization for Standardization.

43) IEEE. (2018). IEEE Standard for Quantum Computing: Definition, Terminology, and
Recommended Practices. IEEE Std 7000-2018.

44) Google Cloud. (2021). Building Quantum-Ready Applications: A Guide to Quantum

Computing in the Cloud. Retrieved from Google Cloud

258