Insert at End Tail Insert in DSA Java

Mental Model

Add a new item at the very end of a chain by moving to the last item and linking the new one after it.

Analogy: Imagine a line of people holding hands. To add a new person at the end, you walk to the last person and hold their hand.

head -> 1 -> 2 -> 3 -> null
           ↑

Dry Run Walkthrough

Input: list: 1 -> 2 -> 3, insert value 4 at end

Goal: Add the value 4 as the last node in the list

Step 1: start at head node with value 1

head -> [curr->1] -> 2 -> 3 -> null

Why: We begin traversal from the first node

Step 2: move curr to next node with value 2

head -> 1 -> [curr->2] -> 3 -> null

Why: We need to reach the last node, so move forward

Step 3: move curr to next node with value 3

head -> 1 -> 2 -> [curr->3] -> null

Why: Continue moving until the last node is found

Step 4: curr.next is null, attach new node with value 4

head -> 1 -> 2 -> 3 -> 4 -> null

Why: Link new node at the end to complete insertion

Result:

head -> 1 -> 2 -> 3 -> 4 -> null

Annotated Code

DSA Java

public class LinkedList {
    static class Node {
        int data;
        Node next;
        Node(int data) {
            this.data = data;
            this.next = null;
        }
    }

    Node head;

    // Insert new node at the end of the list
    public void insertAtEnd(int value) {
        Node newNode = new Node(value);
        if (head == null) {
            head = newNode; // empty list, new node is head
            return;
        }
        Node curr = head;
        while (curr.next != null) {
            curr = curr.next; // move to last node
        }
        curr.next = newNode; // link new node at end
    }

    // Print list nodes
    public void printList() {
        Node curr = head;
        while (curr != null) {
            System.out.print(curr.data);
            if (curr.next != null) System.out.print(" -> ");
            curr = curr.next;
        }
        System.out.println(" -> null");
    }

    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.insertAtEnd(1);
        list.insertAtEnd(2);
        list.insertAtEnd(3);
        list.insertAtEnd(4); // insert value 4 at end
        list.printList();
    }
}

