Open In App

Delete a Linked List node at a given position

Last Updated : 24 Sep, 2024
Comments
Improve
Suggest changes
Like Article
Like
Report

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



Next Article
Write a function to delete a Linked List
author
kartik
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox