An Abstract Data Type (ADT) is a theoretical concept in computer science that defines a data type

based on its behavior and operations, independent of its implementation. It provides a logical
description of data and operations without specifying how they are implemented.

ADTs are essential for organizing and managing complex data in software systems. They encapsulate
data and operations, which promotes data abstraction and information hiding, crucial principles in
software engineering for managing complexity and improving maintainability.

Common examples of ADTs include stacks, queues, trees, graphs, and sets. By defining these
abstractly, programmers can focus on how to use them in their applications without worrying about
the underlying details of their implementation. This abstraction simplifies software development,
promotes code reuse, and enhances the overall quality and efficiency of software systems.

In object-oriented programming (OOP), inheritance is a fundamental concept that allows a new class (the
derived class) to inherit properties and behaviors from an existing class (the base class or superclass). The
derived class can then extend or modify these properties and behaviors, creating a hierarchy of classes with a
parent-child relationship.

When a class inherits from another, it automatically gains access to all the public and protected members
(attributes and methods) of the base class. This allows for code reuse, as the derived class doesn't need to
redefine these members. Instead, it can focus on adding new functionality or customizing existing behavior.

Inheritance promotes code organization, extensibility, and flexibility in software design. It enables the creation
of specialized classes that build upon the functionality of more general classes, facilitating modular and
maintainable code.

Derived classes can also override methods of the base class to provide their own implementations. This is
particularly useful for customizing behavior to suit specific requirements while still benefiting from the existing
structure and functionality of the base class.

Overall, inheritance is a powerful mechanism in OOP that supports the creation of hierarchical class structures,
code reuse, and the implementation of polymorphism, where objects of different classes can be treated
interchangeably through a common interface.

A stack is a fundamental data structure that follows the Last In, First Out (LIFO) principle, meaning that the
most recently added element is the first one to be removed. Think of it as a stack of plates, where you can only
add or remove plates from the top.

Operations on a Stack:

1. Push: This operation adds an element to the top of the stack.

Procedure:1 Check if the stack is full (optional, depending on implementation). 2 Increase the
stack pointer.3 Place the new element at the position indicated by the stack pointer.

2. Pop: This operation removes and returns the top element from the stack.

Procedure:1Check if the stack is empty.2 Retrieve the element at the position indicated by the
stack pointer. 3 Decrease the stack pointer.
Stack Overflow: This occurs when an attempt is made to push an element onto a stack that is already
full (in a fixed-size implementation) or when there is no available memory to allocate for a new
element (in a dynamic implementation).

Procedure: 1 In a fixed-size implementation, check if the stack is full before pushing a new element. If
it's full, handle the overflow condition appropriately (e.g., by resizing the stack or returning an error).2
In a dynamic implementation, handle memory allocation failures gracefully (e.g., by returning an error
or resizing the memory pool).

Stack Underflow: This occurs when an attempt is made to pop or peek an element from an empty
stack.

Procedure: 1 Before popping or peeking, check if the stack is empty. If it is, handle the underflow
condition appropriately (e.g., by returning an error or throwing an exception).

AVL TREES

An AVL tree is a self-balancing binary search tree that maintains a balanced structure to ensure
efficient searching, insertion, and deletion operations. It was named after its inventors, Adelson-Velsky
and Landis. Here are some key points about AVL trees:

1. Balanced Structure: An AVL tree is balanced in such a way that for any node in the tree, the
heights of its left and right subtrees differ by at most one. This property ensures that the tree
remains relatively balanced, preventing degeneration into a linked list-like structure,

2. Balance Factor: The balance factor of a node in an AVL tree is the difference between the
heights of its left and right subtrees. A balance factor of -1, 0, or 1 indicates that the subtree is
balanced. If the balance factor exceeds these bounds, the tree needs to be rebalanced to
maintain its AVL property.

3. Complexity: The height of an AVL tree with 𝑛n nodes is guaranteed to be 𝑂 (logn), making
searching, insertion, and deletion operations efficient in the average and worst cases.

4. Implementation: Implementing an AVL tree requires careful consideration of balancing

operations to ensure that the tree remains AVL-compliant after each modification. Recursive
algorithms are commonly used for insertion, deletion, and rebalancing.

5. Applications: AVL trees are used in scenarios where efficient searching and retrieval of data
are essential, such as databases, language compilers, and file systems. They are particularly
useful in applications that involve frequent insertions and deletions, as their self-balancing
property helps maintain performance.

NODE STRUCTURE IN B-TREE

In a B-tree, the node structure plays a pivotal role in organizing and managing the data efficiently. A
B-tree is a self-balancing tree data structure that maintains sorted data and is commonly used in
databases and file systems for efficient searching, insertion, and deletion operations. Here's a short
note on the node structure in a B-tree:
 1. Key-value pairs: Each node in a B-tree contains a set of key-value pairs. These key-value pairs
are used for searching and indexing data. The keys are typically sorted in ascending order
within each node.

2. Child pointers: In addition to key-value pairs, each node contains pointers to its child nodes.
The number of child pointers is always one more than the number of keys in the node. These
pointers facilitate navigation through the tree during search, insertion, and deletion
operations.

