Remove Nth Node from End of List in DSA Go - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output after removing 2nd node from end

What is the output linked list after removing the 2nd node from the end in the given list?

DSA Go

type ListNode struct {
    Val  int
    Next *ListNode
}

func removeNthFromEnd(head *ListNode, n int) *ListNode {
    dummy := &ListNode{0, head}
    first, second := dummy, dummy
    for i := 0; i <= n; i++ {
        first = first.Next
    }
    for first != nil {
        first = first.Next
        second = second.Next
    }
    second.Next = second.Next.Next
    return dummy.Next
}

// Initial list: 1 -> 2 -> 3 -> 4 -> 5 -> null
// Remove 2nd from end
// Print resulting list

A 1 -> 2 -> 4 -> 5 -> null

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

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

D 1 -> 2 -> 3 -> 5 -> null

💡 Hint

Think about how the two pointers move to find the node before the one to remove.

The function uses two pointers with a gap of n nodes. When the first pointer reaches the end, the second pointer is just before the node to remove. Removing the 2nd node from the end (which is 4) results in the list: 1 -> 2 -> 3 -> 5 -> null.

❓ Predict Output

intermediate

Output after removing 1st node from end

What is the output linked list after removing the last node (1st from end) in the list?

DSA Go

type ListNode struct {
    Val  int
    Next *ListNode
}

func removeNthFromEnd(head *ListNode, n int) *ListNode {
    dummy := &ListNode{0, head}
    first, second := dummy, dummy
    for i := 0; i <= n; i++ {
        first = first.Next
    }
    for first != nil {
        first = first.Next
        second = second.Next
    }
    second.Next = second.Next.Next
    return dummy.Next
}

// Initial list: 10 -> 20 -> 30 -> null
// Remove 1st from end
// Print resulting list

A 10 -> 30 -> null

B 10 -> 20 -> null

C 20 -> 30 -> null

D 10 -> 20 -> 30 -> null

💡 Hint

Removing the last node means the node with value 30 is removed.

The last node (value 30) is removed, so the list becomes 10 -> 20 -> null.

🔧 Debug

advanced

Identify the error in the removeNthFromEnd function

What error will occur when running this code if the input list has length 3 and n=4?

DSA Go

func removeNthFromEnd(head *ListNode, n int) *ListNode {
    dummy := &ListNode{0, head}
    first, second := dummy, dummy
    for i := 0; i <= n; i++ {
        first = first.Next
    }
    for first != nil {
        first = first.Next
        second = second.Next
    }
    second.Next = second.Next.Next
    return dummy.Next
}

A runtime error: invalid memory address or nil pointer dereference

B compilation error: undefined variable first

C runtime error: index out of range

D no error, returns correct list

💡 Hint

Check what happens when first pointer moves beyond the list length.

If n is greater than the length of the list, the loop moving the first pointer will cause first to become nil and then accessing first.Next causes a nil pointer dereference runtime error.

🧠 Conceptual

advanced

Why use a dummy node in removeNthFromEnd?

What is the main reason to use a dummy node at the start of the list in the removeNthFromEnd function?

A To avoid using recursion in the function

B To reduce the time complexity from O(n^2) to O(n)

C To handle the case when the head node itself needs to be removed

D To store the length of the list for later use

💡 Hint

Think about what happens if the first node is removed.

The dummy node helps handle edge cases where the node to remove is the head node. It provides a stable previous node to update the next pointer.

🚀 Application

expert

Resulting list after multiple removals

Given the list 5 -> 10 -> 15 -> 20 -> 25 -> null, what is the list after removing the 3rd node from the end twice in a row?

DSA Go

type ListNode struct {
    Val  int
    Next *ListNode
}

func removeNthFromEnd(head *ListNode, n int) *ListNode {
    dummy := &ListNode{0, head}
    first, second := dummy, dummy
    for i := 0; i <= n; i++ {
        first = first.Next
    }
    for first != nil {
        first = first.Next
        second = second.Next
    }
    second.Next = second.Next.Next
    return dummy.Next
}

// Initial list: 5 -> 10 -> 15 -> 20 -> 25 -> null
// Remove 3rd from end twice
// Print resulting list

A 5 -> 20 -> 25 -> null

B 5 -> 10 -> 20 -> 25 -> null

C 10 -> 15 -> 20 -> 25 -> null

D 5 -> 15 -> 25 -> null

💡 Hint

Remove the 3rd node from end once, then again on the new list.

