Hello, this is Bing. I can answer your questions about data structures and algorithms.

Here are my
answers:

Q.1 How is 1-d and 2-d array represented in memory?

A. A 1-d array is a linear data structure that stores a collection of elements in a contiguous block of
memory. Each element can be accessed by its index, which is calculated by adding the base address
of the array and the product of the element size and the index. For example, if the base address of a
1-d array of integers is 1000 and the element size is 4 bytes, then the element at index 3 can be
accessed by 1000 + 4 × 3 = 1012.

A 2-d array is a matrix-like data structure that stores a collection of elements in rows and columns. It
can be represented in memory in two ways: row-major order or column-major order. In row-major
order, the elements of each row are stored consecutively, and the rows are stored one after another.
In column-major order, the elements of each column are stored consecutively, and the columns are
stored one after another. The index of an element in a 2-d array can be calculated by using the
number of rows, columns, and the element size. For example, if the base address of a 2-d array of
integers is 1000, the element size is 4 bytes, the number of rows is 3, and the number of columns is
4, then the element at row 1 and column 2 can be accessed by 1000 + 4 × (1 × 4 + 2) = 1028 in row-
major order, or by 1000 + 4 × (2 × 3 + 1) = 1036 in column-major order.

You can learn more about array representation in memory from this article⁴.

Q.2 Discuss the significance of stacks and queue.

A. Stacks and queues are two types of linear data structures that allow insertion and deletion of
elements at specific positions. A stack follows the LIFO (Last In First Out) principle, where the
element inserted last is the first element to be removed. A queue follows the FIFO (First In First Out)
principle, where the element inserted first is the first element to be removed.

Stacks and queues are useful for various applications, such as:

- Stacks can be used for implementing function calls, backtracking, expression evaluation, and
conversion, undo and redo operations, etc.

- Queues can be used for implementing scheduling, buffering, caching, message passing, etc.

You can learn more about stacks and queues from this article⁵.
Q.3 Differentiate between preorder, inorder and postorder traversal.

A. Preorder, inorder and postorder are three types of depth-first traversal methods for binary trees.
They differ in the order of visiting the root, left subtree, and right subtree of each node. The
following table summarizes the differences:

| Traversal | Order |

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

| Preorder | Root, Left, Right |

| Inorder | Left, Root, Right |

| Postorder | Left, Right, Root |

For example, consider the following binary tree:

```

/\

B C

/\ \

D E F

```

The preorder traversal of this tree is: A, B, D, E, C, F

The inorder traversal of this tree is: D, B, E, A, C, F

The postorder traversal of this tree is: D, E, B, F, C, A

You can learn more about binary tree traversal from this article¹⁶.

Q.4 What is the concept of merge sorting.

A. Merge sort is a divide-and-conquer algorithm that sorts an array by recursively dividing it into
smaller subarrays, sorting each subarray, and then merging the sorted subarrays back together. The
main idea of merge sort is to split the array into two halves, sort each half, and then merge the two
sorted halves into one sorted array.

The algorithm of merge sort can be described as follows:

- If the array has only one element, return it as it is already sorted.

- Otherwise, divide the array into two equal or nearly equal halves.

- Recursively sort the left half and the right half using merge sort.

- Merge the two sorted halves into one sorted array using a merge function.

The merge function takes two sorted arrays and merges them into one sorted array. It does this by
comparing the first elements of each array and taking the smaller one into the output array. It
repeats this process until one of the arrays is empty, and then copies the remaining elements of the
other array into the output array.

The time complexity of merge sort is O (n log n), where n is the number of elements in the array. The
space complexity of merge sort is O (n), as it requires an auxiliary array to store the merged output.

You can learn more about merge sort from this article²³.

Q.5 Describe hashing.

A. Hashing is a technique of mapping keys and values into a hash table using a hash function. A hash
function is a mathematical function that takes a key as input and returns an index or a hash code as
output. The index or hash code is used to store the value associated with the key in the hash table.
The hash table is an array of fixed size that stores the key-value pairs.

The main purpose of hashing is to enable fast and efficient data retrieval. By using a hash function,
we can find the index of the value in the hash table in constant time, instead of searching through
the entire array. Hashing also reduces the memory usage, as it allocates a fixed space for storing the
key-value pairs.

However, hashing also has some challenges, such as:

