Delete Node at Specific Position in DSA Go

Mental Model

To remove a node at a certain place, find the node just before it and change its pointer to skip the node to delete.

Analogy: Imagine a chain of paper clips linked together. To remove one clip in the middle, you hold the clip before it and link it directly to the clip after the one you want to remove.

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

Dry Run Walkthrough

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

Goal: Remove the node at position 3 and keep the list connected

Step 1: Check if position is 1, if yes, move head to next node

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

Why: If deleting first node, just move head pointer

Step 2: Start from head and move to node at position 2 (one before target)

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

Why: We need the node before the one to delete to change its pointer

Step 3: Change curr's next pointer to skip node 3 and point to node 4

head -> 1 -> 2 -> 4 -> null

Why: By skipping node 3, it is removed from the list

Result:

head -> 1 -> 2 -> 4 -> null

Annotated Code

DSA Go

package main

import "fmt"

type Node struct {
	val  int
	next *Node
}

func deleteAtPosition(head *Node, pos int) *Node {
	if head == nil {
		return head
	}
	if pos == 1 {
		return head.next // move head to next node to delete first
	}
	curr := head
	for i := 1; i < pos-1 && curr.next != nil; i++ {
		curr = curr.next // move to node before target
	}
	if curr.next != nil {
		curr.next = curr.next.next // skip target node
	}
	return head
}

func printList(head *Node) {
	curr := head
	for curr != nil {
		fmt.Printf("%d", curr.val)
		if curr.next != nil {
			fmt.Print(" -> ")
		}
		curr = curr.next
	}
	fmt.Println(" -> null")
}

func main() {
	head := &Node{val: 1}
	head.next = &Node{val: 2}
	head.next.next = &Node{val: 3}
	head.next.next.next = &Node{val: 4}

	pos := 3
	fmt.Print("Original list: ")
	printList(head)

	head = deleteAtPosition(head, pos)

	fmt.Printf("List after deleting node at position %d: ", pos)
	printList(head)
}

