Delete a Linked List node at a given position
Last Updated :
24 Sep, 2024
Improve
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->7Input: 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.
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++ 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 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 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 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)
