Delete Node at End in DSA Typescript

Mental Model

To remove the last item in a chain, find the second last item and make it the new end by cutting off the last one.

Analogy: Imagine a line of people holding hands. To remove the last person, the second last person lets go of their hand, so the last person is no longer connected.

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

Dry Run Walkthrough

Input: list: 1 -> 2 -> 3 -> null, delete node at end

Goal: Remove the last node so the list ends at node with value 2

Step 1: start at head node (1)

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

Why: We begin from the start to find the node before the last

Step 2: move to next node (2)

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

Why: We keep moving until we reach the node before the last

Step 3: check next node's next pointer; it's null, so current node (2) is second last

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

Why: We found the node before the last node

Step 4: set current node's next pointer to null, removing last node (3)

head -> 1 -> 2 -> null

Why: Disconnect last node to delete it

Result:

head -> 1 -> 2 -> null

Annotated Code

DSA Typescript

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

class LinkedList {
  head: Node | null;
  constructor() {
    this.head = null;
  }

  append(value: number): void {
    const newNode = new Node(value);
    if (!this.head) {
      this.head = newNode;
      return;
    }
    let curr = this.head;
    while (curr.next) {
      curr = curr.next;
    }
    curr.next = newNode;
  }

  deleteAtEnd(): void {
    if (!this.head) return; // empty list
    if (!this.head.next) {
      this.head = null; // single node list
      return;
    }
    let curr = this.head;
    while (curr.next && curr.next.next) {
      curr = curr.next; // advance to second last node
    }
    curr.next = null; // remove last node
  }

  printList(): void {
    let curr = this.head;
    let result = '';
    while (curr) {
      result += curr.value + ' -> ';
      curr = curr.next;
    }
    result += 'null';
    console.log(result);
  }
}

// Driver code
const list = new LinkedList();
list.append(1);
list.append(2);
list.append(3);
list.printList();
list.deleteAtEnd();
list.printList();

if (!this.head) return; // empty list

handle empty list by returning early

