1. (a) What is the difference between constant and variable?

ans- A constant is a value that does not change. It is typically represented by a

number or symbol. example, the number 7 is a constant.

A variable is a symbol that represents a value that can change. The value of a
variable can be changed by assigning it a new value or by using it in an
expression. example, the variable x can represent any number.

(b) When singly linked list can be represented as circular linked list?

Ans-A singly linked list can be represented as a circular linked list if the last node
of the singly linked list points to the first node of the singly linked list. This
creates a circular loop where the list wraps around from the end back to the
beginning.

Here's an example of how to convert a singly linked list into a circular linked list:

```python
class Node:
def __init__(self, data):
self.data = data
self.next = None

class SinglyLinkedList:
def __init__(self):
self.head = None

def insert_at_head(self, data):

new_node = Node(data)
new_node.next = self.head
self.head = new_node

def convert_to_circular(self):
current_node = self.head
while current_node.next:
current_node = current_node.next

current_node.next = self.head
```
(c) What are the operations performed in list?

ans- Common operations performed on lists include:

* Access: Retrieving individual elements from the list using their index or position.

*Traversal: Going through each element in the list systematically.

*Insertion: Adding new elements to the list at specific positions.

*Deletion: Removing elements from the list.

*Search: Finding specific elements within the list.

*Sorting: Arranging the elements in the list in a specific order, such as ascending or
descending.

* Reversing: Changing the order of the elements in the list to the opposite.

*Merging: Combining two or more lists into a single list.

* Splitting: Dividing a list into two or more smaller lists.

(d) Define ADT (Abstract Data Type)

Ans-An ADT (Abstract Data Type) is a mathematical model for a data structure
that specifies the following:

* The data values that the ADT can store.

* The operations that can be performed on those values.

* The behavior of those operations.

ADTs do not specify how the data structures are implemented in code. This
allows different implementations of the same ADT to be used in different
programming languages and on different computers.

Some examples of ADTs include:

*Lists: A list is a collection of elements that can be accessed by their index.

*Stacks: A stack is a LIFO (Last In, First Out) data structure. This means that the
last element added to the stack is the first one to be removed.

*Queues: A queue is a FIFO (First In, First Out) data structure. This means that
the first element added to the queue is the first one to be removed.

*Trees: A tree is a hierarchical data structure that consists of nodes connected by

edges.

* Graphs: A graph is a collection of nodes connected by edges. Unlike trees,

graphs can have loops and cycles.
(e) What is a circular linked list?

Ans- A circular linked list is a type of linked list where the last node points to the
first node, forming a closed loop. This is different from a regular linked list, where
the last node points to `NULL`. Circular linked lists are useful for certain
applications, such as implementing queues or keeping track of a position in a
circular buffer.
(f) Why do we need data structures?

Ans-We need data structures to organize and manage data efficiently. They
provide a way to store, access, and modify data in a way that is organized and
efficient. This is important because data is the foundation of almost all software
programs. Without data structures, it would be very difficult to write efficient and
scalable programs.

Here are some specific reasons why we need data structures:

* To store data in a way that is easy to access: Data structures allow us to store
data in a way that makes it easy to find and retrieve. This is important because
we often need to access data quickly in order to perform computations or make
decisions.

* To modify data efficiently:Data structures allow us to modify data efficiently.

This is important because we often need to update data as our programs run.

* To save space: Data structures can help us save space by storing data
efficiently. This is important because computers have limited memory, and we
need to use it as efficiently as possible.

*To make programs more scalable: Data structures can help us make our
programs more scalable. This means that our programs can handle more data
without becoming slow or inefficient.

In short, data structures are essential for writing efficient and scalable software
programs. They provide a way to organize and manage data in a way that is
easy to access, modify, and save space.
(g) Differentiate linear and non-linear data structure

Ans-Linear and non-linear data structures are two fundamental classifications of

data structures based on the organization and relationship between their
elements.

Linear data structures organize elements in a sequential manner, resembling a

straight line. Each element has a distinct predecessor and successor, forming a
linear relationship. Examples, Arrays, Linked lists, Stacks, Queues.

Non-linear data structures, on the other hand, arrange elements in a hierarchical

or non-sequential manner. Elements can have multiple connections or
relationships, forming a more complex network. Example, Trees, Graphs.
(h) Define an array. Mention the different kinds of arrays with which you can manipulate and represent data.,

Ans-An array is a collection of elements of the same data type stored at

