Singly Linked List – Insert Operation

Insert Operation in Singly Linked List

Insertion in a singly linked list means placing a new node at a specific position. This can be at the beginning, in the middle, or at the end of the list.

The key part of insertion is updating the next pointers correctly so that the new node is properly linked in the chain.

Visual Example

Let's understand how insertion works in a singly linked list by walking through an example step by step.

We start with the following list:

Now, we want to insert the value 30 at index 2. The final list should look like this:

Step-by-Step Insertion at Index 2

Start with the original list:

The list has three nodes with values: 10, 20, and 40. Each node points to the next one using a next pointer. The last node points to null indicating the end of the list.
Traverse the list to reach the node just before the insertion point: Since we want to insert at index 2, we need to find the node at index 1. That’s the node with value 20. We store a reference to this node in a temporary variable called current.
Create a new node with the value to be inserted:

We create a new node containing the value 30. This node will be inserted between 20 and 40. Initially, this new node does not point to anything.
Set the new node’s next pointer:
We make the new node point to what current.next was previously pointing to. Since current is pointing to the node with value 20, and current.next was pointing to the node with value 40, now we do:
newNode.next = current.next that is 30 → 40
Link the previous node to the new node:
Now that the new node correctly points to the next part of the list, we update the current node (i.e., 20) so that it now points to the new node:

This completes the insertion. The linked list is now correctly updated.

Final Structure After Insertion

The list now looks like this: 10 → 20 → 30 → 40 → null

The green-highlighted node is the newly inserted node with value 30.

Complete Pseudocode: Insert Node in Singly Linked List

This pseudocode shows how to insert a node at a specific index in a singly linked list.

function insertAt(head, index, value):
    newNode = new ListNode(value)

    if index == 0:
        newNode.next = head
        return newNode

    curr = head
    for i in range(index - 1):
        curr = curr.next

    newNode.next = curr.next
    curr.next = newNode

    return head

Let’s walk through each part of the code to understand what it does.

function insertAt(head, index, value):
    newNode = new ListNode(value)

Explanation: We define a function that will insert a new node into the linked list. A new node is created using the value given as input.

    if index == 0:
        newNode.next = head
        return newNode

Explanation: If the target index is 0, the new node should become the new head. We set the new node’s next pointer to the current head and return the new node as the new head of the list.

    curr = head
    for i in range(index - 1):
        curr = curr.next

Explanation: To insert elsewhere, we start at the head and move curr to the node just before the target index. This is done by looping index - 1 times.

    newNode.next = curr.next
    curr.next = newNode

Explanation: After reaching the correct position, we first connect the new node to the next node using newNode.next. Then, we connect the previous node (curr) to the new node using curr.next.

    return head

Explanation: Finally, we return the head of the updated list so the caller can continue using the modified list structure.