To make your singly linked list useful, you need to add nodes to it. You will implement the logic to insert nodes into the list. You will create new nodes, connect them, and integrate them so that the list grows dynamically as you add elements.

This hands-on approach helps you understand exactly what happens behind the scenes.

Implementing Node Insertion

Let's write a simple function to create a node. This function should:

• As an argument, take a number of type int, which will be stored in the node in the data field;
• Create a pointer to a dynamically allocated memory area (taking into account the size of the node);
• Check the success of memory allocation for the node;
• Put the required value (function argument) into the data field;
• The next pointer must be NULL, since the function creates only one node;
• The function must return a pointer to the memory area where value is stored.

The AddNewNode() function takes a pointer to a pointer, because it can change the value of the pointer to the first (head) node of the list, as well as the value that will be stored in the new node:

void AddNewNode(struct Node** head, int value) 
{
	...
}

If the list is empty (*head == NULL), we simply update the pointer to the head of the list (*head) to point to the new node (newNode), in which case newNode will become the first node (head node). In the case of a non-empty list, we use a loop to look for the last node.

The current node plays the role of a buffer node, with its help we can iterate through the list and find a node that points to nowhere (*next == NULL).

struct Node* current = *head;

while (current->next != NULL) 
{
    ...
}

After all, you need to make the new node newNode the last node, which means current->next must be equal to newNode. Now newNode is the last node in the list.

As a task, you need to figure out and add a function for adding new nodes to existing nodes.