contiguous memory locations. Elements in an array can be accessed using their
index or position. Arrays are versatile data structures that can be used to
represent a wide variety of data, including lists, tables, and matrices.
**Types of Arrays:**

1. One-dimensional Arrays: Also known as single-dimensional arrays, these

arrays represent a linear collection of elements.

2. Multidimensional Arrays: These arrays extend the concept of one-dimensional

arrays to multiple dimensions, representing data in a more complex structure.
Examples include two-dimensional arrays (matrices) and three-dimensional
arrays.

3. Jagged Arrays: Also known as ragged arrays, these arrays are special cases of
multidimensional arrays where rows can have different lengths. This allows for
irregular data storage.

4. Parallel Arrays: These arrays involve storing multiple related arrays that share
the same index but hold different data values. This is useful for representing
related data sets.

5. Associative Arrays:Also known as dictionaries or maps, these arrays store

elements in key-value pairs, allowing for retrieval based on keys rather than
indexes.
(i) What is the Purpose of the Floyd algorithm?,

Ans-The Floyd-Warshall algorithm is a versatile algorithm that serves multiple

purposes in graph theory and network analysis. It is primarily used to:

1. Find the shortest path between all pairs of nodes in a weighted graph:The
algorithm efficiently determines the shortest route, considering edge weights, for
every possible connection between nodes in the graph.

2. Detect negative-weight cycles:Negative-weight cycles can disrupt the

algorithm's ability to find accurate shortest paths. The Floyd-Warshall algorithm
can identify the presence of these cycles, indicating potential errors or
inconsistencies in the graph's structure.

3. Compute the transitive closure of a directed graph:The transitive closure

represents the minimum number of edges required to reach any node from any
other node. The Floyd-Warshall algorithm can determine the transitive closure,
providing insights into the reachability of nodes within the graph.

4. Determine all-pairs shortest paths in dynamic graphs: In scenarios where

graph edges change over time, the Floyd-Warshall algorithm can dynamically
update the shortest paths, adapting to the evolving graph structure.

5. Solve optimization problems in network routing and transportation:The

shortest path information obtained from the Floyd-Warshall algorithm can be
applied to optimize routing decisions in communication networks and
transportation systems.
 (j) What is a circular queue? How do you check the queue full condition?,

Ans-
A circular queue is a type of queue data structure in which the last element
points back to the first element, forming a circular structure. This allows for
efficient insertion and deletion of elements, as the queue doesn't need to be
shifted when an element is removed.
(k) Define queue and give its applications.,

Ans- A queue is a linear data structure that follows the FIFO (First In, First Out)
principle. It is a collection of elements where elements are added to the rear end
and removed from the front end. Queues are like lines at a store or bank, where
the first person in line is the first one to be served.

applications of queues:

| Application | Description |

| Scheduling tasks in an operating system | Queues are used to schedule tasks in an

operating system. For example, the CPU scheduler uses a queue to keep track of
processes that are waiting to be executed. |
Implementing breadth-first search in graphs | Breadth-first search is a graph
search algorithm that uses a queue to explore the graph. The queue is initialized
with the starting node, and then the algorithm iteratively removes a node from
the queue, explores its neighbors, and adds them to the queue.
Handling asynchronous data transfer in networking | Queues are used to handle
asynchronous data transfer in networking. For example, the TCP protocol uses a
queue to buffer data that is being transmitted or received. |
Managing print jobs in a printer queue | Queues are used to manage print jobs in
a printer queue. When a user submits a print job, it is added to the queue, and
then the printer processs the jobs in the queue one at a time.
Simulating customer waiting lines in a store | Queues are used to simulate
customer waiting lines in a store. When a customer arrives at the store, they join
the queue, and then they are served by a salesperson when it is their turn.

2. (a) What are the advantages of linked lists over arrays.

Ans- Linked lists and arrays are both fundamental data structures used to store
and manage collections of data. While both structures have their strengths and
weaknesses, linked lists offer several advantages over arrays in certain
situations:

1. Dynamic Size:Linked lists can grow or shrink without the need to preallocate
memory. This flexibility is particularly useful when dealing with data sets of
unknown or varying size.

2. Efficient Insertion and Deletion: Inserting or deleting elements from a linked list
is relatively simple and efficient, as it only requires modifying the links between
nodes. In contrast, arrays require shifting elements to maintain contiguous
memory allocation, which can be time-consuming for large arrays.