if pos == 1 { return head.next // move head to next node to delete first }

handle deletion of first node by moving head pointer

for i := 1; i < pos-1 && curr.next != nil; i++ { curr = curr.next // move to node before target }

advance curr to node before the one to delete

if curr.next != nil { curr.next = curr.next.next // skip target node }

change pointer to skip the node at position

Output

Original list: 1 -> 2 -> 3 -> 4 -> null

List after deleting node at position 3: 1 -> 2 -> 4 -> null

Complexity Analysis

Time: O(n) because we may need to traverse up to n nodes to reach the position

Space: O(1) because we only use a few pointers and no extra data structures

vs Alternative: Compared to rebuilding the list or copying nodes, this pointer change is more efficient and uses less memory

Edge Cases

empty list

function returns nil without error

DSA Go

if head == nil {
	return head
}

delete first node

head moves to next node

DSA Go

if pos == 1 {
	return head.next
}

position greater than list length

list remains unchanged because no node to delete

DSA Go

if curr.next != nil {
	curr.next = curr.next.next
}

When to Use This Pattern

When asked to remove a node at a specific position in a linked list, use pointer manipulation to skip that node without rebuilding the list.

Common Mistakes

Mistake: Trying to delete a node without updating the previous node's next pointer
Fix: Always find the node before the target and update its next pointer to skip the target node

Summary

Deletes a node at a given position by changing pointers to skip it.

Use when you need to remove a node from anywhere in a linked list efficiently.

The key is to find the node before the one to delete and link it to the node after.

Practice

1. What does deleting a node at a specific position in a linked list mean?

easy

A. Adding a new node at that position

B. Removing the node at that position and linking its previous node to the next node

C. Swapping the node at that position with the last node

D. Counting the number of nodes before that position

Solution

1. Step 1: Understand node deletion in linked list

   Deleting a node means removing it and connecting the previous node to the next node to keep the list intact.

2. Step 2: Identify what happens at the specific position

   The node at the given position is removed, and the previous node's next pointer is updated to skip the deleted node.

3. Final Answer:

   Removing the node at that position and linking its previous node to the next node -> Option B

4. Quick Check:

   Delete node = remove and link neighbors [OK]

Hint: Delete means remove node and link neighbors [OK]

Common Mistakes:

• Thinking deletion adds a node
• Swapping nodes instead of deleting
• Only counting nodes without deletion

2. Which of the following Go code snippets correctly deletes a node at position pos in a singly linked list starting with head?

easy

A. curr := head; for i := 0; i <= pos; i++ { curr = curr.next }; curr.next = curr.next.next

B. head = head.next; for i := 0; i < pos; i++ { head = head.next }

C. if pos == 0 { head = head.next } else { curr := head; for i := 0; i < pos-1; i++ { curr = curr.next }; curr.next = curr.next.next }

D. for i := 0; i < pos; i++ { head = head.next }; head = head.next.next

Solution

1. Step 1: Check deletion at position 0

   If position is 0, we update head to head.next to remove the first node.

2. Step 2: Traverse to node before position and update links

   For other positions, we move to node before the target and set its next to skip the deleted node.

3. Final Answer:

   if pos == 0 { head = head.next } else { curr := head; for i := 0; i < pos-1; i++ { curr = curr.next }; curr.next = curr.next.next } -> Option C

4. Quick Check:

   Correct traversal and link update = if pos == 0 { head = head.next } else { curr := head; for i := 0; i < pos-1; i++ { curr = curr.next }; curr.next = curr.next.next } [OK]

Hint: Update previous node's next to skip deleted node [OK]

Common Mistakes:

• Not handling position 0 separately
• Looping one extra time causing nil pointer
• Incorrectly updating head inside loop

3. What is the output linked list after deleting the node at position 2 from the list: 10 -> 20 -> 30 -> 40 -> 50 -> null?

type Node struct {
  data int
  next *Node
}

// Assume head points to 10
// Delete node at position 2
func deleteAtPosition(head *Node, pos int) *Node {
  if pos == 0 {
    return head.next
  }
  curr := head
  for i := 0; i < pos-1; i++ {
    curr = curr.next
  }
  curr.next = curr.next.next
  return head
}

medium

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

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

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

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

Solution

1. Step 1: Identify node at position 2

   Position 2 node is the third node with value 30.

2. Step 2: Update links to remove node 30

   Node at position 1 (20) next pointer is updated to node at position 3 (40), skipping 30.

3. Final Answer:

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

4. Quick Check:

   Deleted 30 at pos 2 = 10->20->40->50 [OK]

Hint: Skip node at position by linking previous to next [OK]

Common Mistakes:

• Deleting wrong node index
• Not updating links correctly
• Returning wrong head pointer

4. The following Go code tries to delete a node at position pos but causes a runtime error. What is the error and how to fix it?

func deleteAtPosition(head *Node, pos int) *Node {
  curr := head
  for i := 0; i < pos; i++ {
    curr = curr.next
  }
  curr.next = curr.next.next
  return head
}

medium

A. Logic error because loop goes to pos instead of pos-1; fix loop to i < pos-1

B. Syntax error due to missing return statement; fix by adding return head

C. No error; code works fine

D. Runtime error due to nil pointer when pos is 0; fix by handling pos 0 separately

Solution

1. Step 1: Analyze loop traversal

   The loop moves curr to the node at position pos, but we need the node before pos to update links.

2. Step 2: Fix loop to stop at node before pos

   Change loop condition to i < pos-1 so curr points to previous node, allowing safe link update.

3. Final Answer:

   Logic error because loop goes to pos instead of pos-1; fix loop to i < pos-1 -> Option A

4. Quick Check:

   Loop to pos-1 for previous node [OK]

Hint: Loop to node before position, not at position [OK]

Common Mistakes:

• Looping to pos causing nil pointer
• Not handling pos 0 case
• Assuming curr.next always exists

5. Given a singly linked list with nodes: 5 -> 10 -> 15 -> 20 -> 25 -> null, write the resulting list after deleting nodes at positions 0, 2, and then 1 in that order. What is the final list?

hard

A. 10 -> 20 -> null

B. 10 -> 15 -> 25 -> null

C. 5 -> 15 -> 25 -> null

D. 10 -> 25 -> null

Solution

1. Step 1: Delete node at position 0

   Remove first node (5), list becomes 10 -> 15 -> 20 -> 25 -> null.

2. Step 2: Delete node at position 2

   Positions now: 0=10,1=15,2=20,3=25. Remove node 20, list becomes 10 -> 15 -> 25 -> null.

3. Step 3: Delete node at position 1

   Positions now: 0=10,1=15,2=25. Remove node 15, list becomes 10 -> 25 -> null.

4. Final Answer:

   10 -> 25 -> null -> Option D

5. Quick Check:

   Delete 0,2,1 in order = 10->25 [OK]

Hint: Update list after each deletion before next [OK]

Common Mistakes:

• Not updating positions after deletions
• Deleting wrong nodes due to stale positions
• Confusing zero-based indexing