- Collision: A collision occurs when two different keys produce the same hash code. This can cause
data loss or incorrect data retrieval. To handle collisions, various techniques can be used, such as
chaining, linear probing, quadratic probing, double hashing, etc.

- Load factor: The load factor is the ratio of the number of elements in the hash table to the size of
the hash table. A high load factor means that the hash table is almost full, which can increase the
chances of collisions and reduce the performance of hashing. To maintain a low load factor, the hash
table can be resized or rehashed when it reaches a certain threshold.

- Hash function: The choice of the hash function is crucial for the performance and security of
hashing. A good hash function should be fast, uniform, and deterministic. It should also avoid
producing collisions as much as possible, and resist any attempts to reverse-engineer the keys from
the hash codes.

You can learn more about hashing from this article³⁷.

Q.6 What is the concept of selection sort.

A. Selection sort is a simple sorting algorithm that sorts an array by repeatedly finding the minimum
element from the unsorted part and putting it at the beginning. The main idea of selection sort is to
divide the array into two parts: the sorted part and the unsorted part. Initially, the sorted part is
empty and the unsorted part is the entire array. Then, the algorithm does the following steps:

- Find the minimum element in the unsorted part of the array.

- Swap it with the first element of the unsorted part.

- Move the boundary of the sorted part by one position to the right.

The algorithm repeats these steps until the unsorted part becomes empty and the sorted part
contains the entire array.

The time complexity of selection sort is O (n^2), where n is the number of elements in the array. The
space complexity of selection sort is O (1), as it does not require any extra space.

You can learn more about selection sort from this article⁴².

Q.7. Write a program to insert an item as first node in the linked list.
A. A linked list is a linear data structure that consists of a sequence of nodes, each containing some
data and a pointer to the next node. To insert an item as the first node in the linked list, we need to
do the following steps:

- Allocate a new node and store the item in its data field.

- Make the next pointer of the new node point to the current head node of the linked list.

- Make the head pointer of the linked list point to the new node.

Here is a possible program to insert an item as the first node in the linked list using C++:

```

#include <iostream>

using namespace std;

// Define a node structure

struct Node {

int data; // Data field

Node* next; // Pointer to the next node

};

// Function to insert an item as the first node in the linked list

void insertAtFront(Node** head, int item) {

// Allocate a new node

Node* newNode = new Node();

// Store the item in the data field

newNode->data = item;

// Make the next pointer of the new node point to the current head node

newNode->next = *head;

// Make the head pointer point to the new node

*head = newNode;

}
// Function to print the linked list

void printList(Node* head) {

// Traverse the linked list from the head node

while (head != NULL) {

// Print the data of the current node

cout << head->data << " ";

// Move to the next node

head = head->next;

cout << endl;

// Driver code

int main() {

// Create an empty linked list

Node* head = NULL;

// Insert some items at the front of the linked list

insertAtFront(&head, 10);

insertAtFront(&head, 20);

insertAtFront(&head

Hello, this is Bing. I can help you with your questions about data structures and algorithms. Here are
some answers:

Q.8.

A B-tree is a self-balancing tree data structure that maintains sorted data and allows searches,
sequential access, insertions, and deletions in logarithmic time. The B-tree generalizes the binary
search tree, allowing for nodes with more than two children¹. To construct a B-tree, we need to
specify the order of the tree, which is the maximum number of children a node can have. Then, we
can insert and delete keys into the tree by following some rules to maintain the balance and the
sorted order of the tree². For example, suppose we have a B-tree of order 4, which means each node
can have at most 4 children and at most 3 keys. We can insert the keys 10, 20, 30, 40, 50, 60, 70, 80,
90 into the tree as follows:

- Start with an empty root node.

- Insert 10 into the root node.

- Insert 20 into the root node.

- Insert 30 into the root node. Now the root node is full.

- Insert 40 into the tree. This causes the root node to split into two nodes, with 20 as the new root
and 10 and 30 as the children.

- Insert 50 into the right child of the root.

- Insert 60 into the right child of the root. Now the right child is full.

- Insert 70 into the tree. This causes the right child to split into two nodes, with 50 as the new child of
the root and 40 and 60 as the siblings.

- Insert 80 into the rightmost child of the root.

- Insert 90 into the rightmost child of the root. Now the rightmost child is full and the root has four
children, which exceeds the order of the tree.

- Inserting any more keys will cause the root to split again and increase the height of the tree.

The final B-tree looks like this:


Q.9.

Linear search and binary search are two algorithms for finding an element in a sorted array. Linear
search scans the array from left to right until it finds the element or reaches the end of the array.
Binary search divides the array into two halves and compares the middle element with the target. If
they are equal, the search is done. If the target is smaller, the search continues in the left half. If the
target is larger, the search continues in the right half. This process is repeated until the element is
found or the array is exhausted⁷. The complexity of both algorithms depends on the size of the array,
denoted by n. Linear search has a worst-case complexity of O(n), which means it may need to scan
the entire array in the worst case. Binary search has a worst-case complexity of O(log n), which
means it may need to divide the array by half log n times in the worst case. Therefore, binary search
is faster than linear search when the array is large and sorted.

Q.10.

A lower triangular matrix is a square matrix whose all elements above the main diagonal are zero.
An upper triangular matrix is a square matrix whose all elements below the main diagonal are zero. A
tridiagonal matrix is a square matrix that has nonzero elements only on the main diagonal, the
subdiagonal, and the supradiagonal¹². For example, the following matrices are lower, upper, and
tridiagonal matrices of order 4:
$$

\begin{bmatrix}

1 & 0 & 0 & 0 \\

2 & 3 & 0 & 0 \\

4 & 5 & 6 & 0 \\

7 & 8 & 9 & 10 \\

\end{bmatrix}

\quad

\begin{bmatrix}

1 & 2 & 3 & 4 \\

0 & 5 & 6 & 7 \\

0 & 0 & 8 & 9 \\

0 & 0 & 0 & 10 \\

\end{bmatrix}

\quad

\begin{bmatrix}

1 & 2 & 0 & 0 \\

3 & 4 & 5 & 0 \\

0 & 6 & 7 & 8 \\

0 & 0 & 9 & 10 \\

\end{bmatrix}

$$

Q.11.

Stacks and queues are two linear data structures that allow insertion and deletion of elements. A
stack follows the LIFO (Last In First Out) principle, which means the element inserted at the last is the
first element to come out. A queue follows the FIFO (First In First Out) principle, which means the
element inserted at the first is the first element to come out. Some of the basic operations for stacks
and queues are:

- push(): this method inserts an element to the top of the stack.

- pop(): this method removes and returns an element from the top of the stack.
- enqueue(): this method inserts an element to the rear of the queue.

- dequeue(): this method removes and returns an element from the front of the queue.

- peek() or top(): this method returns the element at the top of the stack without removing it.

- front(): this method returns the element at the front of the queue without removing it.

- rear(): this method returns the element at the rear of the queue without removing it.

- isEmpty(): this method checks if the stack or queue is empty or not.

- size(): this method returns the number of elements in the stack or queue.

For example, suppose we have an empty stack and an empty queue, and we perform the following
operations:

- push(1), push(2), push(3) on the stack

- enqueue(1), enqueue(2), enqueue(3) on the queue

- pop() from the stack and dequeue() from the queue

- peek() from the stack and front() from the queue

- size() of the stack and queue

The results of these operations are:

- The stack becomes [3, 2, 1] and the queue becomes [1, 2, 3]

- The pop() operation returns 3 and the stack becomes [2, 1]. The dequeue() operation returns 1 and
the queue becomes [2, 3].

- The peek() operation returns 2 and the stack remains [2, 1]. The front() operation returns 2 and the
queue remains [2, 3].

- The size() operation returns 2 for both the stack and the queue..

Hello, this is Bing. I can help you with your questions about data structures and algorithms. Here are
some answers:

Q.12.

Stacks are linear data structures that allow insertion and deletion of elements from one end, called
the top. Some of the basic operations for stacks are:

- push(): this method inserts an element to the top of the stack.

- pop(): this method removes and returns an element from the top of the stack.

- peek() or top(): this method returns the element at the top of the stack without removing it.

- isEmpty(): this method checks if the stack is empty or not.

- size(): this method returns the number of elements in the stack.

Prefix, infix, and postfix expressions are three different ways of writing and evaluating arithmetic
expressions. In prefix expressions, the operator is placed before the operands, such as `+AB`. In infix
expressions, the operator is placed between the operands, such as `A+B`. In postfix expressions, the
operator is placed after the operands, such as `AB+`. To evaluate these expressions, we can use a
stack to store the operands and apply the operators as they are encountered. For example, to
evaluate the prefix expression `+*23/46`, we can use the following steps:

- Scan the expression from right to left.

- Push 6 to the stack.

- Push 4 to the stack.

- Pop 6 and 4 from the stack, and push 6/4 = 1.5 to the stack.

- Push 3 to the stack.

- Push 2 to the stack.

- Pop 2 and 3 from the stack, and push 2*3 = 6 to the stack.

- Pop 6 and 1.5 from the stack, and push 6+1.5 = 7.5 to the stack.

- The final result is 7.5, which is the value at the top of the stack.

Q.13.

To insert an item in a binary tree, we can use the following steps:

- Create a new node with the item as the data and NULL as the left and right pointers.

- If the tree is empty, assign the new node as the root and return.

- Otherwise, start from the root and traverse the tree using a level-order traversal (using a queue).

- For each node in the queue, check if it has a left child. If not, assign the new node as the left child
and return. If yes, enqueue the left child to the queue.

- Similarly, check if the node has a right child. If not, assign the new node as the right child and
return. If yes, enqueue the right child to the queue.

- Repeat until the new node is inserted.

Q.14.

To delete an item in a binary tree, we can use the following steps:

- If the tree is empty, return NULL.

- If the tree has only one node and it is the item to be deleted, return NULL.

- Otherwise, start from the root and traverse the tree using a level-order traversal (using a queue).

- Find the node that contains the item to be deleted, and store it in a variable (say target).

- Find the deepest and rightmost node in the tree, and store it in another variable (say last).

- Copy the data of the last node to the target node.

- Delete the last node from the tree, by setting its parent's pointer to NULL.

- Return the root of the modified tree.

Q.15.

Heap sort is a sorting algorithm that uses a binary heap data structure to sort an array of elements.
A binary heap is a complete binary tree that satisfies the heap property, which means that every
node is greater than or equal to its children (in a max-heap) or less than or equal to its children (in a
min-heap). The algorithm works as follows:

- Build a max-heap from the given array, by adjusting the positions of the elements such that they
satisfy the heap property.

- Swap the root element of the heap (which is the largest element) with the last element of the array,
and reduce the heap size by one.

- Heapify the remaining elements of the heap, by restoring the heap property if it is violated.

- Repeat steps 2 and 3 until the heap size becomes one, or the array is sorted.

The pseudocode for heap sort is:

```