3.*Memory Efficiency:Linked lists can be more memory-efficient than arrays,

especially when dealing with sparse data sets. In linked lists, only the data itself
is stored, while arrays allocate memory for all elements, even if they are not used.

4. Easy Implementation of Abstract Data Types:Linked lists are well-suited for

implementing abstract data types (ADTs) that involve frequent insertions and
deletions, such as stacks and queues.

5. Efficient Sorting in Some Cases: For certain types of data, linked lists can be
sorted more efficiently than arrays using algorithms like insertion sort or merge
sort.

However, linked lists also have some drawbacks compared to arrays:

1. Random Access: Random access, or accessing elements by their index, is less

efficient in linked lists than in arrays. It requires traversing the list from the
beginning until the desired element is found.

2. Memory Overhead: Each node in a linked list contains both the data value and
a pointer to the next node. This overhead can consume more memory compared
to arrays, where data elements are stored contiguously.

3. Cache Inefficiency: Linked lists tend to be less cache-friendly than arrays due
to their scattered memory layout. This can lead to performance penalties on
cache-aware architectures.

(b) List various operations possible on stack. Explain with example.

Ans-Stacks are a type of data structure that follows the LIFO (Last In, First Out)
principle. This means that the last element added to the stack is the first one to
be removed. Stacks are often used to implement undo/redo functionality, as well
as for parsing expressions and evaluating postfix expressions.

Here are some of the common operations that can be performed on stacks:

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

