Insert at End Tail Insert in DSA Java - Execution Trace

Concept Flow - Insert at End Tail Insert

Create new node with data

↓

Is list empty?

↓

Set head = new

↓

Traverse until current.next == null

↓

Set current.next = new node

↓

Done

This flow shows how to add a new node at the end of a linked list by checking if the list is empty, then either setting head or traversing to the last node and linking the new node.

Execution Sample

DSA Java

Node newNode = new Node(40);
if (head == null) {
  head = newNode;
} else {
  Node current = head;
  while (current.next != null) current = current.next;
  current.next = newNode;
}

This code inserts a new node with value 40 at the end of the linked list.

Execution Table

Step	Operation	Nodes in List	Pointer Changes	Visual State
1	Create new node with data=40	10 -> 20 -> 30 -> null	newNode points to node(40)	┌────────┐ ┌────────┐ ┌────────┐ │ data:10│ │ data:20│ │ data:30│ │ next:──┼──→ │ next:──┼──→ │ next:∅ │ └────────┘ └────────┘ └────────┘ head
2	Check if head == null	10 -> 20 -> 30 -> null	head not null, no change	Same as step 1
3	Set current = head	10 -> 20 -> 30 -> null	current points to node(10)	Same as step 1, current at head
4	Traverse current.next != null? (current=10)	10 -> 20 -> 30 -> null	current moves to node(20)	┌────────┐ ┌────────┐ ┌────────┐ │ data:10│ │ data:20│ │ data:30│ │ next:──┼──→ │ next:──┼──→ │ next:∅ │ └────────┘ └────────┘ └────────┘ head current
5	Traverse current.next != null? (current=20)	10 -> 20 -> 30 -> null	current moves to node(30)	┌────────┐ ┌────────┐ ┌────────┐ │ data:10│ │ data:20│ │ data:30│ │ next:──┼──→ │ next:──┼──→ │ next:∅ │ └────────┘ └────────┘ └────────┘ head current
6	Traverse current.next != null? (current=30)	10 -> 20 -> 30 -> null	current.next == null, stop traversal	Same as step 5
7	Set current.next = newNode	10 -> 20 -> 30 -> 40 -> null	node(30).next points to node(40)	┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐ │ data:10│ │ data:20│ │ data:30│ │ data:40│ │ next:──┼──→ │ next:──┼──→ │ next:──┼──→ │ next:∅ │ └────────┘ └────────┘ └────────┘ └────────┘ head
8	Done	10 -> 20 -> 30 -> 40 -> null	No pointer changes	Same as step 7

💡 Traversal stops when current.next is null at node with data 30, then new node is linked.

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 5	After Step 6	After Step 7	Final
head	node(10)	node(10)	node(10)	node(10)	node(10)	node(10)	node(10)
current	null	node(10)	node(20)	node(30)	node(30)	node(30)	node(30)
newNode	node(40)	node(40)	node(40)	node(40)	node(40)	node(40)	node(40)

Key Moments - 3 Insights

Why do we check current.next != null instead of current != null in the traversal?

Because we want to stop at the last node, not after it. current.next == null means current is the last node where we can insert the new node. See steps 5 and 6 in execution_table.

What happens if the list is empty (head == null)?

We set head to the new node directly, making it the first and only node. This is shown in the concept_flow and step 2 where head is checked.

How does the pointer change when inserting the new node?

The last node's next pointer changes from null to point to the new node, linking it at the end. See step 7 in execution_table.

Visual Quiz - 3 Questions

Look at the execution_table at step 5, where is the current pointer?

A At node with data 20

B At node with data 30

C At node with data 40

D At head node with data 10

💡 Hint

Check the 'Pointer Changes' and 'Visual State' columns at step 5.

At which step does the traversal stop because current.next is null?

A Step 6

B Step 5

C Step 4

D Step 7

💡 Hint

Look for the step where traversal condition fails in the 'Operation' column.

If the list was empty initially, what would be the pointer change after insertion?

A newNode.next points to head

B current points to newNode

C head points to newNode

D No pointer changes

💡 Hint

Refer to the concept_flow and step 2 about empty list handling.

Concept Snapshot

Insert at End (Tail Insert) in Linked List:
- Create new node with data
- If list empty (head == null), set head = new node
- Else traverse from head until current.next == null
- Set current.next = new node
- New node becomes the last node with next = null

Full Transcript

To insert a node at the end of a linked list, first create the new node. Check if the list is empty by seeing if head is null. If empty, set head to the new node. Otherwise, start from head and move current pointer forward until current.next is null, meaning current is the last node. Then link the new node by setting current.next to the new node. This adds the new node at the tail. The traversal stops when current.next is null, not when current is null, to ensure we link correctly. If the list is empty, the new node becomes the head directly.

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