Remove Nth Node from End of List in DSA Python - Build from Scratch

Remove Nth Node from End of List

📖 Scenario: You are managing a queue of customers waiting in line at a store. Sometimes, a customer leaves the line from the end, not just the front. You want to remove the nth customer from the end of the line.

🎯 Goal: Build a program that removes the nth node from the end of a singly linked list and prints the updated list.

📋 What You'll Learn

Create a singly linked list with exact values: 10, 20, 30, 40, 50

Create a variable n to specify which node from the end to remove

Implement the logic to remove the nth node from the end of the list

Print the linked list after removal in the format: 10 -> 20 -> 30 -> 50 -> null

💡 Why This Matters

🌍 Real World

Removing the nth node from the end of a list is useful in managing queues, undo histories, or any ordered data where you need to remove elements relative to the end.

💼 Career

This technique is commonly asked in coding interviews and is important for understanding linked list manipulation and pointer techniques.

1

Create the linked list

Create a singly linked list with nodes containing these exact values in order: 10, 20, 30, 40, 50. Use the class ListNode provided below and create a variable called head pointing to the first node.

DSA Python

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

# Create linked list nodes and connect them
# Your code here

Hint

Start by creating the first node with value 10 and assign it to head. Then link each next node with the given values.

2

Set the position to remove

Create a variable called n and set it to 2. This means you want to remove the 2nd node from the end of the list.

DSA Python

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

head = ListNode(10)
head.next = ListNode(20)
head.next.next = ListNode(30)
head.next.next.next = ListNode(40)
head.next.next.next.next = ListNode(50)

# Set n to 2
# Your code here

Hint

Just create a variable n and assign it the value 2.

3

Remove the nth node from the end

Write code to remove the nth node from the end of the linked list starting at head. Use two pointers called fast and slow. Move fast ahead by n nodes first, then move both pointers until fast reaches the end. Remove the node after slow. Handle the case when the node to remove is the head.

DSA Python

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

head = ListNode(10)
head.next = ListNode(20)
head.next.next = ListNode(30)
head.next.next.next = ListNode(40)
head.next.next.next.next = ListNode(50)

n = 2

# Remove the nth node from the end
# Your code here

Hint

Use a dummy node before head to handle edge cases. Move fast pointer n steps ahead, then move both fast and slow until fast reaches the last node. Then remove the node after slow.

4

Print the updated linked list

Print the linked list starting from head in the format: 10 -> 20 -> 30 -> 50 -> null. Use a loop to traverse the list and print each node's value followed by ->. End with null.

DSA Python

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

head = ListNode(10)
head.next = ListNode(20)
head.next.next = ListNode(30)
head.next.next.next = ListNode(40)
head.next.next.next.next = ListNode(50)

n = 2

dummy = ListNode(0, head)
fast = dummy
slow = dummy

for _ in range(n):
    fast = fast.next

while fast.next:
    fast = fast.next
    slow = slow.next

slow.next = slow.next.next

head = dummy.next

# Print the linked list
# Your code here

Hint

Use a while loop to go through each node starting from head. Print the value and -> until the end. Then print null.

Practice

1. What does the problem Remove Nth Node from End of List ask you to do?

easy

A. Add a new node at the Nth position from the start

B. Find the value of the Nth node from the start

C. Reverse the linked list up to the Nth node

D. Delete the node that is the Nth from the end in a linked list

Solution

1. Step 1: Understand the problem statement

   The problem requires removing a node counting from the end of the linked list, not from the start.

2. Step 2: Identify the correct action

   Deleting the Nth node from the end means locating it and removing it from the list.

3. Final Answer:

   Delete the node that is the Nth from the end in a linked list -> Option D

4. Quick Check:

   Remove Nth node from end = Delete node Nth from end [OK]

Hint: Focus on 'from end' means counting backwards [OK]

Common Mistakes:

