**Course Title:** Mastering C: From Fundamentals to Advanced Programming **Section Title:** Advanced Data Structures: Linked Lists **Topic:** Build a C program that implements a singly linked list with basic operations.(Lab topic) **Introduction** In this lab topic, you'll learn how to implement a singly linked list with basic operations using the C programming language. A linked list is a linear data structure where each element is a separate object, known as a node. Each node contains two items: the data and a reference (or link) to the next node in the sequence. This structure allows for efficient insertion or removal of elements from any position in the sequence. **Step 1: Define the Node Structure** To start building your linked list, you need to define the structure of a node. A node typically consists of two fields: an integer data field and a pointer to the next node. ```c typedef struct Node { int data; struct Node* next; } Node; ``` **Step 2: Define the Linked List Structure** Next, you'll define a structure for the linked list itself. This structure will hold a pointer to the head node and keep track of the number of nodes in the list. ```c typedef struct LinkedList { Node* head; int size; } LinkedList; ``` **Step 3: Implement Basic Operations** You'll implement the following basic operations: * **Create Node**: Dynamically allocate memory for a new node and initialize its data and next fields. * **Insert Node**: Insert a new node at the beginning, middle, or end of the linked list. * **Delete Node**: Delete a node from the linked list. * **Print List**: Print all elements in the linked list. * **Destroy List**: Deallocate memory for all nodes in the linked list. Here's a sample implementation: ```c Node* createNode(int data) { Node* newNode = (Node*)malloc(sizeof(Node)); if (!newNode) { printf("Memory error\n"); return NULL; } newNode->data = data; newNode->next = NULL; return newNode; } void insertNode(LinkedList* list, Node* newNode) { if (list->head == NULL || list->head->data >= newNode->data) { newNode->next = list->head; list->head = newNode; } else { Node* ptr = list->head; while (ptr->next != NULL && ptr->next->data < newNode->data) { ptr = ptr->next; } newNode->next = ptr->next; ptr->next = newNode; } list->size++; } Node* deleteNode(LinkedList* list, int data) { if (list->head == NULL) { printf("List is empty\n"); return NULL; } if (list->head->data == data) { Node* temp = list->head; list->head = list->head->next; list->size--; return temp; } Node* ptr = list->head; while (ptr->next != NULL && ptr->next->data != data) { ptr = ptr->next; } if (ptr->next == NULL) { printf("Invalid key\n"); return NULL; } Node* temp = ptr->next; ptr->next = ptr->next->next; list->size--; return temp; } void printList(LinkedList* list) { Node* ptr = list->head; while (ptr != NULL) { printf("%d->", ptr->data); ptr = ptr->next; } printf("NULL\n"); } void destroyList(LinkedList* list) { Node* ptr = list->head; while (ptr != NULL) { Node* temp = ptr; ptr = ptr->next; free(temp); } list->head = NULL; list->size = 0; } ``` **Example Usage** ```c int main() { LinkedList list; list.head = NULL; list.size = 0; // Create nodes Node* node1 = createNode(5); Node* node2 = createNode(10); Node* node3 = createNode(15); // Insert nodes into the linked list insertNode(&list, node1); insertNode(&list, node2); insertNode(&list, node3); // Print linked list printList(&list); // Delete a node deleteNode(&list, 10); // Print linked list after deletion printList(&list); // Destroy linked list destroyList(&list); return 0; } ``` **Note:** This code uses a simple implementation for the linked list operations. In a real-world scenario, you would need to handle edge cases and errors more robustly. **Conclusion** In this lab topic, you've learned how to implement a singly linked list with basic operations using the C programming language. Practice implementing these operations on your own to solidify your understanding. For more detailed information about linked lists and their applications, refer to [GeeksforGeeks](https://www.geeksforgeeks.org/linked-list-set-1-introduction/) and [Tutorialspoint](https://www.tutorialspoint.com/data_structures_algorithms/linked_list_algorithms.htm). **Join the Discussion:** We invite you to share your thoughts and suggestions about this topic in the comment section below. This is the end of the lab topic on implementing a singly linked list with basic operations. In the next topic, you'll learn about common sorting algorithms: bubble sort, selection sort, and quicksort.