if (head == null) { head = newNode; // empty list, new node is head return; }

handle empty list by setting head to new node

while (curr.next != null) { curr = curr.next; // move to last node }

advance curr pointer until last node is reached

curr.next = newNode; // link new node at end

attach new node after last node to insert at end

Output

1 -> 2 -> 3 -> 4 -> null

Complexity Analysis

Time: O(n) because we traverse all nodes once to reach the end

Space: O(1) because we only use a few extra variables regardless of list size

vs Alternative: Compared to inserting at the front (O(1)), inserting at end requires traversal, so it is slower for long lists

Edge Cases

empty list

new node becomes the head of the list

DSA Java

if (head == null) {
    head = newNode; // empty list, new node is head
    return;
}

single element list

new node is linked after the single existing node

DSA Java

while (curr.next != null) {
    curr = curr.next; // move to last node
}

When to Use This Pattern

When you need to add an item at the end of a linked list, use tail insertion by traversing to the last node and linking the new node there.

Common Mistakes

Mistake: Not checking if the list is empty before traversal, causing null pointer errors
Fix: Add a check for empty list and set head to new node if empty

Mistake: Linking new node before reaching the last node, breaking the list
Fix: Traverse fully until curr.next is null before linking new node

Summary

Adds a new node at the end of a linked list by traversing to the last node and linking it.

Use when you want to keep the existing order and add new data at the tail.

The key is to find the last node (where next is null) before attaching the new node.

Practice

1. What does the "Insert at End" operation do in a singly linked list?

easy

A. Adds a new node at the end (tail) of the list

B. Deletes the first node of the list

C. Inserts a node at the beginning (head) of the list

D. Searches for a node with a specific value

Solution

1. Step 1: Understand the operation

   Insert at End means adding a new node after the last node of the list.

2. Step 2: Identify the effect on the list

   The new node becomes the new tail, extending the list by one node.

3. Final Answer:

   Adds a new node at the end (tail) of the list -> Option A

4. Quick Check:

   Insert at End = Add node at tail [OK]

Hint: Insert at End always adds after the last node [OK]

Common Mistakes:

• Confusing insert at end with insert at beginning
• Thinking it deletes nodes
• Assuming it searches instead of inserts

2. Which of the following is the correct Java syntax to create a new node with value 10 for a singly linked list?

easy

A. Node newNode = new Node(10);

B. Node newNode = Node(10);

C. newNode = new Node(10);

D. Node newNode = new Node(); newNode.value = 10;

Solution

1. Step 1: Recall Java object creation syntax

   In Java, new objects are created using the 'new' keyword followed by the constructor.

2. Step 2: Match syntax for node creation

   Correct syntax is: Node newNode = new Node(10); assuming Node class has a constructor taking value.

3. Final Answer:

   Node newNode = new Node(10); -> Option A

4. Quick Check:

   Use 'new' keyword and constructor for object creation [OK]

Hint: Use 'new' keyword with constructor to create objects [OK]

Common Mistakes:

• Omitting 'new' keyword
• Calling constructor without 'new'
• Not assigning to a variable

3. What will be the output linked list after executing the following code?

class Node {
  int data;
  Node next;
  Node(int d) { data = d; next = null; }
}

public class Test {
  public static void main(String[] args) {
    Node head = new Node(1);
    head.next = new Node(2);
    Node tail = head.next;
    Node newNode = new Node(3);
    tail.next = newNode;
    tail = newNode;
    printList(head);
  }
  static void printList(Node node) {
    while(node != null) {
      System.out.print(node.data + " -> ");
      node = node.next;
    }
    System.out.print("null");
  }
}

medium

A. 3 -> 1 -> 2 -> null

B. 1 -> 3 -> 2 -> null

C. 1 -> 2 -> 3 -> null

D. 1 -> 2 -> null

Solution

1. Step 1: Trace initial list creation

   head points to node 1, head.next points to node 2, tail points to node 2.

2. Step 2: Insert new node at end and update tail

   New node with data 3 is created, tail.next points to newNode, tail updated to newNode.

3. Step 3: Print list

   List nodes in order: 1 -> 2 -> 3 -> null.

4. Final Answer:

   1 -> 2 -> 3 -> null -> Option C

5. Quick Check:

   Tail insert adds node 3 at end [OK]

Hint: Tail always points to last node; new node added after tail [OK]

Common Mistakes:

• Not updating tail after insertion
• Confusing node order
• Printing incomplete list

4. Identify the error in the following code snippet for inserting a node at the end of a singly linked list:

public void insertAtEnd(int data) {
  Node newNode = new Node(data);
  if (head == null) {
    head = newNode;
  } else {
    Node temp = head;
    while (temp.next != null) {
      temp = temp.next;
    }
    temp = newNode;
  }
}

medium

A. The while loop condition should be 'temp != null'

B. The line 'temp = newNode;' does not link the new node to the list

C. The head is not updated when list is empty

D. The newNode is not created properly

Solution

1. Step 1: Analyze the while loop and insertion

   The loop finds the last node (temp.next == null). After loop, temp points to last node.

2. Step 2: Check how new node is linked

   Assigning 'temp = newNode;' only changes temp variable, not the last node's next pointer.

3. Step 3: Correct linking

   Should assign 'temp.next = newNode;' to link new node at end.

4. Final Answer:

   The line 'temp = newNode;' does not link the new node to the list -> Option B

5. Quick Check:

   Link new node by setting lastNode.next = newNode [OK]

Hint: Assign newNode to last node's next, not to temp variable [OK]

Common Mistakes:

• Assigning newNode to temp instead of temp.next
• Not updating head when list is empty
• Wrong loop condition

5. You have a singly linked list with nodes: 5 -> 10 -> 15 -> null. You want to insert a new node with value 20 at the end. Which sequence of steps correctly updates the list?

hard

A. Create new node with 20, set new node's next to null, but do not link it to list

B. Create new node with 20, set head to new node, set new node's next to old head

C. Create new node with 20, set new node's next to head, set head to new node

D. Create new node with 20, traverse to last node, set last node's next to new node

Solution

1. Step 1: Create new node with value 20

   Use constructor to create new node with data 20 and next as null.

2. Step 2: Traverse to last node

   Start from head, move through nodes until node.next is null (node with 15).

3. Step 3: Link new node at end

   Set last node's next pointer to new node, extending list to 5 -> 10 -> 15 -> 20 -> null.

4. Final Answer:

   Create new node with 20, traverse to last node, set last node's next to new node -> Option D

5. Quick Check:

   Insert at end = link new node after last node [OK]

Hint: Traverse to last node, then link new node's next as null [OK]

Common Mistakes:

• Setting head to new node incorrectly
• Not linking new node to list
• Inserting at beginning instead of end