• Confusing Nth from start with Nth from end
• Thinking the problem is about reversing the list
• Trying to add nodes instead of removing

2. Which of the following is the correct Python syntax to create a dummy node pointing to the head of a linked list named head?

easy

A. dummy = head.next

B. dummy = ListNode(head)

C. dummy = ListNode(0); dummy.next = head

D. dummy = ListNode(); dummy = head

Solution

1. Step 1: Understand dummy node creation

   A dummy node is usually created with a value (often 0) and its next pointer set to the head.

2. Step 2: Check each option

   dummy = ListNode(0); dummy.next = head correctly creates a dummy node with value 0 and points its next to head.

3. Final Answer:

   dummy = ListNode(0); dummy.next = head -> Option C

4. Quick Check:

   Dummy node points to head = dummy.next = head [OK]

Hint: Dummy node value 0 and next points to head [OK]

Common Mistakes:

• Passing head as value instead of next pointer
• Overwriting dummy after creation
• Not linking dummy to head

3. What will be the output linked list after removing the 2nd node from the end in the list 1 -> 2 -> 3 -> 4 -> 5 -> null?

medium

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

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

C. 1 -> 3 -> 4 -> 5 -> null

D. 1 -> 2 -> 4 -> 5 -> null

Solution

1. Step 1: Identify the 2nd node from the end

   Counting from the end: 5 (1st), 4 (2nd). So node with value 4 is to be removed.

2. Step 2: Remove node 4 and link previous node to next

   Node 3's next pointer should now point to node 5, skipping node 4.

3. Final Answer:

   1 -> 2 -> 3 -> 5 -> null -> Option A

4. Quick Check:

   Remove 2nd from end (4) = 1->2->3->5 [OK]

Hint: Count nodes from end, remove that node [OK]

Common Mistakes:

• Removing the wrong node counting from start
• Not updating the previous node's next pointer
• Confusing node values

4. Given this code snippet to remove the Nth node from end, what is the error?

def removeNthFromEnd(head, n):
    dummy = ListNode(0)
    dummy.next = head
    first = dummy
    second = dummy
    for i in range(n):
        first = first.next
    while first.next:
        first = first.next
        second = second.next
    second.next = second.next.next
    return dummy.next

medium

A. The for loop should run n+1 times to move first pointer

B. The while loop condition should be while first is not None

C. second.next = second.next.next causes error if second.next is None

D. dummy node is not needed for this problem

Solution

1. Step 1: Analyze the for loop moving first pointer

   To position first pointer n nodes ahead, it must move n+1 times to maintain gap with second pointer.

2. Step 2: Understand the impact of moving first pointer only n times

   If first moves only n times, the gap is off by one, causing wrong node removal.

3. Final Answer:

   The for loop should run n+1 times to move first pointer -> Option A

4. Quick Check:

   Move first pointer n+1 times for correct gap [OK]

Hint: Move first pointer n+1 times to keep gap [OK]

Common Mistakes:

• Moving first pointer only n times
• Incorrect while loop condition
• Ignoring dummy node usage

5. You have a linked list 1 -> 2 -> 3 -> 4 -> 5 -> null. If you remove the 5th node from the end, what will be the resulting list?

hard

A. 1 -> 3 -> 4 -> 5 -> null

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

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

D. 5 -> null

Solution

1. Step 1: Identify the 5th node from the end

   The list length is 5, so the 5th node from the end is the first node with value 1.

2. Step 2: Remove the first node and link dummy to second node

   Removing node 1 means the new head is node 2, so list becomes 2 -> 3 -> 4 -> 5 -> null.

3. Final Answer:

   2 -> 3 -> 4 -> 5 -> null -> Option B

4. Quick Check:

   Remove 5th from end (head) = 2->3->4->5 [OK]

Hint: Removing Nth from end where N equals list length removes head [OK]

Common Mistakes:

• Removing last node instead of first
• Not updating head pointer after removal
• Confusing node positions