Delete a Linked List node at a given position (original) (raw)

Last Updated : 24 Sep, 2024

Given a singly linked list and a position (1-based indexing), the task is to delete a linked list node at the given position.

**Note: Position will be valid (i.e, 1 <= position <= linked list length)

**Example:

**Input: position = 2, Linked List = 8->2->3->1->7
**Output: Linked List = 8->3->1->7

**Input: position = 1, Linked List = 8->2->3->1->7
**Output: Linked List = 2->3->1->7

**Approach:

Deletion at a specified position in a linked list involves removing a node from a specific index/position, which can be the first, middle, or last node.

To perform the deletion, If the position is 1, we update the **head to point to the **next node and delete the current head. For other positions, we traverse the list to reach the node just before the specified **position. If the target node exists, we adjust the next of this previous node to point to next of **next nodes, which will result in skipping the target node.

Deletion-specific-At-End--

Delete a Linked List node at a given position

Step-by-step approach:

If list is empty (**head == **NULL), returns the **head.
If the **position to delete is **1 (the head node):
- Update head = temp->next
Traverse the list until reaching the desired position:
- Initialize **prev to keep track of the previous node.
- Move **temp through the list until the position is reached.
Check for Valid Position:
- If **temp becomes **NULL, it means the position exceeds the number of nodes in the list. Print a message and return the **head.
If the node to delete is found:
- Set **prev->next to **temp->next, effectively skipping over the node to be deleted.

**Code Implementation:

C++14 `

// C++ program to delete a linked list node at a given // position #include using namespace std;

// Node structure for the linked list struct Node { int data; Node* next; Node(int data) : data(data) , next(nullptr) { } };

// Function to delete a node at a given position Node* deleteNode(Node* head, int position) { // previous of node to be deleted Node* prev; Node* temp = head;

// Base case if linked list is empty
if (temp == NULL)
    return head;

// Case 1: Head is to be deleted
if (position == 1) {
    // make next node as head and free old head
    head = temp->next;
    free(temp);
    return head;
}

// Case 2: Node to be deleted is in middle
// Traverse till given position
for (int i = 1; i != position; i++) {
    prev = temp;
    temp = temp->next;
}

// If given position is found, delete node
if (temp != NULL) {
    prev->next = temp->next;
    free(temp);
}
// If given position is not present
else {
    cout << "Data not present\n";
}

return head;

}

void printList(Node* head) { while (head != nullptr) { cout << head->data << " -> "; head = head->next; } cout << "nullptr" << endl; }

// Driver code int main() { // Creating a static linked list // 1 -> 2 -> 3 -> 4 -> 5 -> nullptr Node* head = new Node(1); head->next = new Node(2); head->next->next = new Node(3); head->next->next->next = new Node(4); head->next->next->next->next = new Node(5);

cout << "Original list: ";
printList(head);

// Deleting node at position 2
int position = 2;
head = deleteNode(head, position);

cout << "List after deletion : ";
printList(head);

// Cleanup remaining nodes
while (head != nullptr) {
    Node* temp = head;
    head = head->next;
    delete temp;
}

return 0;

}

C

// C program to delete a linked list node at a given // position

#include <stdio.h> #include <stdlib.h>

// Node structure for the linked list struct Node { int data; struct Node* next; };

struct Node* newNode(int data) { struct Node* node = (struct Node*)malloc(sizeof(struct Node)); node->data = data; node->next = NULL; return node; }

// Function to delete a node at a given position struct Node* deleteNode(struct Node* head, int position) { struct Node* temp = head; struct Node* prev = NULL;

// Base case if linked list is empty
if (temp == NULL)
    return head;

// Case 1: Head is to be deleted
if (position == 1) {
    head = temp->next;
    free(temp);
    return head;
}

// Case 2: Node to be deleted is in middle
// Traverse till given position
for (int i = 1; temp != NULL && i < position; i++) {
    prev = temp;
    temp = temp->next;
}

// If given position is found, delete node
if (temp != NULL) {
    prev->next = temp->next;
    free(temp);
}
else {
    printf("Data not present\n");
}

return head;

}

void printList(struct Node* head) { while (head != NULL) { printf("%d -> ", head->data); head = head->next; } printf("NULL\n"); }

// Driver code int main() { struct Node* head = newNode(1); head->next = newNode(2); head->next->next = newNode(3); head->next->next->next = newNode(4); head->next->next->next->next = newNode(5);

printf("Original list: ");
printList(head);

int position = 2;
head = deleteNode(head, position);

printf("List after deletion: ");
printList(head);

// Cleanup remaining nodes
while (head != NULL) {
    struct Node* temp = head;
    head = head->next;
    free(temp);
}

return 0;

}

Java

// Java program to delete a linked list node at a given // position

// Node class to define a linked list node class Node { int data; Node next;

Node(int data)
{
    this.data = data;
    this.next = null;
}

}

public class LinkedList { // Function to delete a node at a given position public static Node deleteNode(Node head, int position) { Node temp = head; Node prev = null;

    // Base case if linked list is empty
    if (temp == null)
        return head;

    // Case 1: Head is to be deleted
    if (position == 1) {
        head = temp.next;
        return head;
    }

    // Case 2: Node to be deleted is in middle
    // Traverse till given position
    for (int i = 1; temp != null && i < position; i++) {
        prev = temp;
        temp = temp.next;
    }

    // If given position is found, delete node
    if (temp != null) {
        prev.next = temp.next;
    }
    else {
        System.out.println("Data not present");
    }

    return head;
}

// Function to print the linked list
public static void printList(Node head)
{
    while (head != null) {
        System.out.print(head.data + " -> ");
        head = head.next;
    }
    System.out.println("null");
}

// Driver code
public static void main(String[] args)
{
    // Creating a static linked list
    // 1 -> 2 -> 3 -> 4 -> 5 -> null
    Node head = new Node(1);
    head.next = new Node(2);
    head.next.next = new Node(3);
    head.next.next.next = new Node(4);
    head.next.next.next.next = new Node(5);

    // Print original list
    System.out.print("Original list: ");
    printList(head);

    // Deleting node at position 2
    int position = 2;
    head = deleteNode(head, position);

    // Print list after deletion
    System.out.print("List after deletion: ");
    printList(head);
}

}

Python

Python program to delete a linked list node at

a given position

class Node: def init(self, data): self.data = data self.next = None

Function to delete a node at a given position

def deleteNode(head, position): temp = head prev = None

# Base case if linked list is empty
if temp is None:
    return head

# Case 1: Head is to be deleted
if position == 1:
    head = temp.next
    return head

# Case 2: Node to be deleted is in middle
# Traverse till given position
for i in range(1, position):
    prev = temp
    temp = temp.next
    if temp is None:
        print("Data not present")
        return head

# If given position is found, delete node
if temp is not None:
    prev.next = temp.next

return head

Function to print the linked list

def printList(head): while head: print(f"{head.data} -> ", end="") head = head.next print("None")

Driver code

if name == "main": # Creating a static linked list # 1 -> 2 -> 3 -> 4 -> 5 -> None head = Node(1) head.next = Node(2) head.next.next = Node(3) head.next.next.next = Node(4) head.next.next.next.next = Node(5)

# Print original list
print("Original list: ", end="")
printList(head)

# Deleting node at position 2
position = 2
head = deleteNode(head, position)

# Print list after deletion
print("List after deletion: ", end="")
printList(head)

JavaScript

// Javascript program to delete a linked list node at a // given position class Node { constructor(data) { this.data = data; this.next = null; } }

// Function to delete a node at a given position function deleteNode(head, position) { let temp = head; let prev = null;

// Base case if linked list is empty
if (temp === null)
    return head;

// Case 1: Head is to be deleted
if (position === 1) {
    head = temp.next;
    return head;
}

// Case 2: Node to be deleted is in middle
// Traverse till given position
for (let i = 1; temp !== null && i < position; i++) {
    prev = temp;
    temp = temp.next;
}

// If given position is found, delete node
if (temp !== null) {
    prev.next = temp.next;
}
else {
    console.log("Data not present");
}

return head;

}

// Function to print the linked list function printList(head) { while (head !== null) { process.stdout.write(head.data + " -> "); head = head.next; } console.log("null"); }

// Driver code let head = new Node(1); head.next = new Node(2); head.next.next = new Node(3); head.next.next.next = new Node(4); head.next.next.next.next = new Node(5);

// Print original list console.log("Original list: "); printList(head);

// Deleting node at position 2 let position = 2; head = deleteNode(head, position);

// Print list after deletion console.log("List after deletion: "); printList(head);

Output

Original list: 1 -> 2 -> 3 -> 4 -> 5 -> nullptr List after deletion : 1 -> 3 -> 4 -> 5 -> nullptr

**Time Complexity: O(n), where n is the number of nodes in the list
**Auxiliary Space: O(1)