Example: Push(5) onto an empty stack would result in a stack with the element 5.
 ```
2. Pop: This operation removes the top element from the stack and returns it.
Example: Pop from a stack with the elements 5, 3, and 1 would return the
element 5 and leave the stack with the elements 3 and 1.
3. Peek:*This operation returns the top element of the stack without removing it.
Exmple: Peek on a stack with the elements 5, 3, and 1 would return the element 5
without modifying the stack.
4. IsEmpty:This operation checks whether the stack is empty.
Example: IsEmpty on an empty stack would return true, while IsEmpty on a stack
with elements would return false.
5. **Size:** This operation returns the number of elements in the stack.
Example: Size on a stack with the elements 5, 3, and 1 would return 3.
.

3. (a) In what was doubly linked list is better than single linked list. Give example.

Ans- Both singly linked lists and doubly linked lists are fundamental data
structures commonly used in programming. While both have their applications,
doubly linked lists offer certain advantages over singly linked lists in specific
situations:

1. Efficient Insertion and Deletion:Doubly linked lists allow for efficient insertion
and deletion of elements from any position in the list. This is because each node
maintains pointers to both the previous and next nodes, enabling direct access to
the surrounding elements.

2. Easy Traversal in Both Directions:Doubly linked lists can be traversed in both

directions, from the beginning to the end and vice versa. This ability to move
backward makes certain operations, such as reversing the list or searching for
specific elements, more efficient.

3. Avoiding Null Pointer Dereference:Unlike singly linked lists, doubly linked lists
do not encounter null pointer dereference issues when handling the first or last
node. This ensures smoother operation and reduces the risk of errors.

4. Implementation of Specific Data Structures: Doubly linked lists are essential

for implementing certain data structures that require bidirectional access, such
as doubly ended queues and LRU (Least Recently Used) caches.

Here's an example illustrating the advantage of doubly linked lists in deletion:

Consider a scenario where you need to delete the node 'C' from a linked list:

Singly Linked List:

```
A -> B -> C -> D -> E
```

Deleting 'C' requires traversing the list from the beginning, finding 'B', and
modifying its 'next' pointer to point to 'D'. This involves linear traversal.

Doubly Linked List:

```
A <=> B <=> C <=> D <=> E
```

Deleting 'C' involves accessing 'B' directly through its 'previous' pointer and
modifying its 'next' pointer to point to 'D'. This allows for direct deletion without
linear traversal.

While doubly linked lists offer these advantages, they also have a drawback:
memory overhead. Each node in a doubly linked list stores two pointers,
increasing memory consumption compared to singly linked lists, where nodes
only store one pointer.

(b) Define queue? Explain working of circular queue in short.

Ans-here is a definition of a queue and an explanation of how a circular queue

works:

**Queue**

A queue is a linear data structure that follows the FIFO (First In, First Out)
principle. This means that the first element added to the queue is the first one to
be removed. Queues are often used to implement undo/redo functionality, as
well as for parsing expressions and evaluating postfix expressions.

**Circular Queue**

A circular queue is a type of queue where the last element points to the first
element, forming a circular structure. This allows for efficient insertion and
deletion of elements, as the queue doesn't need to be shifted when an element is
removed.
 Here's an example of how a circular queue works:

1. Initially, the front and rear pointers point to the same location, indicating an
empty queue.
2. To insert an element, the rear pointer is moved to the next available location,
and the new element is stored at that location.
3. To remove an element, the front pointer is moved to the next location, and the
element stored at that location is removed.
4. This process continues until the queue is full or empty.
Circular queues are commonly used in operating systems to manage tasks and
in networking to buffer data transmission.

4. (a) Explain the implementation methods of Priority Queues? ,

Ans-Priority queues are a type of abstract data structure (ADT) that store elements
and associate each element with a priority. When retrieving elements from a priority
queue, the element with the highest priority is always returned first. Priority queues
are commonly used to implement tasks like scheduling jobs, handling network
traffic, and searching for the best path in a graph.

There are several different ways to implement priority queues, each with its own
strengths and weaknesses. Some of the most common implementations include:

* Binary heaps: Binary heaps are a type of tree-based data structure that efficiently
maintains the heap property, ensuring that the parent node of each node has a
higher or equal priority than its children. Binary heaps are a versatile and widely used
implementation for priority queues.

*Unordered arrays: Unordered arrays are a simple and straightforward

implementation for priority queues. However, they can be inefficient for operations
like insertion and deletion, as they may require shifting elements to maintain the
priority order.

*Self-adjusting arrays: Self-adjusting arrays are a variant of unordered arrays that

use techniques like bubbling or sifting to maintain the priority order without shifting
all elements. They offer a compromise between simplicity and efficiency.
*Linked lists: Linked lists are another simple implementation for priority queues.
However, they can be inefficient for random access operations, as they require
traversing the list to find the element with the highest priority.

The choice of implementation for a priority queue depends on the specific

requirements of the application. For instance, if frequent insertions and deletions are
expected, a binary heap or a self-adjusting array might be a good choice.

(b) Write insertion and deletion algorithms of priority

heap? ,
Ans-here are the insertion and deletion algorithms of a priority queue using a binary
heap implementation:

**Insertion Algorithm:**

1. Insert the new element into the last position of the heap.

2. Compare the new element's priority to its parent's priority.

3. If the new element's priority is higher than its parent's priority, swap the positions
of the two elements.

4. Repeat steps 2 and 3 until the new element reaches its correct position in the heap.

**Deletion Algorithm:**

1. Remove the element with the highest priority from the root of the heap.

2. Move the last element of the heap to the root position.

3. Compare the new root element's priority to its children's priorities.

4. If the new root element's priority is lower than the priority of either of its children,
swap the positions of the root element and the child with the highest priority.

5. Repeat steps 3 and 4 until the new root element reaches its correct position in the
heap.

5. (a) Explain bubble sort with example.

Ans- Sure. Here is an example of how bubble sort works:

```python
def bubble_sort(arr):
n = len(arr)
for i in range(n):
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] = arr[j+1], arr[j]

arr = [64, 34, 25, 12, 22, 11, 90]

