Delete a Linked List node at a given position

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 <iostream> 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 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)

Write a function to delete a Linked List

kartik

Improve

Article Tags :

Practice Tags :

Delete a Linked List node at a given position

Similar Reads

Types of Linked List

Basic Operations on Linked List