First removal removes node with value 15 (3rd from end). List becomes 5 -> 10 -> 20 -> 25.
Second removal removes node with value 10 (3rd from end in new list). Final list: 5 -> 20 -> 25.

Practice

1. What does the problem "Remove Nth Node from End of List" ask you to do with a linked list?

easy

A. Reverse the linked list

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

C. Remove the node that is the Nth from the end of the list

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

Solution

1. Step 1: Understand the problem statement

   The problem requires removing the node that is Nth from the end, not from the start or adding nodes.

2. Step 2: Clarify the operation on the linked list

   We must delete the node counting from the end, which is different from reversing or finding a value.

3. Final Answer:

   Remove the node that is the Nth from the end of the list -> Option C

4. Quick Check:

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

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

Common Mistakes:

• Confusing Nth from end with Nth from start
• Thinking the problem asks to add nodes
• Assuming the list should be reversed

2. Which of the following Go code snippets correctly declares a singly linked list node struct for this problem?

easy

A. type ListNode struct { Val int; Next *ListNode }

B. type ListNode struct { Value int; NextNode *ListNode }

C. struct ListNode { int Val; ListNode* Next; }

D. class ListNode { int Val; ListNode Next; }

Solution

1. Step 1: Identify Go struct syntax

   In Go, structs use 'type Name struct { fields }' and pointers use '*Type'.

2. Step 2: Match correct field names and types

   type ListNode struct { Val int; Next *ListNode } uses 'Val int' and 'Next *ListNode' which is the standard for singly linked list nodes in Go.

3. Final Answer:

   type ListNode struct { Val int; Next *ListNode } -> Option A

4. Quick Check:

   Go struct with pointer field = type ListNode struct { Val int; Next *ListNode } [OK]

Hint: Go structs use 'type' and pointers with '*' [OK]

Common Mistakes:

• Using C/C++ or Java syntax in Go code
• Missing pointer '*' for Next field
• Incorrect field names or types

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

medium

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

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

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

D. 2 -> 3 -> 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 with value 4 and link previous node to next

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

3. Final Answer:

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

4. Quick Check:

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

Hint: Count nodes from end to find which to remove [OK]

Common Mistakes:

• Removing the wrong node counting from start
• Breaking links incorrectly causing list corruption
• Off-by-one errors in counting nodes

4. Given this Go function snippet to remove the Nth node from end, what is the bug?

func removeNthFromEnd(head *ListNode, n int) *ListNode {
    dummy := &ListNode{0, head}
    first, second := dummy, dummy
    for i := 0; i < n; i++ {
        first = first.Next
    }
    for first.Next != nil {
        first = first.Next
        second = second.Next
    }
    second.Next = second.Next.Next
    return head
}

medium

A. Missing check for empty list before loops

B. The loop runs n times instead of n+1 times

C. second pointer is not initialized correctly

D. Returns head instead of dummy.Next, so removal of first node fails

Solution

1. Step 1: Understand dummy node usage

   Dummy node helps handle edge cases like removing the first node. The result list starts at dummy.Next.

2. Step 2: Check return statement

   Returning 'head' ignores changes if first node was removed. Should return dummy.Next instead.

3. Final Answer:

   Returns head instead of dummy.Next, so removal of first node fails -> Option D

4. Quick Check:

   Return dummy.Next to handle first node removal [OK]

Hint: Always return dummy.Next after removal [OK]

Common Mistakes:

• Returning original head ignoring dummy node
• Not using dummy node for edge cases
• Incorrect loop bounds causing panic

5. You have a linked list: 10 -> 20 -> 30 -> 40 -> 50 -> null. You want to remove the 5th node from the end. What will be the resulting list?

hard

A. 20 -> 30 -> 40 -> 50 -> null

B. 10 -> 20 -> 30 -> 40 -> null

C. 10 -> 20 -> 30 -> 40 -> 50 -> null

D. 30 -> 40 -> 50 -> null

Solution

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

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

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

   Removing node 10 means the new head is node 20, so list becomes 20 -> 30 -> 40 -> 50 -> null.

3. Final Answer:

   20 -> 30 -> 40 -> 50 -> null -> Option A

4. Quick Check:

   Remove 5th from end (first node) = 20->30->40->50 [OK]

Hint: Nth from end equals list length means remove head [OK]

Common Mistakes:

• Removing wrong node when N equals list length
• Not updating head pointer after removal
• Confusing node positions counting from start vs end