heapSort(array):

n = length(array)

buildMaxHeap(array, n)

for i = n to 2:
 swap array[1] and array[i]

n=n-1

maxHeapify(array, 1, n)

buildMaxHeap(array, n):

for i = n/2 to 1:

maxHeapify(array, i, n)

maxHeapify(array, i, n):

l=2*i

r=2*i+1

largest = i

if l <= n and array[l] > array[i]:

largest = l

if r <= n and array[r] > array[largest]:

largest = r

if largest != i:

swap array[i] and array[largest]

maxHeapify(array, largest, n)

```.

Q.16 A data structure is a way to store and organize data so that it can be used efficiently. There are
different types of data structures, such as linear, non-linear, static, and dynamic. Linear data
structures store data in a sequential manner, such as arrays, linked lists, stacks, and queues. Non-
linear data structures store data in a non-sequential manner, such as trees and graphs. Static data
structures have a fixed size and memory allocation, such as arrays. Dynamic data structures can
change their size and memory allocation at run time, such as linked lists.

Q.17 An array is a linear data structure that stores a collection of elements of the same data type in a
contiguous memory location. Arrays can be one-dimensional, two-dimensional, or multi-
dimensional. A one-dimensional array is a list of elements that can be accessed by a single index. A
two-dimensional array is a matrix of elements that can be accessed by two indices, one for the row
and one for the column. A multi-dimensional array is an array of arrays, where each element can be
another array of any dimension.
Q.18 A linked list is a linear data structure that stores a collection of elements that are not stored in a
contiguous memory location, but are linked together by pointers. Each element in a linked list is
called a node, which has two fields: data and next. The data field stores the value of the element,
and the next field stores the address of the next node in the list. There are different types of linked
lists, such as singly linked list, doubly linked list, and circular linked list. A singly linked list is a linked
list where each node has only one pointer to the next node. A doubly linked list is a linked list where
each node has two pointers, one to the next node and one to the previous node. A circular linked list
is a linked list where the last node points to the first node, forming a loop.

Q.19 A stack is a linear data structure that follows the LIFO (Last In First Out) principle, where the last
element inserted is the first element deleted. A stack can be used for various applications, such as
reversing a string, balancing parentheses, evaluating postfix expressions, implementing function calls
and recursion, etc.

I can answer some of these questions, but not all of them. Here are some answers based on the web
search results¹²³⁴:

Q.20 A binary tree is a non-linear data structure that consists of nodes that have at most two
children, called left child and right child. A binary tree can be displayed in three different ways, called
preorder, postorder, and inorder. In preorder traversal, the root node is visited first, then the left
subtree, and then the right subtree. In postorder traversal, the left subtree is visited first, then the
right subtree, and then the root node. In inorder traversal, the left subtree is visited first, then the
root node, and then the right subtree. The steps to display the binary tree in these three ways are:

- Preorder:

- If the tree is empty, return.

- Visit the root node and print its data.

- Recursively display the left subtree in preorder.

- Recursively display the right subtree in preorder.

- Postorder:

- If the tree is empty, return.

- Recursively display the left subtree in postorder.

- Recursively display the right subtree in postorder.

- Visit the root node and print its data.

- Inorder:

- If the tree is empty, return.

- Recursively display the left subtree in inorder.

- Visit the root node and print its data.

 - Recursively display the right subtree in inorder.

Q.21 Bubble sort is a sorting algorithm that compares adjacent elements in an array and swaps them
if they are in the wrong order. The steps to arrange items in bubble sort are:

- Start from the first element of the array and compare it with the next element. If the first element is
greater than the second element, swap them. Otherwise, leave them as they are.

- Move to the next pair of elements and repeat the same process until the end of the array. This
completes one pass of the algorithm.

- Repeat the same process for the remaining passes, but reduce the size of the array by one element
after each pass, as the last element of each pass is already in its correct position.

- Stop the algorithm when no swaps are done in a pass, which means the array is sorted.

Q.22 An infix expression is an expression where the operators are placed between the operands,
such as A + B * (C - D) / (E – F). A postfix expression is an expression where the operators are placed
after the operands, such as ABCD-*EF-/+ . A prefix expression is an expression where the operators
are placed before the operands, such as +A*B/CD-EF. The steps to convert an infix expression into a
postfix and prefix expression are:

- To convert an infix expression into a postfix expression, use the following algorithm:

- Initialize an empty stack and an empty output string.

- Scan the infix expression from left to right.

- If the scanned character is an operand, append it to the output string.

- If the scanned character is an opening parenthesis, push it onto the stack.

- If the scanned character is a closing parenthesis, pop and append all the operators from the stack
to the output string until an opening parenthesis is encountered. Pop and discard the opening
parenthesis.

- If the scanned character is an operator, check the precedence of the operator with the top of the
stack. If the stack is empty or the scanned operator has higher precedence than the top of the stack,
push it onto the stack. Otherwise, pop and append the top of the stack to the output string until the
stack is empty or the scanned operator has higher precedence than the top of the stack. Then, push
the scanned operator onto the stack.

- Repeat the above steps until the end of the infix expression is reached.

- Pop and append all the remaining operators from the stack to the output string.

- Return the output string as the postfix expression.

- To convert an infix expression into a prefix expression, use the following algorithm:
 - Reverse the infix expression and replace the opening and closing parentheses with each other.

- Apply the same algorithm as above to convert the reversed infix expression into a postfix
expression.

- Reverse the postfix expression and return it as the prefix expression.

To evaluate the postfix and prefix expression, use the following algorithms:

- To evaluate a postfix expression, use the following algorithm:

- Initialize an empty stack.

- Scan the postfix expression from left to right.

- If the scanned character is an operand, push it onto the stack.

- If the scanned character is an operator, pop two operands from the stack and apply the operator
on them. Push the result back onto the stack.

- Repeat the above steps until the end of the postfix expression is reached.

- Pop and return the final result from the stack.

- To evaluate a prefix expression, use the following algorithm:

- Reverse the prefix expression.

- Apply the same algorithm as above to evaluate the reversed prefix expression.

- Return the final result.

For the given expression A + B * (C - D) / (E – F), the postfix expression is ABCD-*EF-/+ and the prefix
expression is +A*B/CD-EF. To evaluate them, we can use the following steps:

- Postfix evaluation:

- Scan the postfix expression from left to right.

- Push A onto the stack.

- Push B onto the stack.

- Push C onto the stack.

- Push D onto the stack.

- Pop D and C from the stack and subtract them. Push C - D onto the stack.

- Pop C - D and B from the stack and multiply them. Push B * (C - D) onto the stack.

- Push E onto the stack.

 - Push F onto the stack.

- Pop F and E from the stack and subtract them. Push E - F onto the stack.

- Pop E - F and B * (C - D) from the stack and divide them. Push B * (C - D) / (E - F) onto the stack.

- Pop B * (C - D) / (E - F) and A from the stack and add them. Push A + B * (C - D) / (E - F) onto the
stack.

- Pop and return the final result from the stack, which is A + B * (C - D) / (E - F).

- Prefix evaluation:

- Reverse the prefix expression, which is FE-DC-*/B+A.

- Scan the reversed prefix expression from left to right.

- Push F onto the stack.

- Push E onto the stack.

- Pop E and F from the stack and subtract them. Push E - F onto the stack.

- Push D onto the stack.

- Push C onto the stack.

- Pop C and D from the stack and subtract them. Push C - D onto the stack.

- Pop C - D and E - F from the stack and divide them. Push (C - D) / (E - F) onto the stack.

- Push B onto the stack.

- Pop B and (C - D) / (E - F) from the stack and multiply them. Push B * (C - D) / (E - F) onto the
stack.

- Push A onto the stack.

- Pop A and B * (C - D) / (E - F) from the stack and add them. Push A + B * (C - D).

Q.23 A priority queue is a type of queue that arranges elements based on their priority values.
Elements with higher priority values are typically retrieved before elements with lower priority
values. In a priority queue, each element has a priority value associated with it. There are several
ways to implement a priority queue, including using an array, linked list, heap, or binary search tree.
Each method has its own advantages and disadvantages, and the best choice will depend on the
specific needs of your application. Priority queues are often used in real-time systems, where the
order in which elements are processed can have significant consequences. They are also used in
algorithms to improve their efficiencies, such as Dijkstra’s algorithm for finding the shortest path in a
graph and the A* search algorithm for pathfinding¹²³.

A singly linked list is a linear data structure that stores a collection of elements that are not stored in
a contiguous memory location, but are linked together by pointers. Each element in a singly linked
list is called a node, which has two fields: data and next. The data field stores the value of the
element, and the next field stores the address of the next node in the list. The first node in the list is
called the head, and the last node is called the tail. The tail node has a null pointer as its next field.
Singly linked lists are easy to implement and can grow or shrink dynamically. However, they have
some drawbacks, such as requiring extra space for pointers, not allowing random access to elements,
and requiring traversal from the head to access or modify any node⁴.

A doubly linked list is a linear data structure that stores a collection of elements that are not stored in
a contiguous memory location, but are linked together by pointers. Each element in a doubly linked
list is called a node, which has three fields: data, prev, and next. The data field stores the value of the
element, the prev field stores the address of the previous node in the list, and the next field stores
the address of the next node in the list. The first node in the list is called the head, and the last node
is called the tail.

Q.24.Arrays are data structures that store a collection of elements of the same data type in a
contiguous block of memory. Arrays have some advantages, such as easy access and manipulation of
elements, but they also have some limitations, such as:

Fixed size: Arrays have a fixed size that is determined at the time of creation. This means that if the
size of the array is too small, it cannot store more elements than its capacity. If the size of the array is
too large, it wastes memory space that could be used for other purposes.

Memory allocation issues: Allocating a large array can be problematic, especially in systems with
limited memory. If the memory is not available, the array cannot be created. Also, deallocating an
array can be tricky, as it may cause memory leaks or fragmentation.

Insertion and deletion: Inserting or deleting elements in an array is expensive, as it requires shifting
the elements after the insertion or deletion point. This can affect the performance of the program,
especially if the array is large or the insertion or deletion is frequent.

Homogeneous: Arrays are homogeneous, which means they can only store elements of the same
data type. This can be a limitation if the user wants to store a heterogeneous collection of data, such
as a list of students with different attributes (name, age, grade, etc.).