bubble_sort(arr)
print(arr)
```

This code outputs the following:

```
[11, 12, 22, 25, 34, 64, 90]
```

As you can see, the bubble sort algorithm was able to sort the list of numbers from
smallest to largest.

how the bubble sort algorithm works:

1. Compare the first two elements in the list. If the first element is larger than the
second element, swap the two elements.
2. Move on to the next two elements in the list and repeat step 1.
3. Continue comparing and swapping elements until you reach the end of the list.
4. Repeat steps 1-3 until the list is sorted.

The bubble sort algorithm is a simple sorting algorithm that is easy to understand
and implement. However, it is not the most efficient sorting algorithm. There are
other sorting algorithms, such as quicksort and merge sort, that are more efficient
than bubble sort.

(b) What is Row major and column major implementation of array.

Ans-In row-major order, the elements are stored in memory such that all the elements
in a row are contiguous before moving to the next row. In column-major order, the
elements are stored in memory such that all the elements in a column are
contiguous before moving to the next column.

For example, consider the following 3x3 array:

```
[[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]
```

In row-major order, the elements would be stored in memory as follows:

```
1, 2, 3, 4, 5, 6, 7, 8, 9
```

In column-major order, the elements would be stored in memory as follows:

```
1, 4, 7, 2, 5, 8, 3, 6, 9
```

The choice of whether to use row-major or column-major order is typically

determined by the compiler or the programming language. For example, C and C++
use column-major order, while Fortran and Python use row-major order.

The order in which elements are stored in memory can have a significant impact on
the performance of certain algorithms. For example, algorithms that access
elements by row are typically more efficient when the array is stored in row-major
order, while algorithms that access elements by column are typically more efficient
when the array is stored in column-major order.

6. What is Quick sort? Explain its working by taking suitable example.

Ans- Sure, here is an explanation of quicksort with an example:

Quicksort is a divide-and-conquer sorting algorithm that efficiently sorts an array of

elements. It works by recursively partitioning the array into two subarrays, one
containing elements smaller than a pivot element and the other containing elements
larger than the pivot element. This process is repeated until the array is fully sorted.

**Example:**

Consider the following unsorted array:

```
[5, 2, 4, 1, 3]
```

In quicksort, we first select a pivot element. In this case, we will choose the middle
element, which is 4. We then partition the array around the pivot element, placing all
elements smaller than 4 to its left and all elements larger than 4 to its right. This
gives us the following:

```
[1, 2, 3, |4|, 5]
```

The pivot element (4) is now in its correct position in the sorted array. We can now
recursively apply the quicksort algorithm to the two subarrays on either side of the
pivot element. The left subarray is [1, 2, 3], and the right subarray is [5]. Recursively
partitioning the left subarray gives us:

```
[1, |2|, 3]
```

The pivot element (2) is now in its correct position in the sorted subarray. We can
now recursively apply the quicksort algorithm to the right subarray, which is [5].
Since the right subarray only has one element, it is already sorted.

This leaves us with the following sorted array:

```
[1, 2, 3, |4|, 5]
```

The algorithm is complete, and the entire array is now sorted.

Quicksort is a versatile and efficient sorting algorithm that is often used in real-world
applications. It has an average-case time complexity of O(n log n), which makes it
faster than many other sorting algorithms for large arrays.

7. Explain binary search technique along with its algorithm.

Ans-here is an explanation of the binary search technique:

Binary search is a search algorithm that works by repeatedly dividing the search
space in half. It is one of the most efficient search algorithms for finding an element
in a sorted array.

The algorithm works as follows:

1. Compare the middle element of the array to the target element.

2. If the middle element is the target element, return the index of the middle element.
3. If the middle element is less than the target element, search the upper half of the
array.
4. If the middle element is greater than the target element, search the lower half of
the array.
5. Repeat steps 1-4 until the target element is found or the search space is empty.

Here is an example of how to implement binary search in Python:

```python
def binary_search(array, target):
low = 0
high = len(array) - 1

while low <= high:

mid = (low + high) // 2

if array[mid] == target:
return mid
elif array[mid] < target:
low = mid + 1
else:
high = mid - 1

return -1

array = [2, 5, 8, 12, 33, 42, 56, 78, 91]

target = 42

index = binary_search(array, target)

if index == -1:
print("Target not found")
else:
print("Target found at index", index)
```

In this example, the target element is 42. The binary search algorithm will find the
target element at index 5.

Binary search is a powerful tool for searching for elements in sorted arrays. It is one
of the most efficient search algorithms available, and it is easy to implement.

8. Explain how you will insert an element into binary search tree.
Ans-Sure, here are the steps on how to insert an element into a binary search tree:

1. **Start at the root of the tree.**

2. **Compare the element to the value of the root node.**

3. If the element is less than the value of the root node, move to the left child of the
root node.

4. If the element is greater than the value of the root node, move to the right child of
the root node.

5. If the current node is a leaf node (has no children), insert the element as the child
of the current node.

6. If the current node is not a leaf node, repeat steps 2-5 for the child node you
moved to.

Here is an example of how to insert the element 5 into the following binary search
tree:

```
10
/ \
5 15
```

1. Start at the root of the tree (10).

2. The element 5 is less than the value of the root node (10), so move to the left child
of the root node (5).

3. The current node is a leaf node, so insert the element 5 as the child of the current
node.

The resulting binary search tree is:

```
10
/ \
5 15
```

9. Write and explain polyphase sorting with suitable example.,

Ans-Polyphase sorting is a variation of merge sort that is specifically designed for
external sorting, which is the process of sorting data that is too large to fit into main
memory. Polyphase sorting is more efficient than traditional merge sort for external
sorting because it reduces the number of disk I/O operations required.

Here is an example of how polyphase sorting works:

1. **Divide the data into multiple runs.** Each run should be small enough to fit into
main memory.

2. **Sort each run using an internal sorting algorithm.** For example, you could use
quicksort or merge sort.

3. **Merge the runs in a polyphase fashion.** This means that you will merge the
runs in small groups, and then you will merge the resulting groups, and so on, until
you have one sorted run.

The polyphase merge step is what makes polyphase sorting more efficient than
traditional merge sort. In traditional merge sort, you would merge all of the runs at
once, which would require a lot of disk I/O operations. However, in polyphase
sorting, you only merge a small number of runs at a time, which reduces the amount
of disk I/O required.

Here is an example of how to merge runs in a polyphase fashion:

1. **Divide the runs into groups of three.**

2. **Merge each group of three runs into a single run.**

3. **Divide the resulting runs into groups of three.**

4. **Merge each group of three runs into a single run.**

5. **Repeat steps 3 and 4 until you have one sorted run.**

In this example, you would need to perform four sets of three-way merges to sort the
data. This is significantly less than the number of merges that you would need to
perform with traditional merge sort.

10. Explain the following overflow handling techniques with suitable examples?

(i) Open Addressing.-Sure, here is an explanation of open addressing along with a suitable example:

Open addressing is a collision handling technique used in hash tables to resolve collisions, which occur when two or more keys map to the same hash value. When a
collision occurs, open addressing probes for an empty slot in the hash table until it finds one, and then inserts the key into that slot.

There are several different open addressing strategies, but one of the most common is linear probing. In linear probing, the hash table is probed for an empty slot
starting at the initial hash value of the key, and then successively checking the next slots in the hash table until an empty slot is found.

For example, consider the following hash table with a size of 10 and a hash function that maps keys to their remainders when divided by 10:
```

Index | Value

------- | --------

0 | None

1 | None

2 | None

3 | None

4 | None

5 | None

6 | None

7 | None

8 | None

9 | None

```

If we insert the key 12 into the hash table, the hash function will calculate its hash value to be 2. However, slot 2 is already occupied, so we will probe for an empty slot
starting at slot 3. The next slot in the hash table is slot 3, which is empty, so we will insert the key 12 into that slot.

The resulting hash table is:

```

Index | Value

------- | --------

0 | None

1 | None

2 | None

3 | 12

4 | None
5 | None

6 | None

7 | None

8 | None

9 | None

```

If we insert the key 25 into the hash table, the hash function will calculate its hash value to be 5. However, slot 5 is already occupied, so we will probe for an empty slot
starting at slot 6. The next slot in the hash table is slot 6, which is empty, so we will insert the key 25 into that slot.

The resulting hash table is:

```

Index | Value

------- | --------

0 | None

1 | None

2 | None

3 | 12

4 | None

5 | None

6 | 25

7 | None

8 | None

9 | None

```

Open addressing is a simple and efficient way to handle collisions in hash tables. However, it can lead to clustering, which can degrade the performance of the hash
table. Clustering occurs when multiple keys are inserted into the same hash table bucket, which can make it difficult to find the desired key.

(ii) Chaining-Sure, here is an explanation of chaining in hash tables:

Chaining is a collision resolution technique in hash tables. It deals with the situation
when multiple keys are mapped to the same hash index. In chaining, instead of
overwriting or throwing an error, the colliding elements are stored in a linked list at
that index. The linked list stores all the elements that hash to the same index.

**Example:**

Consider a hash table with a size of 10 and the following key-value pairs:

```
(key, value) = (12, "apple"), (23, "banana"), (15, "grape"), (7, "orange")
```

Using the division method with the hash function h(x) = x % 10, all four keys will
hash to the same index, 2. This can lead to a collision.

With chaining, instead of overwriting or throwing an error, the colliding elements are
stored in a linked list at that index. The linked list stores all the elements that hash to
the index 2.

```
Index 0: -> None
Index 1: -> None
Index 2: -> 12 -> 23 -> 15 -> 7 -> None
Index 3: -> None
Index 4: -> None
Index 5: -> None
Index 6: -> None
Index 7: -> None
Index 8: -> None
Index 9: -> None
```

To search for an element using chaining, we first calculate its hash index and then
traverse the linked list at that index. For example, to search for the value with key 15,
we would look at index 2 and traverse the linked list to find the element with key 15.