Insert at End Tail Insert in DSA Java - Build from Scratch

Insert at End Tail Insert

📖 Scenario: Imagine you are managing a line of people waiting to buy tickets. Each person is represented as a node in a linked list. When a new person arrives, they join at the end of the line.

🎯 Goal: You will build a simple linked list and write code to insert a new node at the end (tail) of the list. Then, you will print the list to see the order of people in line.

📋 What You'll Learn

Create a linked list with three nodes containing values 10, 20, and 30

Create a variable called head pointing to the first node

Create a new node with value 40

Write code to insert the new node at the end of the linked list

Print the linked list values in order separated by ' -> ' and ending with ' -> null'

💡 Why This Matters

🌍 Real World

Linked lists are used in many applications like managing queues, undo operations in editors, and dynamic memory allocation.

💼 Career

Understanding linked list insertion is fundamental for software developers working with data structures, improving problem-solving and coding skills.

1

Create the initial linked list with three nodes

Create a class called Node with an integer data and a Node next reference. Then create three nodes with values 10, 20, and 30. Link them so that node1.next = node2 and node2.next = node3. Finally, create a variable called head that points to node1.

DSA Java

// Define Node class and create three linked nodes
// Your code here

Hint

Remember to create the Node class first, then create nodes and link them by setting the next property.

2

Create a new node to insert at the end

Create a new Node called newNode with the value 40.

DSA Java

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

public class Main {
    public static void main(String[] args) {
        Node node1 = new Node(10);
        Node node2 = new Node(20);
        Node node3 = new Node(30);
        node1.next = node2;
        node2.next = node3;
        Node head = node1;
        // Create newNode with value 40
        // Your code here
    }
}

Hint

Use the new keyword to create a new node with the value 40.

3

Insert the new node at the end of the linked list

Write code to insert newNode at the end of the linked list starting from head. Use a while loop with a variable current to find the last node (where current.next == null). Then set current.next = newNode.

DSA Java

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

public class Main {
    public static void main(String[] args) {
        Node node1 = new Node(10);
        Node node2 = new Node(20);
        Node node3 = new Node(30);
        node1.next = node2;
        node2.next = node3;
        Node head = node1;
        Node newNode = new Node(40);
        Node current = head;
        // Your code here
    }
}

Hint

Use a while loop to move current until the last node, then link the new node.

4

Print the linked list

Write code to print the linked list starting from head. Use a Node variable current to traverse the list. For each node, print current.data followed by " -> ". After the loop, print "null".

DSA Java

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

public class Main {
    public static void main(String[] args) {
        Node node1 = new Node(10);
        Node node2 = new Node(20);
        Node node3 = new Node(30);
        node1.next = node2;
        node2.next = node3;
        Node head = node1;
        Node newNode = new Node(40);
        Node current = head;
        while (current.next != null) {
            current = current.next;
        }
        current.next = newNode;
        current = head;
        // Your code here
    }
}

Hint

Use a while loop to print each node's data followed by ' -> '. After the loop, print 'null'.

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