Delete Node at Specific Position in DSA C++ - Build from Scratch

Delete Node at Specific Position

📖 Scenario: Imagine you have a list of tasks to do today, and you want to remove a task at a certain position from your list.

🎯 Goal: You will create a singly linked list of tasks, then delete the node at a specific position, and finally print the updated list.

📋 What You'll Learn

Create a singly linked list with exactly these tasks in order: "Wake up", "Brush teeth", "Have breakfast", "Go to work", "Exercise"

Create an integer variable called position and set it to 3

Write a function called deleteNodeAtPosition that deletes the node at the given position in the linked list

Print the linked list after deletion in the format: task1 -> task2 -> ... -> null

💡 Why This Matters

🌍 Real World

Linked lists are used in many applications like task scheduling, undo functionality, and managing playlists where items can be added or removed dynamically.

💼 Career

Understanding linked lists and node deletion is fundamental for software developers working with dynamic data structures, memory management, and system programming.

1

Create the linked list of tasks

Create a singly linked list with nodes containing these exact tasks in order: "Wake up", "Brush teeth", "Have breakfast", "Go to work", "Exercise". Use a struct called Node with a string data and a Node* next. Create a pointer head pointing to the first node.

DSA C++

// Define struct Node
// Create nodes with tasks and link them
// Set head to first node
// Your code here

Hint

Define a struct Node with a string and a pointer to next node. Create nodes one by one and link them using next.

2

Set the position to delete

Create an integer variable called position and set it to 3. This means you want to delete the third node in the list.

DSA C++

#include 
#include 
using namespace std;

struct Node {
    string data;
    Node* next;
    Node(string val) : data(val), next(nullptr) {}
};

int main() {
    Node* head = new Node("Wake up");
    head->next = new Node("Brush teeth");
    head->next->next = new Node("Have breakfast");
    head->next->next->next = new Node("Go to work");
    head->next->next->next->next = new Node("Exercise");

    // Create an integer variable called position and set it to 3
    // Your code here

    return 0;
}

Hint

Just write int position = 3; inside main().

3

Write the function to delete the node at the given position

Write a function called deleteNodeAtPosition that takes Node*& head and int position as parameters. It deletes the node at the given position (1-based index) from the linked list. Update the head if the first node is deleted. Use a for loop with int i = 1 and current pointer to reach the node before the one to delete. Handle edge cases where position is 1 or invalid.

DSA C++

#include 
#include 
using namespace std;

struct Node {
    string data;
    Node* next;
    Node(string val) : data(val), next(nullptr) {}
};

void deleteNodeAtPosition(Node*& head, int position) {
    // Write code to delete node at given position
    // Your code here
}

int main() {
    Node* head = new Node("Wake up");
    head->next = new Node("Brush teeth");
    head->next->next = new Node("Have breakfast");
    head->next->next->next = new Node("Go to work");
    head->next->next->next->next = new Node("Exercise");

    int position = 3;

    // Call deleteNodeAtPosition with head and position
    // Your code here

    return 0;
}

Hint

Check if position is 1 to delete head. Otherwise, move to node before position using a for loop, then delete the next node.

4

Print the linked list after deletion

Write a while loop to print the linked list starting from head. Print each node's data followed by " -> ". After the last node, print "null".

DSA C++

#include 
#include 
using namespace std;

struct Node {
    string data;
    Node* next;
    Node(string val) : data(val), next(nullptr) {}
};

void deleteNodeAtPosition(Node*& head, int position) {
    if (head == nullptr || position next;
        delete temp;
        return;
    }
    Node* current = head;
    for (int i = 1; i next;
    }
    if (current == nullptr || current->next == nullptr) return;
    Node* temp = current->next;
    current->next = temp->next;
    delete temp;
}

int main() {
    Node* head = new Node("Wake up");
    head->next = new Node("Brush teeth");
    head->next->next = new Node("Have breakfast");
    head->next->next->next = new Node("Go to work");
    head->next->next->next->next = new Node("Exercise");

    int position = 3;

    deleteNodeAtPosition(head, position);

    // Print the linked list
    // Your code here

    return 0;
}

Hint

Use a while loop to go through each node and print its data followed by " -> ". After the loop, print "null".

Practice

1. What happens when you delete a node at position 1 in a singly linked list?

easy

A. The head node is removed and the next node becomes the new head

B. The last node is removed

C. The list remains unchanged

D. All nodes are deleted

Solution

1. Step 1: Understand position 1 in linked list

   Position 1 refers to the head node of the list.

2. Step 2: Delete the head node

   Removing the head means the next node becomes the new head.

3. Final Answer:

   The head node is removed and the next node becomes the new head -> Option A

4. Quick Check:

   Deleting position 1 removes the head [OK]

Hint: Deleting position 1 means removing the head node [OK]

Common Mistakes:

• Thinking position 1 deletes the last node
• Assuming list stays same after deletion
• Deleting all nodes instead of one

2. Which of the following is the correct syntax to delete a node at position pos in a singly linked list in C++?

easy

A. head = head->prev;

B. if (pos == 1) { head = head->next; }

C. delete head->next->prev;

D. head->next = NULL;

Solution

1. Step 1: Check deletion at position 1

   If position is 1, we update head to head->next to remove the first node.

2. Step 2: Verify syntax correctness

   if (pos == 1) { head = head->next; } correctly updates head pointer; others are invalid or incorrect for singly linked list.

3. Final Answer:

   if (pos == 1) { head = head->next; } -> Option B

4. Quick Check:

   Update head for position 1 deletion [OK]

Hint: For position 1, assign head = head->next [OK]

Common Mistakes:

• Using prev pointer in singly linked list
• Setting next pointer to NULL incorrectly
• Deleting wrong node pointer

3. What is the output linked list after deleting the node at position 3 from the list: 1 -> 2 -> 3 -> 4 -> 5 -> NULL?

medium

A. 2 -> 3 -> 4 -> 5 -> NULL

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

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

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

Solution

1. Step 1: Identify node at position 3

   Node at position 3 is the node with value 3.

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

   Link node 2's next to node 4, skipping node 3.

3. Final Answer:

   1 -> 2 -> 4 -> 5 -> NULL -> Option D

4. Quick Check:

   Node 3 removed, list links 2 to 4 [OK]

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

Common Mistakes:

• Removing wrong node
• Not updating previous node's next pointer
• Deleting head instead of position 3

4. Given the code snippet below, what is the error when deleting a node at position 4?

void deleteNode(Node*& head, int pos) {
  Node* temp = head;
  for (int i = 1; i < pos - 1; i++) {
    temp = temp->next;
  }
  Node* toDelete = temp->next;
  temp->next = toDelete->next;
  delete toDelete;
}

medium

A. No check if position is valid or if temp is NULL

B. Incorrect loop range causing off-by-one error

C. Deleting head node incorrectly

D. Using delete on a pointer not allocated with new

Solution

1. Step 1: Analyze loop and pointer usage

   The loop moves temp to node before position to delete, but no checks if temp or temp->next is NULL.

2. Step 2: Identify missing validation

   Without checking if position is valid or temp is NULL, code may crash on invalid positions.

3. Final Answer:

   No check if position is valid or if temp is NULL -> Option A

4. Quick Check:

   Missing boundary checks cause runtime errors [OK]

Hint: Always check pointers before accessing next [OK]

Common Mistakes:

• Ignoring invalid position inputs
• Assuming list length is sufficient
• Not checking for NULL pointers

5. You have a singly linked list: 10 -> 20 -> 30 -> 40 -> 50 -> NULL. Write the resulting list after deleting the node at position 5 and then deleting the node at position 1.

hard

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

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

C. 20 -> 30 -> 40 -> NULL

D. 10 -> 20 -> 30 -> NULL

Solution

1. Step 1: Delete node at position 5

   Node at position 5 is 50, removing it results in list: 10 -> 20 -> 30 -> 40 -> NULL.

2. Step 2: Delete node at position 1

   Deleting head node 10 updates head to 20, final list: 20 -> 30 -> 40 -> NULL.

3. Final Answer:

   20 -> 30 -> 40 -> NULL -> Option C

4. Quick Check:

   Delete last then head node sequentially [OK]

Hint: Delete last node first, then head node for correct order [OK]

Common Mistakes:

• Deleting head first then last causing wrong list
• Not updating head after deleting position 1
• Forgetting to remove last node