The [ XYZ) are depicted as dynamic pathways, offering flexibility compared to the rigid structures of

[ABC]. The analogy of a chain of train cars illustrates the interconnected nature of [XYZ), each
containing data and a reference to the next node. [XYZ] adapts to growth and modification
seamlessly, enabling swift insertion and deletion operations. Whether managing playlists, navigating
web pages, or organizing contacts, [XYZ] offers the fluidity needed for dynamic data sets in real-life
scenarios.

1. How does a [XYZ) differ from [ABC] in terms of memory allocation and flexibility? Provide examples
of real-life situations where the dynamic nature of [XYZ] offers advantages over [ABC).

2. Explain the concept of nodes in a linked list. How do nodes facilitate the construction and traversal
of linked lists, and why are they essential components of this data structure? 3. How do you delete a
node at the beginning & the end of a linked list? Describe with code & logic.

### 1. Difference between [XYZ) and [ABC] in Terms of Memory Allocation and Flexibility
[XYZ), which we'll refer to as "linked lists," differ significantly from [ABC], which we'll refer to as "arrays,"
in terms of memory allocation and flexibility.

**Memory Allocation:**

- **Linked Lists ([XYZ]):** Linked lists allocate memory dynamically. Each element, known as a node,
contains data and a reference (or pointer) to the next node. This helps use memory efficiently because
you only use memory when you need it.

- **Arrays ([ABC]):** Arrays allocate memory in a contiguous block. This means that the size of the array
must be defined at the time of creation, and resizing an array requires creating a new array and copying
the elements.

**Flexibility:**

- **Linked Lists:** They offer high flexibility in terms of insertion and deletion. Adding or removing
elements doesn't require shifting elements, making these operations O(1) if the position is known.

- **Arrays:** While accessing elements is very efficient (O(1) time complexity), insertion and deletion
can be expensive (O(n) time complexity) since elements may need to be shifted.

**Examples of Real-Life Situations:**

- **Playlists:** Managing a playlist of songs where you frequently add or remove songs is more
efficiently handled by a linked list due to its dynamic nature.

- **Navigating Web Pages:** Web browsers can use a linked list to keep track of visited pages, making
the back and forward buttons work.

- **Organizing Contacts:** In contact management apps, linked lists make it easy to add or remove
contacts efficiently.
### 2. Concept of Nodes in a Linked List
**Nodes:**

A node in a linked list is a fundamental building block. Each node contains two main components:

1. **Data:** The actual information or value stored in the node.

2. **Reference (Pointer):** A pointer to the next node in the sequence.

**Construction and Traversal:**

- **Construction:** Nodes are linked together via pointers to form a chain. The first node is referred to
as the head, and the last node points to `null`, indicating the end of the list.

- **Traversal:** To traverse a linked list, you start at the head node and follow the pointers from one
node to the next until you reach the end (`null`).

**Importance:**

Nodes are crucial because they hold data and links, making linked lists flexible. They allow easy insertion
and deletion without reorganizing everything.

### 3. Deleting a Node in a Linked List

To delete a node at the beginning of a linked list, you need to:

1. Update the head pointer to point to the second node.

2. Free the memory of the original head node if using a language that requires explicit memory
management.

Delete at the beginning:

Push:
Pop:

Nod creation (Beginning):

Nod creation (Ending):

Stack implement through linked list:

int data;

struct Node* next;

};

struct Node* createNode(int data) {

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

newNode->data = data;

newNode->next = NULL;

return newNode;

void push(struct Node** top, int data) {

struct Node* newNode = createNode(data);

newNode->next = *top;

*top = newNode;

}
int isEmpty(struct Node* top) {

return !top;

void printStack(struct Node* top) {

while (top != NULL) {

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

top = top->next;

printf("NULL\n");

Algorithm of BFS:

Step 1: SET STATUS = 1 (ready state) for each node in G

Step 2: Enqueue the starting node A and set its STATUS = 2 (waiting state)

Step 3: Repeat Steps 4 and 5 until QUEUE is empty

Step 4: Dequeue a node N. Process it and set its STATUS = 3 (processed state).

Step 5: Enqueue all the neighbours of N that are in the ready state (whose STATUS = 1) and set

their STATUS = 2

(waiting state)

[END OF LOOP]

Step 6: EXIT
Algorithm of DFS:

Step 1: SET STATUS = 1 (ready state) for each node in G

Step 2: Push the starting node A on the stack and set its STATUS = 2 (waiting state)

Step 3: Repeat Steps 4 and 5 until STACK is empty

Step 4: Pop the top node N. Process it and set its STATUS = 3 (processed state)

Step 5: Push on the stack all the neighbors of N that are in the ready state (whose STATUS = 1)
and set their STATUS = 2 (waiting state)

[END OF LOOP]

Step 6: EXIT

Tamim