Insert at End Tail Insert in DSA Javascript - 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 learn how to add a new node at the end (tail) of the list.

📋 What You'll Learn

Create a Node class with value and next properties

Create a LinkedList class with a head property

Add a method insertAtEnd(value) to add a node at the tail

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 playlists, undo functionality in software, and handling queues.

💼 Career

Understanding linked lists is fundamental for software developers, especially when working with dynamic data and memory management.

1

Create Node and LinkedList classes

Create a class called Node with a constructor that takes value and sets this.value and this.next to null. Then create a class called LinkedList with a constructor that sets this.head to null.

DSA Javascript

# Your code here

Hint

Think of Node as a person in line and LinkedList as the whole line.

2

Add insertAtEnd method

Inside the LinkedList class, add a method called insertAtEnd(value). This method should create a new Node with the given value. If this.head is null, set this.head to the new node. Otherwise, traverse the list to find the last node and set its next to the new node.

DSA Javascript

class Node {
    constructor(value) {
        this.value = value;
        this.next = null;
    }
}

class LinkedList {
    constructor() {
        this.head = null;
    }
    // Your code here
}

Hint

Remember to check if the list is empty before traversing.

3

Insert nodes into the list

Create a new LinkedList instance called list. Use the insertAtEnd method to add nodes with values 10, 20, and 30 in that order.

DSA Javascript

class Node {
    constructor(value) {
        this.value = value;
        this.next = null;
    }
}

class LinkedList {
    constructor() {
        this.head = null;
    }
    insertAtEnd(value) {
        const newNode = new Node(value);
        if (this.head === null) {
            this.head = newNode;
            return;
        }
        let current = this.head;
        while (current.next !== null) {
            current = current.next;
        }
        current.next = newNode;
    }
}

// Your code here

Hint

Use the insertAtEnd method three times with the exact values.

4

Print the linked list

Write a function called printList that takes the list and prints the values of the nodes in order separated by -> and ending with null. Then call printList(list).

DSA Javascript

class Node {
    constructor(value) {
        this.value = value;
        this.next = null;
    }
}

class LinkedList {
    constructor() {
        this.head = null;
    }
    insertAtEnd(value) {
        const newNode = new Node(value);
        if (this.head === null) {
            this.head = newNode;
            return;
        }
        let current = this.head;
        while (current.next !== null) {
            current = current.next;
        }
        current.next = newNode;
    }
}

const list = new LinkedList();
list.insertAtEnd(10);
list.insertAtEnd(20);
list.insertAtEnd(30);

// Your code here

Hint

Traverse from head and build a string with arrows, then print it.

Practice

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

easy

A. Adds a new node at the end of the linked list

B. Removes the first node from the linked list

C. Adds a new node at the beginning of the linked list

D. Deletes the last node from the linked list

Solution

1. Step 1: Understand the operation

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

2. Step 2: Compare with other operations

   Other options describe removing or adding at the start, which is different from tail insert.

3. Final Answer:

   Adds a new node at the end of the linked list -> Option A

4. Quick Check:

   Insert at End = Add node at tail [OK]

Hint: Tail insert always adds node after the last node [OK]

Common Mistakes:

• Confusing tail insert with head insert
• Thinking it removes nodes instead of adding
• Assuming it inserts in the middle

2. Which of the following is the correct syntax to create a new node and insert it at the end of a singly linked list in JavaScript?

easy

A. let newNode = { data: value }; newNode.next = head;

B. let newNode = { data: value, next: null }; tail.next = newNode; tail = newNode;

C. let newNode = new Node(value); newNode.next = head; head = newNode;

D. let newNode = { value: data, nextNode: null }; head.next = newNode;

Solution

1. Step 1: Identify correct node creation

   Node should have data and next properties; next set to null for tail.

2. Step 2: Insert at end

   Set current tail's next to newNode, then update tail to newNode.

3. Final Answer:

   let newNode = { data: value, next: null }; tail.next = newNode; tail = newNode; -> Option B

4. Quick Check:

   Correct node creation and tail update [OK]

Hint: Tail insert needs next=null and tail pointer update [OK]

Common Mistakes:

• Using wrong property names like nextNode
• Inserting at head instead of tail
• Not updating tail pointer

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

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

class LinkedList {
  constructor() {
    this.head = null;
    this.tail = null;
  }
  insertAtEnd(data) {
    const newNode = new Node(data);
    if (!this.head) {
      this.head = newNode;
      this.tail = newNode;
    } else {
      this.tail.next = newNode;
      this.tail = newNode;
    }
  }
}

const list = new LinkedList();
list.insertAtEnd(5);
list.insertAtEnd(10);
list.insertAtEnd(15);

let current = list.head;
let result = '';
while(current) {
  result += current.data + ' -> ';
  current = current.next;
}
result += 'null';
console.log(result);

medium

A. 5 -> 10 -> 15 -> null

B. 15 -> 10 -> 5 -> null

C. 5 -> 10 -> null

D. null

Solution

1. Step 1: Insert nodes at end

   Nodes 5, 10, 15 are inserted sequentially at the tail.

2. Step 2: Traverse and print list

   Traversal prints nodes in insertion order: 5 -> 10 -> 15 -> null.

3. Final Answer:

   5 -> 10 -> 15 -> null -> Option A

4. Quick Check:

   Tail insert preserves order [OK]

Hint: Tail insert keeps order; print from head to tail [OK]

Common Mistakes:

• Confusing head and tail order
• Missing last node in output
• Printing reversed list

4. Find the error in the following tail insert method and select the correct fix:

insertAtEnd(data) {
  const newNode = new Node(data);
  if (this.head === null) {
    this.head = newNode;
  } else {
    this.tail.next = newNode;
  }
  // Missing update of tail pointer
}

medium

A. Change 'this.head = newNode;' to 'this.tail = newNode;' in if block

B. Set 'newNode.next = this.tail;' before insertion

C. Remove the else block completely

D. Add 'this.tail = newNode;' after setting tail.next

Solution

1. Step 1: Identify missing tail update

   After inserting newNode at tail.next, tail pointer must update to newNode.

2. Step 2: Fix by adding tail update

   Add 'this.tail = newNode;' after 'this.tail.next = newNode;' to keep tail correct.

3. Final Answer:

   Add 'this.tail = newNode;' after setting tail.next -> Option D

4. Quick Check:

   Tail pointer must update after insertion [OK]

Hint: Always update tail pointer after inserting at end [OK]

Common Mistakes:

• Not updating tail pointer causes broken list
• Changing head instead of tail in else block
• Incorrectly setting newNode.next to tail

5. You have a singly linked list with nodes: 1 -> 2 -> 3 -> null and a tail pointer correctly pointing to node 3. You want to insert a new node with value 4 at the end. Which sequence of operations correctly updates the list and tail pointer?

hard

A. Create newNode(4), newNode.next = tail, tail = newNode

B. Create newNode(4), head.next = newNode, tail = newNode

C. Create newNode(4), tail.next = newNode, tail = newNode

D. Create newNode(4), tail = newNode, tail.next = null

Solution

1. Step 1: Create new node with value 4

   Initialize newNode with data=4 and next=null.

2. Step 2: Link newNode after current tail and update tail

   Set tail.next = newNode to link, then update tail = newNode to move tail pointer.

3. Final Answer:

   Create newNode(4), tail.next = newNode, tail = newNode -> Option C

4. Quick Check:

   Tail insert requires linking and tail update [OK]

Hint: Link new node after tail, then update tail pointer [OK]

Common Mistakes:

• Linking new node to head instead of tail
• Setting newNode.next to tail (wrong direction)
• Updating tail before linking new node