3. Degree or order: The maximum number of keys that a node can hold is determined by its
degree or order, denoted as 𝑡t. In a B-tree of order 𝑡t, each node can have at most 2𝑡−12t−1
keys and 2𝑡2t child pointers.

4. Internal node vs. Leaf node: In a B-tree, nodes can be categorized as internal nodes or leaf
nodes. Internal nodes contain only key-value pairs and child pointers, while leaf nodes
additionally store actual data or pointers to data records.

5. Balanced structure: One of the defining characteristics of a B-tree is its balanced structure.
All leaf nodes are at the same level, and the height of the tree is kept relatively low by
maintaining a balance between the number of keys in each node and the depth of the tree

To construct a binary search tree (BST) from the given data {50, 70, 60, 20, 90, 10, 40, 100}, follow
these steps:1 Start with an empty tree. 2. Insert each element from the given data set one by one into
the tree according to the rules of a binary search tree.

In a binary search tree:

For each node:1. All nodes in its left subtree have values less than its own value.2. All nodes in its right
subtree have values greater than its own value.

Let's construct the binary search tree:1 Insert 50 (the first element) as the root of the tree.2 Insert 70,
it's greater than 50, so it goes to the right of 50. 3 Insert 60, it's less than 70 and greater than 50, so it
goes to the left of 70. 4 Insert 20, it's less than 50, so it goes to the left of 50. 4 Insert 90, it's greater
than 70, so it goes to the right of 70. 5 Insert 10, it's less than 50, so it goes to the left of 50, then less
than 20, so it goes to the left of 20. 6 Insert 40, it's greater than 20, so it goes to the right of 20.
7Insert 100, it's greater than 50, so it goes to the right of 50, then greater than 70, so it goes to the
right of 70, then greater than 90, so it goes to the right of 90.

IN order 10,20,40,50,60,70,90,100 PRE ORDER 50,20,10,40,70,60,90,100 POST ORDER

10,40,20,60,100,90,70,50
UNIT 4

Graph search methods are algorithms used to traverse or search through a graph data structure. Here
are the most commonly used graph search methods:

1. Depth-First Search (DFS)

Depth-First Search (DFS) explores as far as possible along each branch before backtracking. It uses a
stack data structure, either implicitly through recursion or explicitly.

Example: Consider the following graph:

Starting from node A, DFS would explore the nodes in this order: A, B, D, E, C, F.

Algorithm:1Start at the root node (A). 2 Push the root node onto a stack. 3 While the stack is not
empty: Pop the top node from the stack. If the node has unvisited neighbors, push them onto the
stack.

2. Breadth-First Search (BFS)

Breadth-First Search (BFS) explores all the neighbors of a node before moving on to their neighbors.
It uses a queue data structure.

Example: Using the same graph:

Starting from node A, BFS would explore the nodes in this order: A, B, C, D, E, F.

Algorithm:1Start at the root node (A) .2 Enqueue the root node. While the queue is not empty:
Dequeue the front node. Enqueue all unvisited neighbors of the dequeued node.

Graph Iterators

Graph Iterators: Graph iterators are mechanisms or constructs used to traverse through the elements
(nodes and edges) of a graph systematically. They provide a way to access each element of the graph
without exposing the underlying representation of the graph.

Types of Graph Iterators:

1. Vertex Iterator:

• Used to iterate over all the vertices in a graph.

• Example: In a simple graph representation, you might have for each vertex in graph.

2. Edge Iterator:

• Used to iterate over all the edges in a graph.

 • Example: for each edge in graph.

3. Neighbor Iterator:

• Used to iterate over all the adjacent vertices (neighbors) of a given vertex.
• Example: for each neighbor of vertex v.

Benefits:

• Encapsulation: Hides the internal structure of the graph.

• Abstraction: Provides a simple interface for graph traversal.
• Flexibility: Allows different types of graph traversals (e.g., DFS, BFS) using the same
underlying iterator concept.

Skip List: A skip list is a data structure that allows fast search, insertion, and deletion
operations within an ordered sequence of elements. It is a layered linked list with
multiple levels, where each level is a subset of the level below.

Structure:

• Each element in a skip list has a tower of nodes.

• The bottom level is an ordinary sorted linked list.
• Higher levels provide "shortcuts" that allow the algorithm to skip over many
elements, hence the name "skip list."

Operations:

• Search: Start at the top level and move forward until the target is found or the
end of the list is reached, dropping down a level when necessary.
• Insertion: Insert the element into each level with a certain probability.
• Deletion: Remove the element from each level.

Hashing

Hashing: Hashing is a technique used to map data of arbitrary size to fixed-size

values (hash codes) using a hash function. This is commonly used in hash tables to
achieve efficient data retrieval.

Components:

1. Hash Function: A function that converts input data (keys) into a hash code.
 2. Hash Table: A data structure that stores key-value pairs, where the position of
the key is determined by the hash code.

Operations:

• Insertion: Compute the hash code of the key and place it in the
corresponding index of the hash table.
• Search: Compute the hash code of the key and look up the corresponding
index in the hash table.
• Deletion: Compute the hash code of the key and remove the entry from the
corresponding index