if (!this.head.next) { this.head = null; // single node list return; }

handle single node list by setting head to null

while (curr.next && curr.next.next) { curr = curr.next; // advance to second last node }

move curr to second last node by checking next two nodes

curr.next = null; // remove last node

disconnect last node by setting next to null

Output

1 -> 2 -> 3 -> null

1 -> 2 -> null

Complexity Analysis

Time: O(n) because we traverse the list once to find the second last node

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

vs Alternative: Compared to removing from the front which is O(1), deleting at end requires traversal making it O(n)

Edge Cases

empty list

function returns immediately without error

DSA Typescript

if (!this.head) return; // empty list

single node list

head is set to null, resulting in empty list

DSA Typescript

if (!this.head.next) {
  this.head = null; // single node list
  return;
}

When to Use This Pattern

When you need to remove the last item in a linked list, use the delete at end pattern by finding the second last node and cutting off the last.

Common Mistakes

Mistake: Not handling empty or single node lists causing errors
Fix: Add checks for empty list and single node list before traversal

Mistake: Stopping traversal too early or too late, causing wrong node removal
Fix: Traverse until current node's next's next is null to find second last node

Summary

Deletes the last node from a singly linked list.

Use when you want to remove the tail node of a linked list.

The key is to find the second last node and set its next pointer to null.

Practice

1. What does the operation Delete Node at End do in a singly linked list?

easy

A. Adds a new node at the beginning of the list

B. Removes the first node from the list

C. Removes the last node from the list

D. Adds a new node at the end of the list

Solution

1. Step 1: Understand the operation

   Deleting a node at the end means removing the last node in the linked list.

2. Step 2: Identify the effect on the list

   After removal, the second last node becomes the new last node.

3. Final Answer:

   Removes the last node from the list -> Option C

4. Quick Check:

   Delete Node at End = Remove last node [OK]

Hint: Delete last node means remove tail node [OK]

Common Mistakes:

• Confusing delete at end with delete at start
• Thinking it adds a node instead of removing
• Assuming it deletes a middle node

2. Which of the following TypeScript code snippets correctly deletes the last node of a singly linked list named head?

easy

A. if (!head) return null;
head = head.next;

B. if (!head) return null;
let temp = head;
while (temp.next && temp.next.next) {
temp = temp.next;
}
temp.next = null;

C. let temp = head;
while (temp.next) {
temp = temp.next;
}
temp = null;

D. head = null;

Solution

1. Step 1: Analyze code for deleting last node

   if (!head) return null; let temp = head; while (temp.next && temp.next.next) { temp = temp.next; } temp.next = null; traverses to the second last node and sets its next to null, removing the last node.

2. Step 2: Check other options

   if (!head) return null; head = head.next; deletes the first node, C tries to set temp to null but does not affect list, D deletes entire list.

3. Final Answer:

   Traverse to second last node, set next to null -> Option B

4. Quick Check:

   Traverse to second last node, set next to null = A [OK]

Hint: Stop at second last node, set next to null [OK]

Common Mistakes:

• Setting temp to null does not remove node from list
• Deleting head instead of last node
• Not checking for empty or single-node list

3. Given the linked list: 1 -> 2 -> 3 -> 4 -> null, what will be the list after deleting the node at the end using this code?

function deleteAtEnd(head: Node | null): Node | null {
  if (!head) return null;
  if (!head.next) return null;
  let temp = head;
  while (temp.next && temp.next.next) {
    temp = temp.next;
  }
  temp.next = null;
  return head;
}

medium

A. 2 -> 3 -> 4 -> null

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

C. null

D. 1 -> 2 -> 3 -> null

Solution

1. Step 1: Understand the code logic

   The code removes the last node by stopping at second last node and setting its next to null.

2. Step 2: Apply to given list

   Original list ends with 4. After deletion, 3's next becomes null, so list is 1 -> 2 -> 3 -> null.

3. Final Answer:

   1 -> 2 -> 3 -> null -> Option D

4. Quick Check:

   Last node removed, list ends at 3 [OK]

Hint: Last node removed, second last points to null [OK]

Common Mistakes:

• Not updating second last node's next to null
• Returning null for multi-node list
• Deleting first node instead of last

4. Identify the bug in this TypeScript function that deletes the last node of a singly linked list:

function deleteAtEnd(head: Node | null): Node | null {
  if (!head) return null;
  let temp = head;
  while (temp.next) {
    temp = temp.next;
  }
  temp = null;
  return head;
}

medium

A. It does not update the second last node's next pointer

B. It does not handle empty list

C. It deletes the head node instead of last

D. It causes infinite loop

Solution

1. Step 1: Analyze the loop

   The loop moves temp to the last node, but does not track second last node.

2. Step 2: Check deletion step

   Setting temp = null only changes local variable, does not remove last node from list.

3. Final Answer:

   It does not update the second last node's next pointer -> Option A

4. Quick Check:

   Must update second last node's next to null [OK]

Hint: Update second last node's next to null, not temp variable [OK]

Common Mistakes:

• Setting temp to null does not remove node
• Not tracking second last node in loop
• Ignoring single-node list case

5. You have a singly linked list with nodes: 10 -> 20 -> 30 -> 40 -> null. Write a TypeScript function to delete the last node and return the updated list. Which of the following implementations correctly handles the edge case when the list has only one node?

hard

A. function deleteAtEnd(head: Node | null): Node | null {
if (!head) return null;
if (!head.next) return null;
let temp = head;
while (temp.next && temp.next.next) {
temp = temp.next;
}
temp.next = null;
return head;
}

B. function deleteAtEnd(head: Node | null): Node | null {
if (!head) return null;
let temp = head;
while (temp.next) {
temp = temp.next;
}
temp = null;
return head;
}

C. function deleteAtEnd(head: Node | null): Node | null {
if (!head) return null;
if (!head.next) return head;
let temp = head;
while (temp.next && temp.next.next) {
temp = temp.next;
}
temp.next = null;
return head;
}

D. function deleteAtEnd(head: Node | null): Node | null {
if (!head) return null;
if (!head.next) return head;
let temp = head;
while (temp.next) {
temp = temp.next;
}
temp.next = null;
return head;
}

Solution

1. Step 1: Check handling of single-node list

   function deleteAtEnd(head: Node | null): Node | null { if (!head) return null; if (!head.next) return null; let temp = head; while (temp.next && temp.next.next) { temp = temp.next; } temp.next = null; return head; } returns null if only one node exists, correctly deleting it.

2. Step 2: Verify deletion of last node for longer lists

   For longer lists, it traverses to the second last node using while (temp.next && temp.next.next) and sets temp.next = null, correctly removing the last node.

3. Final Answer:

   Correctly handles single-node by returning null -> Option A

4. Quick Check:

   Return null for single node, else remove last node [OK]

Hint: Return null if single node, else remove last node [OK]

Common Mistakes:

• Not returning null for single-node list
• Setting temp to null instead of updating next pointer
• Incorrect loop condition causing errors